Constraint to move objects along Local z-axis while following bone?

This was done without bones and only 1 (track-to) constraint for each rocker-arm push-rod.  (Blend file below)

It's only necessary to build and animate one rocker assembly to begin with and that's described below...
The method used to move the valve and only on contact with the rocker-arm is firstly to set the valve's origin point to it's very top center vertice.  An Empty is added at that location to give us a reference point to return the valve to after the parenting process, described immediately below.
The rocker's animation (rotation) is manually keyframed.
It's then stepped a frame at a time until it comes into contact with the top of the valve rod.
The valve is parented to the rocker at that frame (CTL-P) so it's locked to the rocker contact point.
(Child = valve)
Once played the valve's derived action can be then be baked from the frame of first contact up to the frame where it's rising again and parting from the rocker, inclusive.  (in the bake panel tick all option boxes).
The bake leaves us with no parent constraint and a set of keyframes at our disposal.  The X & Y axis' channels can be removed, along with all the rotation and scaling channels.
The only animation channel remaining is Z axis LOC and with the frame range already limited to those of physical contact, the valve will only move straight up and down when in contact with the rocker-arm.
Note -
Blender can introduce extraneous interpolation curves when keyframes are close to each other and these can cause the valve rod to penetrate the rocker's surface slightly. If that's happening noticeably, simply remove the intermediate keyframes between peaks in the Graph editor. That will smooth things out and should leave you with a clean, U shaped curve.  There's only a few KF's to worry about.
Now to the rod that pushes the rocker-arm -
Actually it doesn't do that.  The yellow rocker is keyframed to rotate back and forth and the push-rod is parented to the rocker at the hinge pin.  The push-rod's origin point is set to the hinge-pin's center.
To keep it's other end pointing at a stationary target, it's given a 'Track-to' constraint.  The target is an empty which is sitting directly below but slightly offset along the X axis to prevent it wanting to spin 180 degrees with each half cycle.

To hold it all together so the whole thing can be moved/rotated and even scaled without ill-effect, a
'Nav(igation) Empty'  (the large circle)  acts as a Master parent for the rocker, valve, and 'track-to' empty, along with the main shaft that will support all the rocker-arms.
It's the Nav-Empty that's pulled around the scene, rotated etc. not the components.

Once the first assembly is working, it's duplicated and their timing and locations offset to suit.  Make sure you DON'T include the Nav-empty or main shaft when duplicating


How to UV unwrap an object on every frame?

The most important thing here is to active "Load UVs" wich is deativated by default in the "Mesh Object Input" Node. Then you can Insert your UV Map via node as seen in the screenshot. The material itself should be copied to your target automaticly.
Animating the vertices via vector-wiggle does not change/mess up your UVs, but they will stay the same. So your applied texture should work out of the box.
(there is also a small redundancy fix in the tree from the tutorial ;) )


As with most software, the keyboard shortcut to save a file is ⎈ Ctrl+S. A new window will open to navigate to wherever you want to save in your computer and specify the name the name of the file.

An alternative using the menu pressing file>save.


Python API, get bezier points taking into account shape key values

You can create a shape key that is the mix of the current shape keys (as it is accessible from the shape key menu).

From it get spline info.

Then delete this shape key which was created only for that purpose.

Something like:

import bpy

curve = bpy.context.object

# Add a new shape key that is a mix of the existing one
bpy.ops.object.shape_key_add(from_mix=True)

# Get the last shape key
shape_key = curve.data.shape_keys.key_blocks[len(curve.data.shape_keys.key_blocks)-1]

# Get the info you want
for sk in shape_key.data:
    print( sk.co )
    print( sk.handle_left )
    print( sk.radius )

# Remove the shape key
bpy.ops.object.shape_key_remove( all = False )


How can I apply a texture to a single mesh face?

In vertex edit mode, mark seams, uv project, add texture, use the uvmap setting.
Seams are difficult to see.  They are necessary to get separation of faces for free movement of the image plane off the uv image editor
In uv editor only the target face should remain on the image area, all other faces can be moved to the side
Material Texture .. Image Mapping Extension must be << Clip >>
In the images below a cube has been modified and the target face is shaped into a trapezoid.  The base color is red.   Only one face has the texture.


K_Horeman's answer helped me fix it:
https://blenderartists.org/t/noob-weird-selection-issues-cant-select-vertices-of-a-mesh-in-edit-mode/622979/2
"If it’s selected in orange with no vertices when you’re in edit mode, it is a separate object. You’ll have to go to edit mode on that object. You can only be in edit mode on one object at a time."
I didn't have the correct mesh selected in the Viewer (top-right) before entering Edit mode. So I highlighted all 4 objects you see in the picture, and I can select their vertices.


Focusing the graph editor area to a custom [frame, keyframe_value] range

Scrollbars aren't exposed to Python, you can't check or change their scroll position in a script.


Equivalent color settings in Blender with Autodesk Navisworks

Expanding my comment above: yes, you're using Blender Render.

About 1)

Ambient color should be what is set in the World settings, here:

And you can level the amount of ambient each material gets with this:

see also
https://www.blender.org/manual/render/blender_render/materials/introduction.html

About 2) I think you need to set your material's specular:

You can choose color, intensity, shader type, and you can also use a custom-defined color ramp, if needed, here:

See whole reference here: https://www.blender.org/manual/render/blender_render/materials/index.html

Of course, being Blender Internal a scanline renderer, it is not targeted to ultra-realistic results.

I don't know Navisworks at all, so it could be a similar system, or not. Maybe others will help better than me in this respect.

Blender's Cycles, instead, is a very good PBR renderer and it allows ultra realistic results, if needed, but its materials are completely different, and based on nodes - in that case, start here: https://www.blender.org/manual/render/cycles/materials/index.html


Why is my blueprint not visible as a render?

Edge lines between vertices don't have any volume, so they can't be seen. You can use a wireframe modifier to add thickness to the lines, also make sure you have some sort of light in the scene or it might be too dark to see.


How to X-Mirror weight paint of "Weight Gradients" to .R/.L bones in Blender

CHECK 1: Is your armature containing all the bone hierarchy correctly to "DEFORM" from either side to side? It looks like you don´t have vertex groups correctly assigned from one of your sides. First, identify which side is the one working (I would assume it´s the bone.L side that´s working).

You want to mirror that weight paint groups onto the RIGHT side, go onto:

CHECK 2: Once you identify, which one is the current working side, you´ll want to MIRROR it onto the other side. For that you´re going to use a MODIFIER VERTEX WEIGHT MIX.

The basics are simple: Create a vertex group from your weight paint mode while selecting your character. Then go to your vertex groups (here on the pictures you see a green.L side and a pink.R side) and create vertex groups for your LEFT and RIGHT side of the body (or whatever you want to mirror weights from). Then with the modifier you´ll want to select those vertex groups. One will transfer ONTO the other. So make sure you create a duplicate of the VERTEX group that is CURRENTLY WORKING (you don´t want to loose it in case something goes wrong).
Once you identify the correct .L or .R weight working you want to transfer it to the one that´s NOT working with 1 as influence. While in weight paint mode you may want to click the SHOW VERTEX button to make your life easier.

So once you create your new vertex groups (green.R, purple.L on my picture) you´ll want to transfer the weights. So go out to OBJECT MODE again, use the MIX WEIGHT MODIFIER, now select your vertexGroup.L and vertexGroup.R and set the transfer mode to ADD (because your left side or your right side need to influenciate fully the side that´s not working).

Finally the last option to check is the button: MIX SET (Vgroup A and B).
This means that when the transfer is over, the state in which your group is going to be ending up influenced by the vertexGroup you choose will dominate (will be the one you choose here).
If you leave alone this option alone, you end up with a simple mix (a+b). Try other options if it suit your purposes.

The final process will yield a Vertex group that is working, one that´s not working (this is expected) and another one that has the mix of both Vertex groups (this is expected).

Fill the names of the vertex groups. Hit apply. You now have mirrored (transfered mix) weights.

Well, that about explains it all. Every parameter covered. Let me know about the bounty. Cheers.


composition- managing distant view of large objects

I think the main issue here is simply the viewpoint - in your scene the camera is actually about 54m above the surface of the lake; Suzanne is scales at 38m. As we (as humans) are used to viewing the world from about 1.5m above the 'floor', this throws out the perspective, giving the impression of a much smaller scene.

By simply moving the camera to about 2m from the surface of the lake you can get a much better perspective, making the mountains look much more distant :

Note that for added effect you could add a mist-pass in the compositor or blur based on distance for more realism.


Cycles rendering mode crashes the entire program AMD OpenCL

Posted this in an AMD forum Users Post:
Re: In 2021,Why AMD GPU Still Sucks On Cycles?!
I think I might have found a so-called hack to get the 'Indirect_Background' one to work.

Start with initial default cube. Mainly so that Blender will recover faster.
Add a HDRI (don't really know if you have to).
Switch from 'Solid' view to 'Mat Preview' then switch to 'Render' view. Now I think it does start to hang, but immediately switch back to 'Mat View' and wait for it to clear its self up. Then switch back to 'Render' view.
Hit F10 while still in 'Viewport' (may not have to do this, but was in 'Mat Preview').
Go to Render tab and watch the magic happen (hopefully).

I don't think I've forgotten anything. You can then open another file and everything should still work. Even on start up.
*** Updated to Adrenaline 21.4.1, repeated what's above and it still works ***


The "period key" next to the zero not there on a laptop

Not sure what the key is called- maybe the Accent key?  Followed by #3.  See below.


Subsurface modifier creates gaps on extrude

This happens because has a face betweeen those. You need to delete that face.However this is not a normal behavior.


Is it possible to put an if statement into the scripted expression of a driver?

A Python expression you can use is:

valueIfTrue if isConditionTrue else valueIfFalse

This is known as a ternary conditional operator see:
https://stackoverflow.com/questions/394809/ternary-conditional-operator-in-python


How to make part of an object solid like a cut?

You can do this with supporting geometry. Make a loop cut Ctrl+R around the middle of the plate and slide it towards the center until it's close but not touching the center ring.

If your center section is flat like in my example, you can add a loop cut to the center of that. Then select it and bevel it using Ctrl+B to make it 2 loops that fit both the inner and outer ring.

Do this as well for the inner and outer "sides" of the bottom rim.

You may also need to select the center bottom face and inset it slightly. The reason this works is that Subdivision Surface and flat shading takes the "average" between two faces and rounds the result accordingly. The smaller the faces are, and the closer they are together (such as those clamped in by edge loops) the less area there is to round, and are therefore the edges look "sharper". There are other ways of achieving this, such as selecting edges, and selecting "mark sharp", however I feel it's probably best to learn how the supporting geometry works first.

Lastly, just finish it off by giving it a shiny material.


An application handler could be used to read subtitle data from your simulation module and display it by editing a text object.

import bpy
from bpy.app.handlers import persistent

@persistent
def frame_change(arg):
    print("Load Handler:", bpy.data.filepath)
    t = bpy.data.objects["Text"]
    # here get the text you want to display
    label = ("Frame # %d" % bpy.context.scene.frame_current)
    t.data.body = label

bpy.app.handlers.frame_change_pre.append(frame_change)


How to procedurally deform shape of an object?

Add a Displace modifier to the object, set the texture coordinates to "object". Add an empty and set it in the object field. Set the strength to a low value (0.1 for example) and set the direction to "RGB to XYZ".
Add a texture in the modifer, and click on the far right icon of the texture field, alternatively click on the checker icon on the bottom of the properties.

Set The texture type to clouds, and the color from grayscale to color. Up the size a little bit. (depends on the real scale of your object)

If your object doesn't deform correctly, you should make sure to have a dense enough mesh. Add a subdivision modifier before the displace modifier and set the divisions to 1 or 2.

Now move your empty object in the scene and the object should deform.


I have been having an issue with proportional editing

It's a bit hard to tell what's going on ... (We can't read your mind, what is 'the doughnut in tutorial 2.'?).. but 2 points might help.

G and GG are different operations. G is Grab, a free translation in screen space. GG is Vertex Slide, which will slide selected vertices down adjacent edges. G can be proportional. Proportional Editing has no effect on GG.
When editing proportionally, you should be able to see a circle in the viewport representing the radius of the falloff. If you can't see it, and the whole object moves, the falloff is large enough to encompass all the object's vertices, and may be so large it is off-screen. Try using the scroll-wheel to bring it down into view.


continuous sequence of frames with multiple cameras with each camera starting at start of animation?

You could use the Multi-View Render Layer functionality to simultaneously render from multiple cameras to files and then stitch them together in the compositor.
Start by creating and positioning your cameras. Ensure they all have the same name with the exception of a suitable suffix - eg, 'Camera_L' for left, 'Camera_R' for right, 'Camera_T' for top. In the Render Layers tab, enable Views and create an entry for each camera with a matching suffix for each view (ie, '_L' for left, '_R' for right, '_T' for top).

Now when you render the scene Blender will render a separate image for each camera. To view the individual images you need to disable the Stereo 3D option and select the channel using the selection box.

When rendering the animation you will now get multiple renders per frame - each will be produced with a filename including the camera suffix. For example, rendering to EXR :
0001_L.exr
0001_R.exr
0001_T.exr
0002_L.exr
0002_R.exr
0002_T.exr
0003_L.exr
0003_R.exr
0003_T.exr
0004_L.exr
0004_R.exr
0004_T.exr
....

(rendering to PNG produces similar filename output)
The separate frames can now be used in the compositor using Image nodes with suitable filename and offset, along with logic to mix between them based on the frame :

The compositor nodes have three separate images, each set with a different start frame so, in this case, the first 50 frames are using the first set of images (from one camera), after frame 50 the Mix nodes select the second set of images and after frame 100 the third set.
Note the maths nodes use the presence or not of an Alpha channel to determine which image to merge into the output to automatically select the relevant image. If the alpha channel is in use for transparency then you will need to use the frame number via a driver (enter ‘#frame’ into a Value field) or another method (eg, keyframes) to determine which image to use.
Here is the final result :

Note that Suzanne is only being rotated once through 360 degrees, but rendered from each camera and combined to show each view in turn.
Blend file included (note that there are two scenes - one for the render and a separate one for compositing (required due to the different number of frames - 50 for the render and 150 for the compositor pass)).

just a hint for newer Blender versions:
you can find in Output properties -> Stereoscopy


You could do it this way:

Create your road section, subdivide it a bit:

Create your road profile with a curve.
In Edit mode, enable the normals display and make sure that the direction is correct, otherwise press W > Switch Direction:

Select your road section and put it at the same point as the curve origin (select the curve, then ShiftS > Cursor to Selected, then select the mesh and ShiftS > Selection to Cursor):

Give your road section an Array modifier, choose the amount of iterations (Count value), enable the Merge option.
Give your road section an Curve modifier, choose the curve as Object. The object will follow along the curve. You can add a Subdivision Surface and click Smooth Shading to smooth it.

Now let's imagine that you want a bumpy terrain:

Create your terrain, create your curve, subdivide your curve a bit:

Give your curve a Shrinkwrap modifier so that it follows the terrain relief. Apply the modifier:

Follow the same steps as before, create a road section and make it follow the curve:

Once you are about glad, apply the Array and the Curve modifiers and bring some corrections manually to make a correct topology and to make it stick nicely to the terrain:

Last possibility: You need the road to be flat on a bumpy terrain. In that case you can use a Shrinkwrap modifier on the terrain so that it sticks to the road, then smooth its topology in Sculpt mode, see here.


Can't write bmesh object back to mesh datablock

The mesh me must not be in edit-mode when writing the bmesh object bm back to me - like the error message tells you:

  ValueError: to_mesh(): Mesh 'Cube' is in editmode

So, either run the code when the mesh is in object mode, respectively change the mode: bpy.ops.object.mode_set(mode='OBJECT')

Or use a wrapped bm, which means to directly manipulate the editmode mesh through the bmesh module:

import bpy
import bmesh

me = bpy.context.object.data

bm = bmesh.from_edit_mesh(me)

for v in bm.verts:
    v.co.x += 1.0

# Update mesh, so we see the changes.
bmesh.update_edit_mesh(me, False, False)

# Because we did not add or remove geometry,
# tessface=False and destructive=False can be used.
# DO NOT DO THIS IF YOU CHANGED GEOMETRY!
# Blender will crash otherwise.

As you see, you can either fill in a mesh, manipulate it (purely in memory, the original mesh is not changed) and write it to a mesh datablock afterwards if desired OR gain access to the editmesh and edit it directly with all changes being applied to the original mesh without copying (the update at the end is required though).

You can chose which way to use based on the current mode to avoid unnecessary mode switches:

import bpy
import bmesh

me = bpy.context.object.data

if me.is_editmode:
    bm = bmesh.from_edit_mesh(me)
else:
    bm = bmesh.new()
    bm.from_mesh(me)

for v in bm.verts:
    v.co.x += 1.0

if bm.is_wrapped:
    bmesh.update_edit_mesh(me, False, False)
else:
    bm.to_mesh(me)
    me.update()

BTW: update is a method of the Mesh type, you need to call it: me.update()


How can I let the User draw a curve in BGE while playing?

Trail Object

This object represents a single step on the trail. The x-dimension should be exactly 1.0. Make it "no collision" in physics tab to avoid interaction with other objects.

To appear as a line use plan that gets scaled to 0 on the y-axis. Give it a material with wire frame to make it visible with exactly one pixel width. It should reside on an hidden layer (otherwise add object will not work).

Trailed object

Is the object that should leave a trail. Typically you add one trail per step. Then align the trail to the last position of the trailed object and change the size that it completely fills the step.

The script can be like that:

import bge

INTERNAL_PROPERTY_LAST_POSITION = "_last.position"

AXIS_X = 0

controller = bge.logic.getCurrentController()

owner = controller.owner

lastPosition = owner.get(INTERNAL_PROPERTY_LAST_POSITION)
currentPosition = owner.worldPosition.copy()
owner[INTERNAL_PROPERTY_LAST_POSITION] = currentPosition

if lastPosition is not None:
    direction = lastPosition - currentPosition
    for actuator in controller.actuators:
        actuator.instantAddObject()
        trail = actuator.objectLastCreated

        trail.alignAxisToVect(direction, AXIS_X)
        trail.worldScale = 3*[direction.length]

Result

Remarks

This creates quite a lot of trail objects. At a certain number it will cause lags.
You can increase the step size by increasing "skip" at the always sensor of the trailed object. It creates less objects but results in less precise trailing and a small delay.
trail objects with a bigger width can result in overlapping and gaps. This depends on the shape and material.


You applied the modifier, that's why.

I only have a short time to explain, but I'll try:

Modifiers are non-destructive while they have been added to an object, but not yet applied. Once a modifier is applied, the effect is committed to the mesh permananetly. It's kind of like flattening layers in GIMP or Photoshop. It's a one-way street.

There are times when you want to apply a modifier and times when you don't. If, for example, you had sculpted a symmetrical body using the Mirror Modifier, but then wanted to sculpt spikes on just one arm, obviously you would want to apply the modifier and then do the non-symmetrical parts.


Blender 2.8 bake node displacement as UV

The correct way of using Displacement in Material Output node is through Displacement node (Vector->Displacement) and connecting image to the Height input. But even that way I believe Displacement in node editor doesn't work in Eevee, only in Cycles in rendered view. In Eevee it only shows up as bump. The only way to get Displacement in Eevee is by using Displace modifier.

Clarifications for baking color:

Then you click New on Image Texture to create new texture. Switch Render Engine to Cycles, set options for baking color:

Click Bake, wait to complete, then get to image editor where you select your image from dropdown at the top and save it as (Shift+S).


Blender 2.80+ Game Engine Replacement with Python

At some point in time, an "interactive mode" was in discussion/announced. But it seems this was dropped, according to a statemen at Blender Conference 2019. You can check some discussion at Blenderartists:

https://blenderartists.org/t/any-news-on-blender-2-8-interactive-mode/1178594


How to show out of bounds texture from a modulo operation

The idea is to work at a given scale, so that the pattern will repeat and using a random (noise) at this scale (each cell will correspond to a random color).

Now imagine the result as a grid, the idea is:

For each cell we want to draw
We take all the 8 cells around it
And have a look if we need to draw something from these 8 cells inside the cell we want to draw (the one at the center of the 8 others)

What is done for each of these 8+1 cells is to offset and rotate the pattern with the random values, transfer the result in the central cell and look if it's inside the central cell surface.

Globally, this is some kind of 3x3 convolution and in consequence, the node setting is the repetition of 9 same figures:

If we go into more details:

The inputs are:

Texture coordinates
The scale at which we want to repeat the pattern
A tuning for the random offset
A tuning for the rotation

The final position is calculated by two node groups which multiply the input coordinates by the scale, then take the modulo 1 of it, so that the final result is between 0 and 1 (as the texture coordinates are between 0 and 1).

On the other part, we have 9 node groups on the left, which are here to calculate the randomness. It takes into account the input parameters and incorporate a noise texture.

Also, there is X and Y inputs: each of the 9 nodes has X, Y inside the pairs (-1,-1), (-1,0), (-1,1), (0,-1), (0,0), (0,1), (1,-1), (1,0), (1,1), to go through all the 9 cells we talked about at the beginning.

The goal of this node group is to result in the wanted random value, offset(ed) by the coordinate of the (X, Y) pairs in input.

Inside of it:

We take X and Y at the scale (X/scale and Y/scale)
Add the input coordinates as X/scale and Y/scale is the delta we want
Input that in NoiseDiscretize which is a noise mosaic at the given scale
Then add this random to the input: X and Y are offset(ed) and Z will be considered as the random rotation

The NoiseDiscretize goal is to ouput random value at the scale we want. The result is centered (we want output between -1 and 1).

Back at top level, we now have the random deltas we want + the cell to draw in at the good scale. We now mix that to get the color for each cell from the center cell point of view. PickColor node group does that:

Inside of it, we have:

The calculation of the rotation of the input vector, taking Z from the random input.
Then we input that in the pattern texture
But we'll keep a default color if the resulting coordinates are not between 0 and 1 (as if not this cell must not be drawn in the central cell).

Important: the pattern texture node interpolation is set to closest (if not border lines may appear).

Finally, the nine results are mixed by a mix rgb node using the darken operation at 100%.

Blend file for 2.8:

Note: I feel this kind of setting painful. But the bad is really that we need to duplicate the input pattern texture, as there is no way to have it as a parameter. And so the setting can not be reused easily.

But maybe another answer will solve this problem?


Where is the UI menu option for "Separate by loose parts"?

Make sure that you're presing P in edit mode, not object mode.
If that doesn't work you can find the separate action here (Mesh > Vertices > Separate > By loose parts):

You can check if the configuration is right on File > User Preferences > Input and search for "separate" and look on "mesh":


IK + Pole Target {Rig} is =//= Twisting my Characters Mesh

Turning on Axes for the bones can be really helpful when things twist, and/or before parenting mesh to rig. Like it seems in your case, the twist occurs when you parent mesh to rig with Auto-Weights.

I suspect a complete bone rotation in Y axis in one step, (Y axis is Up for bones)

So probably step 1 can solve it, step 2) 3) are more indepth regarding IK.

What happens if you change IK Solver to iTaSC

Sometimes adding stiffness can solve at least weird rotational behaviour.


Change a mesh to a specific number of faces

You can try a Quadriflow Remesh (in the object Data Properties tab). Pick quad and select Quad and then hit the Remesh button:

Before it performs the operation, it brings up an options window where you can select, among other things, the target number of faces:

The results aren't always super pretty, and I only think I've seen once when it was able to remesh to the exact number of faces I targeted, but the algorithm generally selects what is best for the mesh (mathematically at least) and is usually pretty close to the target number. If the objects you are starting with (the different skulls) are relatively similar, they should produce quite similar results. At the very worst you will have to add or remove <30 faces manually.


You can use the knife tool to create vertices inside of it, press K and start creating the vertices, conecting it with the outside ones. Other option is to select this face and press CTRL + T to triangulate it and make more vertices on it, but the knife tool is better


Add-on Viewport to SVG can do this ... and many other things.
Tested with Blender 2.92 (2.93 will need attention ...)

Edit: Any add-on contains location info ... 3D View Editor > Sidepanel N > SVG tab


It seems you have high-dpi screen. If this is the case, see here: Make Blender usable on high resolution screen.

In a nutshell, go to Preferences -> System -> DPI. Play around with the value until you are comfortable. If that isn't enough, see the link.

To actually answer your question: they are tiny, because they are fixed to a pixel size and your pixels are tiny.


Set Custom Toggle Hotkey for Grease Pencil Stroke Tools not Working?

The toggle hotkey has to be created in Window context rather than GreasePencil(Global).


Can I control the visibility of edges in a cycles wireframe?

One simple way to do it is the following:

Mark the edges as Freestyle Edges
Enable Freestyle
Configure Freestyle to only show marked edges
Configure the Freestyle line style to set the thickness and color

EDIT If you want thinner lines on objects that are far away, see this question: How to make freestyle lines stay the same size?


My rotation driver variable loses a value greater than 180 degrees

Auto Euler works the way I want.
It supports rotation values greater than 180.
Quaternion or other Euler options work with a 180 degree limit.
Depending on the situation, you may be able to use Auto Euler or other axis options.


How to weight all vertices for a selected bone?

Delete the vertex group, select the bone again, and Paint.
Blender will  create a new Empty vertex group for you.

Vertex group Bone.001 is on the right side of image.  It is deleted on the left side.

By continuing to paint Blender created a new vertex group.


the answer to that is "face sets", it has actually already been answered here:
part of the mesh become yellow when in sculpt mode


How Can I Use a Procedural Bump Map to Replicate a Natural Pattern?

To align the texture along the direction of the mesh requires a UV map and this needs to be unwrapped in such a way that each face is oriented along the line of the antler. Further, to avoid a 'seam' along the length of the mesh requires that a seamless texture is used and that the UV map unwrapping ensures that the edges of the UV map align. The right UV map and a seamless texture can produce the following :

Manually unwrapping such a mesh while keeping the faces correctly aligned and joined at the seams would be quite complicated and time consuming - unwrapping the splits while keeping the orientation and the seams would be particularly difficult. Fortunately, Python can do the unwrapping for us.
Starting with a mesh created using the Skin modifier :

The 'texture' needs to run from one end of the antler (the 'root) to the tips. Create two new vertex groups (one for the 'start' and the other for the 'end') and assign the relevant vertices to each. For the example above I marked the vertices around the 'root' of the antler as 'START' and those at the tips as 'END'. The texture will be spread over the mesh using those points as anchors.

Next, create another vertex group ('seam') and assign vertices along the length of each 'branch' to it. This will be the 'seam' of the texture as it's wrapped around the mesh. You can experiment with different seams to get twists and different patterns for the split but the pattern shown below works quite well.

To give further control at the boundaries of branches you can allocate vertices to a 'crease' vertex group. This will effectively block the influence of the 'seam' to prevent one branch's seam from affecting the next. You may need some experimentation for this - depending on your geometry and chosen seam. In my case I simply 'capped' the end of each seam.

Open a Text Editor window and paste the following code (Blender versions prior to 2.80 - for later versions, see EDIT further down post) :
import bpy
import bmesh

group_vertex_cache = []

def color_vertices_rgb(obj, numpasses, target_delta, grp_start, grp_end, grp_seam, grp_crease):
    """Uses the Vertex Groups to assign each vertex UV coordinates, blended across the mesh"""

    bpy.ops.object.mode_set(mode='OBJECT')
    bpy.ops.object.select_all(action='DESELECT')
    obj.select = True
    bpy.context.scene.objects.active = obj
    bpy.ops.object.mode_set(mode='EDIT')

    obj.update_from_editmode()

    mesh = obj.data
    scn = bpy.context.scene

    scn.objects.active = obj

    start_vertices = []     # Start RED
    end_vertices = []       # End RED
    seam_vertices = []      # GREEN
    crease_vertices = []    # Block influence
    vert_colors = {}
    vert_links = {}

    global group_vertex_cache
    init_group_vertex_cache(obj)

    # Get a count of loop verts and create an array to hold the details
    loopvert_count = len(obj.data.loops)
    loopverts = [0] * loopvert_count

    print('Capturing...')
    # Process each loop vert and collect all the data we require
    for polygon in obj.data.polygons:

        loopidxpos = -1
        for loopidx in polygon.loop_indices:
            loopidxpos = loopidxpos + 1

            loopvertrec = {}

            # Determine which loop verts are to the left and right of this one
            if loopidxpos == 0:
                left  = polygon.loop_indices[len(polygon.loop_indices) - 1]
                right = polygon.loop_indices[loopidxpos + 1]
            elif loopidxpos == (len(polygon.loop_indices)-1):
                left  = polygon.loop_indices[loopidxpos - 1]
                right = polygon.loop_indices[0]
            else:
                left  = polygon.loop_indices[loopidxpos - 1]
                right = polygon.loop_indices[loopidxpos + 1]

            loopvertrec['left']  = left
            loopvertrec['right'] = right
            loopvertrec['left-dist'] = get_edge_length(obj, loopidx, left)
            loopvertrec['right-dist'] = get_edge_length(obj, loopidx, right)

            # get list of loops verts that make up the same vert as this one
            loopvertrec['shared-loop-verts'] = get_loop_verts(obj, loopidx)

            #...get whether it's in each of the 'groups' (ie, start, end, seam, crease) - and the associated weight (assume weight 0 if not in group)
            loopvertrec['start-weight'] = get_group_weight(obj, grp_start, loopidx)
            loopvertrec['end-weight'] = get_group_weight(obj, grp_end, loopidx)
            loopvertrec['seam-weight'] = get_group_weight(obj, grp_seam, loopidx)
            loopvertrec['crease-weight'] = get_group_weight(obj, grp_crease, loopidx)

            #loopvertrec['color'] = get_loopvert_color(obj, loopidx)

            loopverts[loopidx] = loopvertrec
            print(str(loopidx))

            vert_colors[loopidx] = [0.5,0.5,0.5]

    print('Captured.')

    new_colors = {}
    print('Processing....')
    for p in range(0, numpasses):
        print("Pass "+str(p+1)+" of "+str(numpasses))

        maxdelta = 0

        for v in range(0, len(loopverts)):

            loopvertrec = loopverts[v]

            start_weight  = loopvertrec['start-weight']
            end_weight    = loopvertrec['end-weight']
            seam_weight   = loopvertrec['seam-weight']
            crease_weight = loopvertrec['crease-weight']

            # Generate Red, Green, Blue based on weights and spread over mesh. Red will be used to generate U, Green/Blue to generate V

            # Average colors with neighbours
            r = (vert_colors[v][0] + vert_colors[loopvertrec['left']][0] + vert_colors[loopvertrec['right']][0]) / 3
            g = (vert_colors[v][1] + vert_colors[loopvertrec['left']][1] + vert_colors[loopvertrec['right']][1]) / 3
            b = (vert_colors[v][2] + vert_colors[loopvertrec['left']][2] + vert_colors[loopvertrec['right']][2]) / 3

            average_this_loop = [r, g, b]

            for v2 in loopvertrec['shared-loop-verts']:
                r = r + (vert_colors[v][0] + vert_colors[loopverts[v2]['left']][0] + vert_colors[loopverts[v2]['right']][0]) / 3
                g = g + (vert_colors[v][1] + vert_colors[loopverts[v2]['left']][1] + vert_colors[loopverts[v2]['right']][1]) / 3
                b = b + (vert_colors[v][2] + vert_colors[loopverts[v2]['left']][2] + vert_colors[loopverts[v2]['right']][2]) / 3

            average_all_loops = [r / (len(loopvertrec['shared-loop-verts'])+1),g / (len(loopvertrec['shared-loop-verts'])+1),b / (len(loopvertrec['shared-loop-verts'])+1)]

            # CREASE
            r = average_all_loops[0]
            g = average_this_loop[1] * ( crease_weight ) + average_all_loops[1] * ( 1.0 - crease_weight )
            b = average_this_loop[2] * ( crease_weight ) + average_all_loops[2] * ( 1.0 - crease_weight )

            r = r * (1.0 - end_weight)                          # END
            r = r * (1.0 - start_weight) + 1.0 * start_weight   # START

            # Determine the left/right side of the seam based on direction of 'red'
            if (vert_colors[loopvertrec['left']][0] > vert_colors[loopvertrec['right']][0]):
                leftness = 1.0
            elif (vert_colors[loopvertrec['left']][0] < vert_colors[loopvertrec['right']][0]):
                leftness = 0.0
            else:
                leftness = 0.5

            g = g * (1.0 - seam_weight) + leftness * seam_weight

            # store it
            if len(new_colors)>v:
                vertdelta = abs(new_colors[v][0]-r) + abs(new_colors[v][1]-g) + abs(new_colors[v][2]-b)
            else:
                vertdelta = abs(r) + abs(g) + abs(b)

            if vertdelta > maxdelta:
                maxdelta = vertdelta

            new_colors[v] = (r,g,b)

        print(maxdelta)
        if maxdelta < target_delta:
            break

        #Copy new colors back to vert_colors
        for i in range(0,len(loopverts)):
            vert_colors[i] = new_colors[i]

    # Generate UV map - must be in EDIT mode for this

    bm = bmesh.from_edit_mesh(obj.data)
    uv_layer = bm.loops.layers.uv.verify()
    bm.faces.layers.tex.verify()

    for f in bm.faces:
        for l in f.loops:
            luv = l[uv_layer]

            r = vert_colors[l.index][0]
            g = vert_colors[l.index][1]
            b = vert_colors[l.index][2]

            luv.uv = (r, g)

    bmesh.update_edit_mesh(obj.data)
    bpy.ops.object.mode_set(mode='OBJECT')

###########################################################################################################################

def get_edge_length(obj, loopidx1, loopidx2):

    vert1 = obj.data.loops[loopidx1].vertex_index
    vert2 = obj.data.loops[loopidx2].vertex_index

    for edge in obj.data.edges:
        if (edge.vertices[0] == vert1 and edge.vertices[1] == vert2) or (edge.vertices[0] == vert2 and edge.vertices[1] == vert1):

            OWMatrix = obj.matrix_world
            v1Pos = OWMatrix * obj.data.vertices[vert1].co
            v2Pos = OWMatrix * obj.data.vertices[vert2].co

            dist = (v1Pos - v2Pos).length

            return dist

    return 0.0

###########################################################################################################################

def get_loop_verts(obj, loopidx):
    loopverts = []
    vertidx = obj.data.loops[loopidx].vertex_index

    idx = -1
    for loop in obj.data.loops:
        idx = idx + 1
        if loop.vertex_index == vertidx and idx != loopidx:
            loopverts.append(idx)

    return loopverts

###########################################################################################################################

def get_group_weight(obj, group, loopidx):

    groupindex = obj.vertex_groups[group].index
    vertidx = obj.data.loops[loopidx].vertex_index

    global group_vertex_cache

    for v in group_vertex_cache:
        if v.index == vertidx:
            for g in v.groups:
                if g.group == groupindex:
                    return g.weight

    return 0.0

###########################################################################################################################

def init_group_vertex_cache(obj):

    global group_vertex_cache

    for v in obj.data.vertices:
        if len(v.groups) > 0:
            group_vertex_cache.append(v)

###########################################################################################################################

#Invoke it
color_vertices_rgb(bpy.context.scene.objects["Antler"], 1250, 0.0001,'START', 'END', 'SEAM', 'CREASE')

Note the last line of the script which invokes the function on your mesh. This should be amended to specify the name of your mesh and the other arguments as follows :
color_vertices_rgb(bpy.context.scene.objects["<meshname>"], <iterations>, <mindelta>, '<start>', '<end>', '<seam>', '<crease>')

Where meshname is the name of your mesh, iterations is the number of steps to run the 'average' spread algorithm, mindelta is the minimum acceptable change in UV coordinates (if it reaches that then it will decide it's finished regardless of iterations - if unsure, set to 0), start, end, seam, crease are the names of the 4 vertex groups mentioned above. Run the script - it might take a while depending on the complexity of your mesh and the chosen number of iterations (more will produce better results but will take longer). If you have a command-line console window open it will output progress and diagnostics.
This works by allocating UV coordinates (which can be represented as 'colors' - Red being equivalent to 'U' and Green being equivalent to 'V') to each of the vertices in the groups and spreading them across the mesh by averaging them with their immediate neighbours.

Note that the Red is strongest at the root and fades out towards the tips while the green is strongest at the left-hand edge of the seam and fades around the circumference of the mesh.
Once the processing is complete you should have a UV Map that you can use for your texture and this can be used with a seamless image texture if desired - although depending on the texture used, this isn't strictly necessary if the texture is already quite linear since it effectively hides the seam. For example, here's a simple Musgrave texture, scaled in one direction using a Mapping node.

Combine multiple textures at different scales for a more interesting surface.

This can now be used to drive the Bump node and adjusted to get the desired effect.

Blend file attached

EDIT for Blender 2.80+ (changes to API): At later Blender versions the API function calls for some operations has changed. Here's an updated script that works at later releases (tested on 2.91).
import bpy
import bmesh

group_vertex_cache = []

def color_vertices_rgb(obj, numpasses, target_delta, grp_start, grp_end, grp_seam, grp_crease):
    """Uses the Vertex Groups to assign each vertex UV coordinates, blended across the mesh"""

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

    #For 2.80+, changed API for selecting object
    #obj.select = True
    obj.select_set(state = True)

    #For 2.80+, changed API to set active object
    #bpy.context.scene.objects.active = obj
    bpy.context.view_layer.objects.active = obj

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

    obj.update_from_editmode()

    mesh = obj.data
    scn = bpy.context.scene

    #2.80+ this isn't necessary (already made it 'active')
    #scn.objects.active = obj

    start_vertices = []     # Start RED
    end_vertices = []       # End RED
    seam_vertices = []      # GREEN
    crease_vertices = []    # Block influence
    vert_colors = {}
    vert_links = {}

    global group_vertex_cache
    init_group_vertex_cache(obj)

    # Get a count of loop verts and create an array to hold the details
    loopvert_count = len(obj.data.loops)
    loopverts = [0] * loopvert_count

    print('Capturing...')
    # Process each loop vert and collect all the data we require
    for polygon in obj.data.polygons:

        loopidxpos = -1
        for loopidx in polygon.loop_indices:
            loopidxpos = loopidxpos + 1

            loopvertrec = {}

            # Determine which loop verts are to the left and right of this one
            if loopidxpos == 0:
                left  = polygon.loop_indices[len(polygon.loop_indices) - 1]
                right = polygon.loop_indices[loopidxpos + 1]
            elif loopidxpos == (len(polygon.loop_indices)-1):
                left  = polygon.loop_indices[loopidxpos - 1]
                right = polygon.loop_indices[0]
            else:
                left  = polygon.loop_indices[loopidxpos - 1]
                right = polygon.loop_indices[loopidxpos + 1]

            loopvertrec['left']  = left
            loopvertrec['right'] = right
            loopvertrec['left-dist'] = get_edge_length(obj, loopidx, left)
            loopvertrec['right-dist'] = get_edge_length(obj, loopidx, right)

            # get list of loops verts that make up the same vert as this one
            loopvertrec['shared-loop-verts'] = get_loop_verts(obj, loopidx)

            #...get whether it's in each of the 'groups' (ie, start, end, seam, crease) - and the associated weight (assume weight 0 if not in group)
            loopvertrec['start-weight'] = get_group_weight(obj, grp_start, loopidx)
            loopvertrec['end-weight'] = get_group_weight(obj, grp_end, loopidx)
            loopvertrec['seam-weight'] = get_group_weight(obj, grp_seam, loopidx)
            loopvertrec['crease-weight'] = get_group_weight(obj, grp_crease, loopidx)

            #loopvertrec['color'] = get_loopvert_color(obj, loopidx)

            loopverts[loopidx] = loopvertrec
            print(str(loopidx))

            vert_colors[loopidx] = [0.5,0.5,0.5]

    print('Captured.')

    new_colors = {}
    print('Processing....')
    for p in range(0, numpasses):
        print("Pass "+str(p+1)+" of "+str(numpasses))

        maxdelta = 0

        for v in range(0, len(loopverts)):

            loopvertrec = loopverts[v]

            start_weight  = loopvertrec['start-weight']
            end_weight    = loopvertrec['end-weight']
            seam_weight   = loopvertrec['seam-weight']
            crease_weight = loopvertrec['crease-weight']

            # Generate Red, Green, Blue based on weights and spread over mesh. Red will be used to generate U, Green/Blue to generate V

            # Average colors with neighbours
            r = (vert_colors[v][0] + vert_colors[loopvertrec['left']][0] + vert_colors[loopvertrec['right']][0]) / 3
            g = (vert_colors[v][1] + vert_colors[loopvertrec['left']][1] + vert_colors[loopvertrec['right']][1]) / 3
            b = (vert_colors[v][2] + vert_colors[loopvertrec['left']][2] + vert_colors[loopvertrec['right']][2]) / 3

            average_this_loop = [r, g, b]

            for v2 in loopvertrec['shared-loop-verts']:
                r = r + (vert_colors[v][0] + vert_colors[loopverts[v2]['left']][0] + vert_colors[loopverts[v2]['right']][0]) / 3
                g = g + (vert_colors[v][1] + vert_colors[loopverts[v2]['left']][1] + vert_colors[loopverts[v2]['right']][1]) / 3
                b = b + (vert_colors[v][2] + vert_colors[loopverts[v2]['left']][2] + vert_colors[loopverts[v2]['right']][2]) / 3

            average_all_loops = [r / (len(loopvertrec['shared-loop-verts'])+1),g / (len(loopvertrec['shared-loop-verts'])+1),b / (len(loopvertrec['shared-loop-verts'])+1)]

            # CREASE
            r = average_all_loops[0]
            g = average_this_loop[1] * ( crease_weight ) + average_all_loops[1] * ( 1.0 - crease_weight )
            b = average_this_loop[2] * ( crease_weight ) + average_all_loops[2] * ( 1.0 - crease_weight )

            r = r * (1.0 - end_weight)                          # END
            r = r * (1.0 - start_weight) + 1.0 * start_weight   # START

            # Determine the left/right side of the seam based on direction of 'red'
            if (vert_colors[loopvertrec['left']][0] > vert_colors[loopvertrec['right']][0]):
                leftness = 1.0
            elif (vert_colors[loopvertrec['left']][0] < vert_colors[loopvertrec['right']][0]):
                leftness = 0.0
            else:
                leftness = 0.5

            g = g * (1.0 - seam_weight) + leftness * seam_weight

            # store it
            if len(new_colors)>v:
                vertdelta = abs(new_colors[v][0]-r) + abs(new_colors[v][1]-g) + abs(new_colors[v][2]-b)
            else:
                vertdelta = abs(r) + abs(g) + abs(b)

            if vertdelta > maxdelta:
                maxdelta = vertdelta

            new_colors[v] = (r,g,b)

        print(maxdelta)
        if maxdelta < target_delta:
            break

        #Copy new colors back to vert_colors
        for i in range(0,len(loopverts)):
            vert_colors[i] = new_colors[i]

    # Generate UV map - must be in EDIT mode for this

    bm = bmesh.from_edit_mesh(obj.data)
    uv_layer = bm.loops.layers.uv.verify()

    #Removed for 2.80+ since no longer valid and not needed
    #bm.faces.layers.tex.verify()

    for f in bm.faces:
        for l in f.loops:
            luv = l[uv_layer]

            r = vert_colors[l.index][0]
            g = vert_colors[l.index][1]
            b = vert_colors[l.index][2]

            luv.uv = (r, g)

    bmesh.update_edit_mesh(obj.data)
    bpy.ops.object.mode_set(mode='OBJECT')

###########################################################################################################################

def get_edge_length(obj, loopidx1, loopidx2):

    vert1 = obj.data.loops[loopidx1].vertex_index
    vert2 = obj.data.loops[loopidx2].vertex_index

    for edge in obj.data.edges:
        if (edge.vertices[0] == vert1 and edge.vertices[1] == vert2) or (edge.vertices[0] == vert2 and edge.vertices[1] == vert1):

            OWMatrix = obj.matrix_world

            #In 2.80+, use the '@' operator for matrix mulitplication
            #v1Pos = OWMatrix * obj.data.vertices[vert1].co
            #v2Pos = OWMatrix * obj.data.vertices[vert2].co
            v1Pos = OWMatrix @ obj.data.vertices[vert1].co
            v2Pos = OWMatrix @ obj.data.vertices[vert2].co

            dist = (v1Pos - v2Pos).length

            return dist

    return 0.0

###########################################################################################################################

def get_loop_verts(obj, loopidx):
    loopverts = []
    vertidx = obj.data.loops[loopidx].vertex_index

    idx = -1
    for loop in obj.data.loops:
        idx = idx + 1
        if loop.vertex_index == vertidx and idx != loopidx:
            loopverts.append(idx)

    return loopverts

###########################################################################################################################

def get_group_weight(obj, group, loopidx):

    groupindex = obj.vertex_groups[group].index
    vertidx = obj.data.loops[loopidx].vertex_index

    global group_vertex_cache

    for v in group_vertex_cache:
        if v.index == vertidx:
            for g in v.groups:
                if g.group == groupindex:
                    return g.weight

    return 0.0

###########################################################################################################################

def init_group_vertex_cache(obj):

    global group_vertex_cache

    for v in obj.data.vertices:
        if len(v.groups) > 0:
            group_vertex_cache.append(v)

###########################################################################################################################

#Invoke it
color_vertices_rgb(bpy.context.scene.objects["Suzanne"], 1250, 0.0001,'START', 'END', 'SEAM', 'CREASE')


Deforming objects along the surface of other objects

So one of the cool things about a torus-- which is what a chain link is-- is that it unwraps really nicely.  You seam it twice and it makes a perfect square.  And any tiling texture on that square will tile on the torus.
So what I might try here is to take that knowledge and create some displacement maps for my toruses.  You could build each link's stuff as a flat scene, then render to a height map, and apply that height map as displacement to your torus.  (UV mapping the individual elements would be a different matter though.)
Another option here is to use the Textools addon, which can create flattened versions of meshes.  It rips along UV seams and then creates a flattened shapekey.  From the flattened shapekey, you can surface deform other meshes, then unflatten.


Blender - Plot viewport-independent 2D-Labels

The features in blender for this task are not so advanced, so I would suggest one of two options...

Load in Empty objects and name them usefully, enabling the objects display -> name option in the object buttons.
(note, these names wont render)
Create 3d text objects for each name (reduce the curve resolution to ~4 or so, for faster display), these will render which is their main advantage.
(note, wont point towards the view though you could constrain them to face the camera).

You say that the amount of object would be huge and hard to view in the outliner. To workaround this you could...

Give them a parent, the outliner will nest them under the parent.
Put them on a second layer (probably a good idea anyway), then set the outliner to only view visible layers.

Other alternatives exist like using Python to draw text in the view-port or converting curve data to grease-pencil. But Im not sure these are worth the extra hassle of simply creating named empties or text objects.


How to delete objects stacked on top of each other?

It's hard to tell exactly what you've done with seeing some images or the blend file.

However if you press "A" twice to unselect everything, then select the coin you want to keep and press "Ctrl + I", Blender will select everything else and unselect the coin you want to keep. Then you can press "X" to delete everything else in the scene.


How to perfectly copy uv texture to another side without having to make them overlap?

I'm assuming you are using a newer version of Blender. I tested the following with Blender 2.90.1.
I used the setup below to demonstrate.

First you might want to copy your object. On the copy use overlapping UVs. In my case i mirrored the cube.

Then add another UV map to the object.
Next copy the old UVs to that map. You can do that by selecting both objects and press Ctr+L and choose "Transfer UV Maps". (Select initial object last, thats where the UVs are coming from). You now have you target and source UV layout on the same object.
Next go to the Texture Paint mode and choose the clone brush. Set the Mode to "Single Image"
Create an empty texture and choose the destination UV layout. Also tick "Clone from Paint Slot". Than choose your original texture map and one field underneath choose the original UV map.

Now draw over the mesh. you should see the texture beeing transfered from the original UVs to the new UVs. = )


How to make walls be covered with tiles with different shading?

An icosphere is a triangulated sphere.
Subdivide for more faces.


replace operators with low level functions

Attempt to create a collection of information resources:

From API documents

Inspect the inherited Functions Section at the page bottom.

From within the Python Console

Inspect bpy.data...
Inspect bpy.types...

List of useful reference documents

Reference API Quickstart (Blender 2.71 API)
Reference API usage (Blender 2.71 API)


Equivalent of Set Inverse in ChildOf constraint

Use more than one Child Of constraint - with each set to a different 'inverse'. Then use the Influence to blend in each at the appropriate point in the animation - rather than re-using the same one.


I ended up finding a solution that is "elegant" enough to where it would work on even larger scenes where you might have 10-15 copies of multiple objects without being miserable to do.

First, I dragged a copy of each individual object away from my scene in an area where I'll basically have 1 copy of each unique object. You can even move these on a separate layer if it helps.
Next I grouped up (ctrl+G) all of the objects that are the same within my scene in separate groups. So all the houses in one group, all the trees in one group etc... You can find more properties for grouping under the Object tab (the square icon 3 to the left from Materials)
Using the simple process explained in the video above ( https://www.youtube.com/watch?v=Tj-S5QAac3U ) I created a texture atlas using the unique objects that I've dragged out of my scene.
Then, I simply went into edit mode and separated all of them out by selection. This is pretty easy to do because I made sure I left some space between them when I dragged the objects away. You just go into edit mode, using B you select the area where your object is and then P and pick by selection.
Next you just pick the groups of objects and the unique object that now has its texture part of an atlas and press ctrl+L to link and link the material and send over the UV mapping too. So for example I would first select the group of houses which has 6 houses that all look exactly the same and then I would select the house that I dragged out to make it my active and then ctrl+L twice to copy the material and UV maps.
The only trick here is that if you want to re-build your atlas at a later point, you need to create new UV maps for all of your unique objects that you've dragged aside. This is simple to do, you just go to the object data tab next to Materials, scroll down to the UV Maps tab, click + to create a new one and delete the old one. Nothing visible will happen when you do this, however if you don't, if you try to join your unique objects with new ones at a later point to try and create a new atlas, your textures will get messed up when you press ctrl+J.

Hope it helps!


How to make face between two layers of irregular pipe

You can use the bridge edge loops option in order to combine the loops.

You can find some additional information on the blender Wiki. In order to get a seamless connection between the two meshes both need to have the same number of vertices otherwise some will have multiple connecting edges.

Link


Oh I noticed where I failed. I tried to create a pipe by creating cylinder with "nothing" filler and then adding solidify modifier, and I totally forgot to add faces to the inside, and the solidify modifier got confused.


As long as you don't have an excessive amount (if your topology is clean you shouldn't have many) they won't be a problem. I've never seen a character with no poles in the underarm area, and every character I've made has them and they all deform cleanly.


Alpha PNG as Texture with nodes -> isn't totally transparent

Everything is working as it's supposed to. Those black borders you see are simply shadows cast by the mug onto itself because you've made a hole in the side with the transparency shader. It's easier to see from the side:

It seems like you're trying to do something like this:

You don't need a transparency shader because you're not making anything transparent - you simply need to make the background of the image the same colour as the rest of the mug, so just use a MixRGB node and the alpha of the image as the Fac.

You'll notice I added a math node as well - that's just to control how much of the glossy is being mixed in, since if you used the alpha directly without the math node it'd be mixing 100% glossy and 0% diffuse.


How to constrain two objects to face each other without a dependency cycle

Just parent one empties to each cone, and track each others empties instead of the cone directly.


I found a solution: You can refine the alpha channel post render, here is how:

Just use any node that can influence a gradient and stick it in between the native alpha channel and the one of the output node.


Material saving issue during "Seperate by Material"

This was a known bug in 2.77a.
https://developer.blender.org/T49228

I now installed Blender 2.78a and the issue is resolved by using the new version of Blender. The material is now saved and loaded correctly.


Dope Sheet: Select all keyframes before or after a certain point

Left square bracket ([) and right square bracket (]) will select all keyframes on all channels before or after the current frame respectively, including the current frame.

If you don't want the current frame included you will have to change the current frame by 1, left or right, depending on the selection direction.


You should use voxel remesh in blender 2.81, it is quite good for joining two separate object. First join the head and the body using Ctrl-J, then go to Object Data tab in the properties panel and under Remesh click Voxel Remesh.

More information:
https://docs.blender.org/manual/en/latest/modeling/meshes/editing/retopology.html


Wireframe of top and bottom caps on cylinder

Note: I already posted this answer as a comment; posting it as answer now so the question can be completed. Also added some extra information + images for clarity.

Have you tried using Mesh wireframe? In Edit mode, select the edge loops on both ends of the cylinder and find 'Wire Frame' in the search menu(spacebar). Uncheck 'Replace' if you also want to keep the cylinder shape.

Note that this is destructive modification; using the Wireframe modifier would likely be more convenient, but I think that's not applicable since if you use the modifier, the edge vertices are shared with the top/bottom face vertices, so they will likely always be modified together. The modifier also doesn't seem to work on only selected vertices / vertex group.


How to reset all properties to their default values in a custom made User Interface Panel

To return a property to its default value,  use property_unset(propname)

Python console code

>>> bpy.types.Scene.x = bpy.props.IntProperty(default=3)
>>> C.scene.x
3

>>> C.scene.x = 4
>>> C.scene.x
4

>>> C.scene.property_unset(
property_unset(property)
.. method:: property_unset(property)
Unset a property, will use default value afterward.
>>> C.scene.property_unset("x")
>>> C.scene.x
3


how to get a mask that only contains the inside of a bowl

True normal channel
Given a similar face distribution, you can spot a difference between the normal of the faces on the concave side and the ones on the convex side.

Just sort them with a math node:

And exclude the ones who are pointing straight up if you want to get rid of the border.

Obiuvsly this trick works only for a simple vase like the one you posted, for any other model I would use vertex paint:


The short answer is that SSS on the GPU eats up a lot of memory, so much so that it is recommended to have more than 1 GB of memory on for your GPU. This was mentioned in one of the videos from the Blender Conference (unfortunately I can't remember which one). Updating your drivers won't really help as that can't add more memory, so for now you are stuck with having to render on the CPU. If you have multiple objects that have SSS shaders on them then you could try just rendering one at a time and then compositing them back together.


How can the "Name" field in the node properties be useful for the user?

The 'Name' field can be used to identify different nodes when accessing the nodes with python.

I might have 2 diffuse type nodes, 'Diffuse BSDF' and 'Diffuse BSDF.001' and be able to identify which node I want to change a property on, by it's name:

bpy.data.materials['Material'].node_tree.nodes['Diffuse BSDF'].use_custom_color

This would access the use_custom_color property on the node called "Diffuse BSDF".

I know which node I am accessing by looking at the 'Name' field in the node editor.

Because I am accessing the nodes by name, it might be useful for them to have more descriptive names to help me separate them from other nodes e.g. "diffuseMain", "diffuseOriginal' etc. I can use that name field to rename them to something more relevant and identifying.


Bumpy node set up for metallic noisy texture

You're very close. Generally if you're adding displacement information from a B&W texture, run it through the height input of a Displacement Node first before connecting it. You can go one further by plugging the texture into the height of a bump node as well, to take advantage of some of the normal information. However, by default, the strength of the Bump Node (1.0) is too high for many things. I reduced it, as well as the scale of the displacement - otherwise it's too "noisy" especially with the values you are using for the noise textures. See below:


how can I create a procedural circuit board texture

It would be VERY DIFFICULT do do this procedurally in blender using cycles nodes. This could be done in Substance Designer without as much sweat, but that still might prove a challenge.

A free, easy tool to achieve this affect is JSplacment.
This lightweight program excels at generating unique and customizable sci-fi patterns for use in CG programs, like blender.

To get started with JSplacment, you can download it here: https://windmillart.net/?p=jsplacement

A good tutorial for these patterns is this: https://youtu.be/ee59XU3fKFw
(He uses C4D as his main 3D program, but the way you create them for use in Blender is identical)

I hope this helps!


I'm trying to get sIBL to work, but it won't install the .py addon for it

In the Scene Properties there is a section titled sIBL Gui in it there are a few buttons,
 1. Launch sIBL GUI
 2. Start Server
 3. Stop Server

Press Start Server and you should be able to use the send to software button in sIBL_GUI.


Calculate the local coordinates by applying the inverse matrix of the armature to the global coordinates.

# obj       the armature (scaled)
# emp       the empty in world space (no parent)

bone.head =  obj.matrix_world.inverted() * emp.location


Compositing heat distortion not rendering

Whatever is connected to the composite node is your final render, the Viewer does not get saved using the output settings.

In your current setup you are feeding just one layer directly into the Composite (output) Node, bypassing any displacement.

Connect the output of the displacement to the composite node and be happy ever after.


The texture (usually called a diffuse map) simply affects the color of the object.  The normal map affects the normals to create a bump-mapping effect.  This works by converting the red and green channels of the normal map to x and y (or y and x, I forget which) rotation of the surface normals (0.5 being straight up, or no change) to simulate small bumps and surface details for added realism.  (The blue channel is actually ignored, though it is usually set at 0.5 as well which makes for the distinctive pinkish/bluish color of a normal map.)

As for your setup, you have two problems:

You need to send the normal map through the color input of a vector > normal map node and the normal output of that to the normal input of the shaders.
You are giving the normal map normals as mapping coordinates, all texture maps should have the same mapping coordinates.  In this case it looks like you are using generated for the diffuse so you should use generated coordinates for the normal map as well.

Credit to @Vladimir for image, this is a croped version of his screenshot as I don't have Blender available at the moment.


BGE: Send single pulse at start of game?

Often times to control parts of the game that are kinda background or sidework, we add empties. Invisible empties can be used for playing sounds, loading levels, spawning bad-guys, or running pythn scripts.

Create an empty that will run your script if it doesn't need to be on a specific object (a jeep for example ;) add an always sensor to it, and then connect it to a python controller, set the controller to run your script, then enable the little marker next to the name of the controller, setting it to be a startup script. the symbol will change from this:

to this:

And your final setup will look like this:


Problems using bone symmetry in Blender 2.80

To be able to symmetrize, the bones must have suffixes like _R or .R or _L or .L.


You could select the material slot and then click 'Select', which will select the faces that have this material. Only faces have material assigned, vertices don't.

You can do this in Edit mode only with thanks to Delagone :)


How to avoid flipped looking normals when baking them?

Use color space: Non-Color  for the normal map in the ImageTexture node, not sRGB. Classic mistake ;-)


No, Blender's constraint system is unique to blender and not portable to other software (in fact most program's advanced rigging tools are the same). Basic rigging (e.g. the bone heirarchy with parent/child relationships) can be exported with file types such as fbx.

Generally these sort of rigs are created explicitly for the program that the model will be animated in.


Changing object dimensions along Y axis - scales Z axis

This is because the object is rotated 90° around the X axis.

So blender is scaling the object around the local Z, then rotating the object so that the local Z is aligned with the global Y.

To fix this, apply the rotation with ⎈ CtrlA> Rotation.


Using custom transformation orientations in rigging

That's exactly what a simple single bone does: it rotates in its own (local) axis, so that its rotation world is affected by its rotation set in edit mode.

If you really need (and I don't think so) the triangle of bones following the panel, you can parent them to a bone set as in my example and use it as the main rotation bone.


blender timeline in seconds instead of frames

Press Ctrl + T with your mouse inside the timeline. This toggles that view. Do that and the timeline will depict parts in frames instead of seconds. This is useful for if you want it to be in seconds.

It can also be accessed via the view menu.

Of course, there are times when one is preferable over the other.


metarig is invisible, can't see it (scale, move pose it)

A friend of mine got what I did to mess up. Really simple, for anyone that might make the same rookie mistake, on the upper right side there's viewport options and "bones" weren't selected. I just clicked and It was back to normal.


If you want to do this automatically, you can use Bridge Edge Loops by selecting the rings, pressing Spacebar and typing "Bridge Edge Loops":

If you prefer a semi-automatic way, make sure you have F2 addon enabled in User Preferences Ctr+Alt+U > Addons.
Then select 2 vertices using F and continue filling the loop by moving your cursor in the direction you want to create faces and pressing the F (can be pressed repeatedly):


Cycles diffuse color bake texture atlas bake is way brighter

So the reason being was the mirror modifier on the spaceship... caused a lighter tone.  Not sure why but after I removed all mirror modifiers from the scene the color stayed the same.  Thanks @Brenticus for suggesting an issue with the spaceship it lead to the fix!

Also:   I was baking into an image with the wrong color space... Whenever you generate an image for an atlas its color space is sRGB by default. I switched it to raw and that worked like a charm.  Leaving the above because somehow that did work one round.


How do you fade an image over video in the VSE

In the Video Sequence editor press N to bring out the tool bar.
Then select the video strip you want to fade out and insert keyframes for opacity , change to a different frame, change the opacity and insert a new keyframe:

( to create a key frame hover the mouse over the opacity press the right mouse button or press I)

For other kinds of transitions/efects please refer to the Sequencer Effects Manual


the emulate middle-mouse button does not directly navigate for you when you use the pen, rather it adds a key or keys that in combination with the pen touching and moving navigate like with the mouse.

In that regard, once activated, the Alt button held down will be used to rotate with the pen like you would with the MMB.

If you use Alt+Shift, you can pan the screen like you would with Shift+MMB.

And using Alt+Ctrl gives your pen the zoom based on moving up or down movement like you would normally do with Ctrl+MMB.

As you can see, the emulation essentially replaces the MMB with the Alt key. So some other functions like loop select that would normally use Alt+LMB, will have other keys like a double LMB(click).

Happy Blending.


Want to import an STP file to blender with colors

According to FreeCAD's Key Feature's it looks like you could just export to OBJ, DAE or IFC.

OBJ & DAE are natively available import options in Blender.

IFC does have add-on support in Blender, but from what I can tell it's last compatible version is 2.73 (add-on found here). If, howvever, you get the latest from IfcOpenShell's Github repo, they have updated the plugin for Blender 2.80. Blender also now has an IFC exporter which supports recording colour information in IFC format as part of the IfcOpenShell package (v0.6.0 branch).

If these aren't working as expected, then you should be digging further into FreeCAD's export options.


How to attach mesh object to another mesh

You can use the "Vertex triangle" Parent object option, which will make your accessory follow the movement of the trhee vertices of the parent mesh (Hair) nearest to the child.

So select accessory, shift select hair, press Ctrl P and choose "vertex triangle".

After selecting the hair, if you tab into edit mode you can choose three vertices to act as leaders of the movement.


How do I scrub the sequencer playhead more than just 1 frame at a time

You can revert back to Blender 2.7X keymap in the Preferences

Edit: Sorry I didn't see the part about more than one frame at a time. My bad!

If you wish to stick with the current keymap though, you can add another keybind for that.

Head back over to the Preferences tab, go to the Keymap option, and scroll down until you find the Frames dropdown menu.

At the bottom of that menu, click Add New. That will add a none shortcut, so open it up, and enter screen.frame_offset into the text entry on the left side. A Delta property will then be added, and change that to however frames you want to jump by. Then, just assign what keys you want to bind it to.

Repeat the process for the shortcut you want to jump forward/backward. Negative delta for moving back, positive for forwards.


How to configure Blender for 2D functions only?

You want to setup the layout the way you want and save it as his startup.blend.

By adjusting his preferences you can delete entries for changing orthographic/perspective, view front/top/right. As you probably know the shortcuts you want to disable you can search for the inputs by key-binding.

The far extreme is to compile a custom build for him, with this you can also remove menu entries for changing the view orthographic/perspective and even hide the window types menu so he can't accidentally change the 3dview to something else.

Or you can just teach him to use what he needs, and say just ignore all the other stuff that you don't need to use. I'm sure he can handle exploring other parts of blender if he feels adventurous and knows you to call when he gets lost.


Why doesnt the color not show on my character model?

I confirm there is no material defined for your model.

Here is the way to create it and assign the texture:

Go to the material tab
Create a new material
Change the color, indicating you want an image texture
Choose the image
Then you can use ShiftZ to toggle the 3D view to rendering mode (you can also use material or texture modes).

The created material can also be defined using the Cycles nodes system (both UI does the same, but nodes is more clear if your material becomes complex):

Create the material
Open a node view
Choose material nodes: by default a simple diffuse setting is created
Add ShiftA an image texture node
Connect it to the diffuse color
Select the wanted image


Importing .mov files in blender sequencer is very laggy

Importing .mov is not the issue. Mov files are quicktime files. Quicktime is a container that can hold video files in a variety of different compression codecs. Some codecs are more efficient than others. Some codecs require more from the CPU than others. Some require faster drives to sustain the data rate. Some are fast and easy to play at the expense of quality. All quicktime files are not created equal.

The same can be said about mvk. It is a container, that can encode in different codecs. Some will work for you, others won't. Sustaining the data rate depends depends on the codec and the resources available on your computer.

But the bottom line is that editing 4k video requires a lot of computing power, and/or clever optimization. Blender's video editing capabilities are quite limited and antiquated. To deal with video you would be better off with a real video editing app. Most of them can play video more efficiently than blender, using GPU acceleration and multithreaded operations. Blender uses none of that.

Blender is a great 3D app but the vse's performance and design is sub-par to other apps out there in the real world.


Multiple file browsers (different files) using python

If I understand your question clearly, you want to proceed with the first modal result and run the second operator right?
Instead of calling two modal operator, you should call the second one in the first operator "execute" function. In that block, the modal part is done and can call another modal operator.
A simple snippet that run two file select window in a sequence:
import bpy
from bpy_extras.io_utils import ExportHelper

class ExportCommon(bpy.types.Operator, ExportHelper):

    bl_idname = "export.common"
    bl_label = "Export common"
    filename: bpy.props.StringProperty()
    filename_ext = ".fbx"

    def invoke(self, context, event):
        context.window_manager.fileselect_add(self)
        return {'RUNNING_MODAL'}

    def execute(self, context):
        print(self.filename)
        bpy.ops.wm.save_as_mainfile('INVOKE_DEFAULT', copy=True)
        return {"FINISHED"}

bpy.utils.register_class(ExportCommon)

bpy.ops.export.common('INVOKE_DEFAULT')


I am assuming all of your meshes are already combined to a single  mesh (if not please select all pieces and hit Ctrl + J).

Select and delete faces inside, as shown below:

Select the edge loops (as selected below) and follow the menu Mesh->Edges->Bridge Edge Loops:

Output will be :

I hope it will help you, best of luck :)


How do I restore the original window configuration?

In 'User Preferences' under the 'File' tab, you can uncheck the 'Load UI' option.

Save User Preferences.

Then restart Blender.

This will cause blender to load the default window layout.

If you want to keep a window layout, you need to remember to re-check 'Load UI' once blender has restarted.

To close individual panel, you can drag the corner with the arrow of neighboring panel with the same height or width. This is using the outliner to close the properties panel.

The link posted by @poor has this answer, you just have to wait until the end of a 30 second gif to see it in action.  (is there a TL;DW for gifs?)


Blender Render (Internal) How to control smoke direction?

I would use a wind forcefield with a strength of about 7. Make sure it's pointed in the same direction that you want your smoke to blow in. Keep it a little bit away from the domain, or else smoke would flow around it and it would look weird.


texture splatting - mix multiple (4) textures

You basically had the right idea about breaking it down by color channel.

Here's one example of how you can solve this:

Using RGB and black to create a 4-texture blend map

I could have used the alpha channel, but opted for the absence of color (black) instead to represent the fourth channel because you can't see the alpha channel in the 3D Viewport or paint it in Texture Paint Mode.

This is what the node setup looks like (Blender Internal):

What's happening in the node setup

From the 'Blend Map' texture the RGB channels are separated and each one used to additively factor in the color of the texture against solid black.

The RGB Curves node just gives enough of a boost that the transitions between regions won't look dark. (Mute the node in the .blend to see the difference it makes.)

The ColorRamp and Invert nodes isolate the darker parts of the blend map and that becomes the fourth channel mask (black).

The Material node receives the final additive mix of color data (the four textures) and applies it to a material created just for this node setup that I named 'NodeComponent'. This is just the quirky way of doing things in BI's nodes so that the material will receive specular highlights and not be shadeless.

For cases when you need more than four textures, you can repeat the blend mapping process iteratively. So for example, within the red region of the blend map there could be another blend map with its own red, green, blue, and black regions. So you could use the first blend map to control what kind of terrain (grass, sand, snow, stones), and then the second level blend map to map out the grass textures within the grass region. In such a case it would be best to create a Group node and reuse it for each blend map, to keep your nodes manageable.

Getting it into your game

As for exporting, you can bake your blend map to a new massive texture, but it wouldn't be good for a game because such a large image would need to be generated. It's better to use the individual tiling textures and the blend map to combine them. I don't know what game engine you plan to use, but if you are using the BGE or Blend4Web you can use this node setup as-is. For other engines you should look into what kind of data those engines expect for a blend map.

 *Terrain material is set to 'Shadeless'. Turn off 'Shadeless' to see lighting.


How do I Remove Reflections Off a Diffuse BSDF Surface?

Reflectivity is controlled by surface roughness. The higher the roughness value, the less reflective the surface. Another thing to try is turn off reflective and refractive caustics in the render settings.


Extrusions causing problems in edit mode

First, the "grainy black texture" is z-fighting. Some where you have overlapping faces.

The automatic extrusions on the x-axis is from the normal value of the face you are extruding from. You can after hitting E press Z and that will disable the guide along the normal.

I'm not sure what you mean by "it doesn't allow me to extrude planes into 3-D shapes." If you select a face in face select mode(change the selection mode with CtrlTab) then press E you will have a 3D shape.


Copy to selected not available or doesn't work when highlighted

Select all your objects, then at last Shift select the one with the modifier, then ctrlL > Modifiers. By the menu bar: Object > Make Links > Modifiers.


Need help with exporting from Materialize

Your program creates several maps - including a height map. Don't use it as a bump map. If you want to use bumps, get Materialize to generate a normal map for you (bump is a cheap cheat)
However if you want to use actual displaced geometry, use the height map, transfer it to a Displace Vector with a Vector -> Displacement node and plug it into the Displacement slot of your Material Output Node.
There are a few more options you will want to consider, too long to explain them here, the keyword to google for is: true displacement subdivision.


What it the meaning of  added by 3d view to the object name?

Every time you add a marker on the timeline, all the objects will include the suffix F (frame) and the number of the frame you added the marker to.
If you move to another frame, you can see that the suffix disappear.


is there any way to make an add-on password protected?

Jerryno's answer is technically correct. But there is a potential solution if you really really want to try this.

For what you describe, you could possibly host the addon code on a separate server that requires authentication, and then have a simple addon that loads the rest of the addon from this server each time it is run. This would probably be very tricky to get right though.

I would question whether you actually need this level of protection? Copyright protection should be enough in many countries. Other assets from the studio (e.g. models) can easily be removed, they are only protected by copyright. What damage to the studio's business/bottom line will this actually cause (I suspect most studios do not worry about this at all).


Incorrect Rotation for Imported Vertical Video in *Movie Clip Editor*

you can open your movie in video editing and then insert the rotation value 90/-90 as you need it and then just render it out and use the result for your tracking.


The text object must be converted to mesh (ALTc -> "mesh from ..."), or you cannot use boolean on it. If you don't convert it, you cannot neither use the boolean on the other mesh which has to be embossed, because you cannot select the text as target object. When you convert the text to mesh, both can be done.

My suggestion, also, is to operate as logic suggests: select the "other mesh", apply the boolean modifier, as "difference", and select the (converted to mesh) text as target "object".


Object tilts along animation constraint path

Select the curve and choose Twist Method > Z-Up:


Working in 3D stereo in the 3D view - hardware requirements?

I had these problems with my internal Intel HD 4000. I wanted to use my laptops second GPU, an AMD Radeon HD 8790M. But unfortunately for this Dual GPU laptops you are dependant on your manufacturers driver support - so in the end it didn't work out for me.

I filed two Bug reports:

The first helped me to find out that the problem on my side is with the driver. The devs told me to use the opengl32.dll from http://download.blender.org/ftp/sergey/softwaregl/ and place it next to my blender.exe. That's only applicable for Windows though, but it showed me that the problem wasn't in Blender (as with this software render mode it worked really slow but fine).
The second one concluded in Dalai updating the manual mentioning the Triple Buffer:

  Multi-View drawing requires capable graphics card and drivers with Triple Buffer support. If the Automatic mode doesn’t work, set the Window Draw Method in the System User Preferences.

So for your case, I'd suggest, you'd try to figure out in general whether your 3D view is working under Windows with this OpenGL-Wrapper. And finally you have to make sure, your MacBooks graphics card supports Trible Buffer.
I was able to use the 3D Stereo View with my line interlaced Zalman Trimon ZM-M240W 3D Monitor in software mode (like a slideshow). But this has nothing directly to do with 120Hz or not - that's just needed for using Shutter Glasses. With a line interlaced Monitor you don't need this, it just halves your horizontal resolution (but you won't really notice this and the 3D effect outweighs this limitation!).

So in general it is working, but not unfortunately not with my manufactures dual GPU drivers. And I can imagine a similar problem exists for your MacBook that one of the key factors (TripleBuffer support) is missing.
The first step is to get 3D working with a MacBook in general (which I didn't hear of being possible yet) and after that you might try to setup Blender to show your Viewport or renderings in stereoscopic 3D.


Wires are edges that do not belong to any face.

From the manual


Should the "Experimental" option be selected on the GPU/CPU screen? This might support a wider array of GPUs.

Make sure you have a supported CPU with the correct drivers installed.


Is it possible to resize faces/edges/vertices to a specific size?

Yeah, unfortunately, I think the best you can do for now is to enable face and edge measurements under overlays. It's only a display - it doesn't let you input any numbers directly, but at least it lets you see dimensions as you scale, and transform and whatnot. If an add-on for this type of thing does exist, I would love if someone could point it out. Until then, I think this is what we're stuck with.


Basic idea : render additional layer with overriding material which assign a grayscale value based on the point height  , use this layer as height pass

Details :

create the overriding material that will replace all materials in the height pass as follows :

setup an the height pass to use the override material :

in the compositor use the color output of the Height layer as a height pass :

after compositing here is the result :
no height :

 with height :


How do you write in a text box in the Game Engine within Blender?

If it is a text object, you can Tab into edit mode and change the text value ahead of time. If you want to edit it realtime in you game please see the following steps:

Step 1

Switch your screen layout to "Game Logic" or open a Logic Editor window.

Now add the text object and position it where you want it.

Step 2

Under the logic properties for the Text object, click the special button that says "Add Text Game Property". A new string property called "Text" will appear, but alas! you cannot edit it directly. You need some game logic. Add a normal game property, set it to boolean, and give it a name you will remember. Now create a new Keyboard sensor, enable "All Keys" mode, and under the log toggle field, select your boolean property. Lastly, under the target field, select your property "Text".

Step 3

Profit. You now have a system where you can dynamically change a text objects lettering in game, but it will only happen when you enable the boolean property. i.e. if in a first person shooter, you could set it to toggle when keypress[right enter key] so you don get long string of "WWWASASAAWWWWWWWWWDD".

Hope this works for you. Happy blending.


In the user preferences edit - preferences you go to navigation, and then under orbit and pan check orbit around selection.  this will make you rotate around whatever object you have selected.

hope this helps.


If you have the original somewhere, you can copy it with CTRL+C and then paste it into another Blender instance with CTRL-V.

If you lost the original blend file, you can click on File > Recover Auto Save.


Is there a way for particles on a curve guide to collide?

To keep particles at the end of Curve Guide you can change Settings > Free to 0.300. But since particles Life Time is given to use this number of frames to get from start to end of curve (and has influence to its speed) it was quite confusing what is going on there.
Blender Manual says:

Free – Fraction of particle life time, that is not used for the curve.

You can also try Curve object and under Physics enable Force Field > type Curve

One of many tutorials.
Use Particles System > Physics > Fluid type to get volume in a pool.


X-Ray like Shading Error in EEVEE but not Cycles

Ten to one, you have the shader blend method set to “Alpha blend,” which is useless for things more than one face thick. Use “alpha hashed” instead.
This is probably in the top 10 FAQ.


Linux Sheep It Client Doesn't Recognize Nvidia GPU

The easy(ish) answer is that Cuda isn't actually installed by default on every platform.  Blender actually compiles in CUDA libs statically AFIK, but in other programs you will need to install the CUDA toolkit.

https://community.linuxmint.com/software/view/nvidia-cuda-toolkit

Additionally, you can actually install the version from the NVidia site, but it's a bit more compilcated:

https://www.reddit.com/r/deepdream/comments/3cd1yf/howto_install_on_ubuntulinux_mint_including_cuda/


Playing Scale and Alpha Animations at the same time

The channels are separate ... I would expect it to be fine.I really can't tell why it does not play.

I suggest to play them at different animation layers.


Mirroring during retopology creates aberrations on mirrored axis

Your high-poly object is not really symmetrical, try to remirror your rabbit with the dyntopo Symmetrize button, you'll see holes both sides.


Strange horizontal stripe on a surface with a Cycles material applied

I suggest that you turn off your current [sun] lamp for rendering.
Add a new [plane] with emission material and use this as a light source.
The visibility settings of the new [plane] should have camera visibility off depending on the placement.

All these actions should take 3 minutes or less when you have practiced them.


There is a possibility I have thought of:

Create a plane. Subdivide it a lot. Then add displacement modifier. Make sure the texture is black and white.

Apply the texture to the displacement modifier, this will raise 1 area of the plane while the other is lowered. Apply the displacement modifier.

Than you can go to side view in edit mode and select the lower faces using box select and delete them.


Why don't my materials reflect HDR images?

It was a bug with Intel HD 4000 GPUs. It has been fixed in 2.90. Please try that.

https://developer.blender.org/T75943

https://builder.blender.org/download/


You have Duplication enabled on the cylinder.  Please see the manual for proper Dupligroup use:

EDIT: Without knowing the history behind the creation of this blend, it's hard to say why that was like that and what/how it was being duplicated.  You and @m.ardito mentioned linking from an external file.  As the manual states:

  Note that if the DupliGroup was linked from an external file the Object Data (mesh, materials, textures, transforms) will also still be linked from the original group. However, the various object’s parent-child relationships do not carry over.


How to draw distance lines to a central object?

This doesn't provide the distance info but will provide 'rubbery lines' between satellites and central body and has been done in the 3D window.  The distance information can be calculated separately and overlaid via the video editor later.

Rubbery lines -  (Rendered with OpenGL)

Add the central sphere, then one satellite.

Add a Nurbs Path and rotate it to align roughly between the satellite and sphere and so it's Edit arrows are pointing to the sphere.

Bevel it with a new plane (scaled down to suit) so it forms a rectangular pipeline. (see Bevel below)

Give it a material slot and saturated colour to avoid shading.  Remove specular.

Set it's origin point to the satellite end.

Select the satellite, then use shift-S to set the 3D cursor to the satellite's origin point. (Cursor to Selected)

Select the line and use SH-S again to set it's origin point to the satellite's OP.   (Selected to cursor)

The line will be now be rotating from the satellite's origin point.

Give the line/path a constraint --> Track to --> the Sphere. (look at sphere)

Goto Edit mode and select it's sphere-end control point.  Press CTL-H and select "Hook to New Object".

Back in Object mode, pull the new empty (hook) down to the center (or surface) of the sphere.

Parent the Hook-Empty to the sphere. ("Keep Transform")

When the sphere moves, the line should maintain a connection between the two objects.

-================-

Add a new satellite.  Duplicate the line and move it down to near the new satellite.

Select the satellite and press SH-S --> Cursor to selected.

Select the new line, press SH-S again --> Selected to cursor.

The rest of the line's properties are inherited so that's all that's needed.

Repeat the procedure for each new satellite.

-=================-

If the satellites need to roam about also, simply parent each line to it's respective satellite. ("Keep Transformation") (Child=line)

-================-

Bevel -

This is just an ordinary plane scaled down to suit the resultant cross section size of the path.

Add it, size it, then convert it to a curve with ALT-C.

Got to the path, select the plane in the "Bevel Object" slot.

The plane can be rescaled anytime to adjust the cross sectional size.


How can I constrain a bone to follow another bone from the same armature?

Done! It turns out I was trying to add the constrains in the OBJECT CONSTRAINS tab, instead of BONE CONSTRAINS. I'm glad it way my fault because of my lack of experience with Blender.
Sorry for my ignorance and thanks for your help, you were right, you can make a bone child to another bone in the same armature with BONE CONSTRAINS! :)


How can I change a Text color in Blender?

You are using an older version of Blender. You should download a newer one, however, you should still be able to follow this, because it's basically the same in your version, except your tab icons are on the top, instead of the side of that panel, as below.
Change tabs and add new shader

Click the default white color for a pallet wheel

Choose you color


My Blender animation was rendering and stopped suddenly by 14 frames?

check the start frame and end frame in the render settings if they are set correctly.
also check the frame step if it's set to something other than 1.
You don't have to re-render from the beginning, just set the start frame to 15 to continue rendering from where you left off.


Character's hands stretching when moved in Object mode

It's normal, the mesh is bound to your rig and when you move it away from it, you'll get weird deformations.
If you want to move the mesh object without the rig, you can temporarily uncheck its Armature Deform modifier's visibility.

Otherwise, the way to move the entire character is usually to move the rig object: because he is the parent of the meshes he deforms, they will move with them (unless you forgot some parts, which is also a way to check your work).
Though the most common way is to have an empty used as the parent of the armature object. This way you have the whole character wrapped in that empty's hierarchy, you get one more level of control, and it's more flexible. And you don't seem to have a root bone in your rig, so it would also fill this role.


Does (display) mean that the card is not fully utilized for Cycles rendering?

Calculating and refreshing all the pixels on the screen(s) is the main job of a GPU and this requires a significant amount of resources, which will be scarce when the GPU is used for rendering as well.

So if you want your display to be responsive while GPU-rendering, then it's a good idea to reserve one GPU just for its originally intended job of of pushing those pixels to the display(s).

The '(Display)' text from the CUDA settings helps you accomplish this, by indicating which of your GPUs is currently connected to the display(s).
Otherwise you wouldn't be able to tell which one is which if you had say 3 x GTX 1070.