What is the different between a .msi and .zip Blender installer file?

Both versions of blender have the same functionality, features, plugins, etc.

The main difference is that the Zip file does not get installed in the system as a program, meaning that the executable files are not in the programs folder, the application does not appear on the start menu, or as part of the programs menu. Also the operating system will not associate .blend files to open with blender automatically.

The zip file can be extracted to any folder you want, and the contained blender.exe program can be run from there. It can even be executed from an external drive, so that it can also be run on computers where the user has no access to modifying the operating system (in schools, public computers, your parent's computer, etc).

The zip file allows you to use different versions of the program, whereas the installed version will use only the latest one installed.

The files used on the zip file don't need to be uninstalled from the system, you can simply delete the containing folder.

To uninstall the .msi file you need to use the OS uninstall tools.


How to I translate an edge in edit mode precisely using numbers?

To Translate any selected Vertices, objects or edges you press G and then after that depending on what axis you want to move it on you press the corresponding letter, which can be Y,X, or Z.

Secondly, you can either move it yourself with your mouse or type in a number. You can use numbers with decimals and or negative numbers which will translate in the opposite direction.

As for getting the edge to where you want it to be you will have to experiment with numbers. Hope this helps, and good luck.


How to add a material to the active material slot with python

The list of materials that shows in the material properties comes from

obj.material_slots

The index for the one that is selected in that list is

idx = obj.active_material_index

using that you assign a material to that slot with

obj.material_slots[idx].material = mat


How can I create a face with a rounded edge?

Have you considered retopologizing the top part of your object?

If you align the top loops in a perpendicular direction they can perfectly match the remaining half circle border loop and maintain a quad based edge flow.

Edit A little more detail:

Place the 3D Cursor correctly aligned at the right depth in relation to the face to be filled.

Erase you top existing faces, select the remaining top curved edgeloop, extrude it with E but cancel it immediately Right-Click.

Afterwards, with with 3D cursor already placed as described above, press the . (Period key) to transform relative to the 3D Cursor position, scale the edges in the Y axis only with S > Y > 0 (zero). That should flatten it directly and the right position.

Add one extra edgeloop along the height of the object, connect the two first segments of the bottom circle with the loop, and then you can fill the whole height of the object at once with the Bridge operator by selecting only the top and bottom edge loops (not the two large vertical bridging edges).

All done


You could use shape keys.
In Object mode select your object and in Object Data Properties give your object two shape keys. They will be named Basis and Key 1.

Select Key 1 and toggle to Edit mode. Select the middle vertices of your object. Make sure proportional editing is on (o key) and the mode is set to linear. Press g and adjust the white circle so that is covers the string (Mouse scroll wheel). Move the vertices until it looks good.

Toggle to object mode and change Key 1 Value. This value can be keyframed to create animation.

PS. If you use only a little bit geometry in your bow string then you don't even need proportional editing. You can just grab and move the vertices where you want. If you want to edit the actual bow to move while firing then proportional editing is handy.


Rendered View very pixelated compared to Rendered Result

The issue appears to be the way that cycles handles small light sources.  To solve this I turned down the brightness for all of my small indoor lights and added a blender internal light (spot light) and placed them as if they were sourced from the bulbs (and parented the meshes to them for ease of adjustment) and adjusted the brightness from there.   This appears to give the realistic affect I was looking for.


The version of Blender I was using was old. I updated to version 2.79b and that appears to have fixed the issue.


How can I change my node group interface to more easily edit the Group Input/Output nodes?

That's just the way node groups display in the current version of Blender. The other screen shot is from an older version of Blender.

In your node group, you can edit all the input/output settings by hitting the N key which will open the property panel on the right. Clicking on each input/output in the list will allow you to change the properties for each one there.


Logarithmic curve with spiralling cross-section

Have you tried the tilt property of the curve's control points?

If you select one or more curve vertex and press Ctrl + T you enter tilt editing mode where you can control the twisting effect of the curve.

Depending on how your curve was built you can control this for one or more vertex at a time.

If you need to make a smooth gradient across a multitude of points you can use Proportional editing O key to affect adjacent vertex. Use Mouse wheel  to adjust the affected radius.


1-Yes,You can import edit your theme or import one from and XML file then press Save user setting.

2-Blender save user setting here "C:\Users\Username\Application data\Blender Foundation\"

3-There no file for the default theme.


Text objects look slightly differently in viewport and game engine

Have you thought about displaying only a single text object, and when you replace the new text and or new number string in script use a concatenated string variable which contains the single string.

I don't know Java; but, the concept would be A$="Ammo", B$=numeric $tring (Ammo Count) and DisplayText$= "a$+" :"+B$.  Something like that?
Then you'd only have to deal with the Font size, vs game engine Font size, and your single Text Object would be variable DisplayText$ which would look like "Ammo :0"  (Of course replacing my simple variables with your own, etc.)

Like I said, I don't know Blender Script language, per se: so, don't know the string concatenator, could be the symbol "&" or semicolon ";" between the strings.


Every Quad is in reality 2 triangles and the behavior you observed is caused by this. Triangulate your mesh with Ctrl+T and rotate the created edges like you want with Ctrl+E > Rotate Edge CW / CCW.


How to copy weight painting on foot1 to foot2?

It seems to me that the new foot bone is either using the group associated with the other foot or that it copied a new group to the new foot but has also copied over the weights for the opposite foot...

You need to make sure that you have a separate group for each foot bone, and that each of those groups is associated with its particular foot weights.

Its also good to keep good naming conventions, foot.R and foot.L, for your bones and groups as blender uses the .L or .R to work out its symmetry when doing opposite calculations.

Hope this helps...


I managed to answer my own question but will post answer to help future people who have a similar question.

I used the answer to this question and this python script to animate the object:

import bpy
from mathutils import Quaternion

filename = 'input.txt'

file = open(filename, 'r')
lines = file.readlines()

frame_number = 0

ob = bpy.context.object
ob.rotation_mode = 'QUATERNION'

for i in lines:
    frame_number += 1
    q0, q1, q2, q3 = i.split(',')
    quat = float(q0), float(q1), float(q2), float(q3)

    ob.rotation_quaternion = quat
    ob.keyframe_insert('rotation_quaternion', frame=frame_number)

file.close()


Render has more objects than camera view

Try pressing Alt + H in Object Mode to unhide all objects. It is possible that you accidentally hid some of them so you don't see them in Object Mode but you do in the render.

Also since you used a particle system check, if you used children then it's possible that the number of children to render is different from the number of children to display. To check this go into the Particle System tab under children.

If you are using cycle, select the object that isn't displaying and go in the Object tab, under Cycles settings make sure that Camera is checked.


1) Dupliverts + Origin offest

For your particular situation, where your base geometry is made by vertex and edges only you can obtain the effect by shifting the object's origin from the geometry.

Since you don't have faces but ony edges and vertex, vertex normals (which is the vector that the lamp will follow, blue in animated the image below) is always directed as the origin-to-vertex vector is, letting you achieve the desired result.

2) Duplifaces

As moving the origin may not be suitable for all the kind of workflows, you can duplifaces instead of dupliverts. You'll have more controle on the faces normals, which is the vector that your lamps will point to.

In the picture below you can see the target shape in orange, and in vivid yellow (active object) the shape parented with the lamp. It's the same shape, rotated by (360/6)/2=30° and scaled a bit to get the center of the face overlayed with the target shape vertices. Faces were created by extruding the edges.

Adjusting the Z difference between the innee and outer boundary edgeloop will give you full control of the lamps orientation.

3) Particle System

Emit particles by mesh's vertex, one for each (in your case the number must be 6) without any randomness (we must be sure to have one, and just one lamp for each vertex). Set Size=1 and Rotation checkbox enabled. Than rotate the Lamp on its Y axis by the choosen factor:


How can I get my EEVEE render to match my viewport lighting?

I figured out that if I decreased my cameras depth of view and allowed some of the background cube to show in the render, that the ambient lighting was then visible. I'm not sure why that is - almost as if because the camera couldn't see the object that it wasn't processing the volumetrics it was emitting


TL,DR:

In your screenshot, check Maximum Draw Type. You have it at Wire. Change it to Textured.

Long version

Max. Draw Type (as you have noticed) allows you to reduce the visualization quality at the object level.
It is useful to control the level of detail while you're editing your scene. Set objects you don't want to bother with to Wire or even Box, and keep those you want to see in full detail Textured.


You can turn on the new denoising feature that was presented in Blender 2.79. Please download Blender 2.79 Here and then follow the instructions presented below.

Step 1.

Open render layers.

Step 2.

Check the box that says denoising.

Hopes this helps a lot of people


Object inner is black with clipping camera for cutaway view - add inner lighting?

This is because the geometry is still there, even though it's not visible to the camera. Rays bouncing through the scene will still interact with such geometry.

Instead try something like in my answer here.


Merge overlapping vertices of different objects

The start and end caps of an array can themselves be 'live' (unapplied) arrays.

If 'merge' is checked in the array modifier, the start and end caps merge with the arrayed object.

So you can apply the array modifier to your transition object (no repeats) and set your first array as the start cap, and your second array as the end cap of your transition 'array'.


Creating a curved cutter to cut into a sphere - Making a Jack-o-lantern

Okay, I found the answer here: What's the most elegant way to cut shapes out of a mesh. I created a bezier curve that covered the curve where I wanted to put the face cut, then I applied a curve modifier to the jack-o-lantern face mesh and moved it into position. Next I applied the boolean operator on the pumpkin using the face and the difference setting. That neatly cut the face out of the pumpkin, giving me the Jack-o-lantern I wanted. Well, almost. I messed up a couple of things (make sure your face is deep enough to cut far enough into the pumpkin) and have to go back and fix them, but the general purpose works.

I hope someone finds this helpful.


Line Conversions and Bsurfaces with Blender 2.69

I'm not sure about converting back and forth between a grease pencil stroke and a curve, but you can create a surface from grease pencil strokes like this:

Enable Bsurfaces in User preferences > Addons

Create an empty mesh by adding a primitive and deleting all the geometry from edit mode > Delete:

Add a new grease pencil layer in the 3D view > Properties region (N) and select Surface:

Still in edit mode, (editing the empty object) draw grease pencil strokes on the target object with D+LMB:

In the Tool shelf (N in the 3D view), press Add surface in the Bsurfaces panel:


Run additional code after user has executed and finished an operator

No, at least operators don't have the notion of a final state.

I can see in some cases you may want to setup a tools options, then perform some action once the options are set.

You could use a pop-up dialog 1 (as image-new does), but then you dont get feedback when changing values.

Some script writers add toggles to their operators that perform some extra calculation, so the user can choose to quickly setup options then press this last, while this isn't in keeping with our intended workflow, it makes some sense if the operator can't give interactive feedback because they're so slow.

There is one way you might be able to do what you want, and that is to create a Modal Operator, see the example in the text editor templates.
This way you start a tool which has its own mode (like grab or rotate), you can choose to handle events to adjust the settings, then a key such as Enter can finalize the operation.
So this may work in some cases - but modal operators assume a fairly different workflow so it depends a lot on what you do.


How to make a beveled cutout in a sphere?

For natural and smooth indentation you could use Displace modifier with a texture. Here we have a rotated UV sphere that has UV coordinates projected from view. The white parts of the texture are moved along the surface normal by the specified amount, negative numbers making an indentation.

Steps to recreate this:

Add an UV sphere, enable smooth shading and rotate it 90 degrees around y-axis
Enter edit mode and select all
Enter orthogonal top down view and press U > Project from view
Exit edit mode and add subsurface modifier, set it to 4 view and render
Add a displace modifier, set the strength to -0.05 and click to create new texture
Go to Texture tab, select you newly created texture from the drop-down and set its type to image or movie
Create and paint new image, open one from file or browser the drop-down for existing image to be used with the texture. Note the image should have soft gradient from white areas to black areas, this will affect the displace strength accordingly.
If you need to edit the placement of the displace texture, go into edit mode and find the UV layout in an image editor window. In the image editor window you can select all your UVs and move, rotate or scale them to align the texture.

This approach often requires a high number of vertices for non-jagged results but it's faster than trying to make the appropriate geometry especially if the shape of the indentation is a bit uncertain.

Alternative approach might be to model the shape on a flat surface geometry and curve the flat surface on a sphere using shrinkwrap or lattice.


If your doing a space scene, there isn't an atmosphere to emit or bounce light. therefore make sure the world's light is set to absolute black and from there you have full control of the lights that comes from our sun or your main light source.

Tip: set the size of your sun to something between 0 - 0.05, it makes it sharper and gives the illusion of a very huge object, study the physics if you want to understand why that happens.

Till next time


Use Spin tool and create the arc-shaped top based on the existing geometry.

Select top vertices which should serve as a base for the arc. Snap cursor to them with Shift+S menu. Note that spinning will happen based on 3D cursor position and the current orientation of the view in the viewport.
Deselect one of the vertices leaving only one selected (to make spin happen from one origin).
Press Alt+R to execute the tool (or find it on the Toolshelf). Adjust Angle in operator's options to 180 degrees and set amount of steps according to your mesh.
Make sure to remove double vertices with W menu.


Why does my cycles-rendered heightmap have wrong values?

This is probably due to blenders color management. You're expecting a linear relationship between the height of that part of the object and the colour of the pixel. However whilst the luminosity/emission strength of that pixel should be correct, when you render your image these values will be converted to an sRGB color space, and the values will not be correct.

What you need to do is set your display device to "None" in your colour management settings. This will leave your rendered values as Linear Values and not convert them to sRGB.


How can I resize/move the "canvas" of an image in the compositor?

There was a bug report on this where Ton said:

  Blender compositor is an extension of our render pipeline, animation frames by definition are always the same size.

  This is an issue we like to work on though, it's called "Canvas awareness" for compositor, where you can define a different output size for it than renders, and transform the renders inside the canvas freely.

There's currently two options:

Perform transforms in 3D and used to resulting render layer. The planes from images addon can help with the setup.
Perform a composite operation against an image of the desired size. The easiest way to generate one, is using the Mask node with a Fixed size.


Is there a way to use the terminal to check if a mesh is watertight?

In order to check if a mesh is watertight, we can test that the mesh is 2-manifold and no boundary edges exist [1].

The following definitions are loosely based on the quoted sources, some terminology and explanations were adjusted. This may not be up to standard for a scientific publication.

Definition: 2-manifold [1] [2]:

Each edge is incident to one or two faces.
For each vertex, if one where to remove that vertex, the remaining vertices from the fan would remain connected. A fan is the set of incident faces to the vertex.
No self-intersections occur.

Definition: Watertight [1]:

A mesh that is 2-manifold and has no boundary edges. Therefore each edge has two incident faces.

In layman terms, there shouldn't be any:

internal faces
two or more triangle fans connected only through a single vertex
disconnected islands
holes in the mesh / areas with no thickness

bpy.ops.mesh.select_non_manifold already performs these tests as batFINGER mentioned, except for the self-intersection check. This requires the use of a tree structure to efficiently determine intersections with itself, for instance a k-d tree, AABB tree, BVH tree or octree.

The script below selects only vertices that are non-manifold through bpy.ops.mesh.select_non_manifold(extend=False). The extend=False argument is important since the current vertex selection should be ignored. The is_watertight function then iterates over the vertices and checks if any vertex is selected. Once it finds a selected vertex, it's clear that the mesh is non-manifold and therefore not watertight.

The self-intersection test is performed using a BVH tree. In case you don't need the test because you can guarantee that the mesh doesn't have self-intersections, you can disable it by setting the check_self_intersection argument to False.

Please be aware that the BVH overlap computation in mathutils doesn't allow to exclude the comparison between the exact same face when comparing the tree with itself. Therefore a small but non-zero epsilon is used during the intersection calculation to avoid false positives, where each face would be considered to be intersecting itself. However this non-zero epsilon also allows slight intersections below the threshold to pass as watertight. Therefore a proper implementation would exclude the comparison of faces with themselves. Given that the example is supposed to be self-contained, only use modules readily available in Blender and  be reasonably efficient, I've used the mathutils BVH overlap function despite its shortcomings.

import bpy
import bmesh
import mathutils

def is_watertight(object: bpy.types.Object, check_self_intersection=True) -> bool:
    """
    Checks whether the given object is watertight or not
    :param object: Object the inspect
    :return: True if watertight, False otherwise
    """
    old_active_object = bpy.context.view_layer.objects.active
    old_mode = old_active_object.mode

    bpy.context.view_layer.objects.active = object

    bpy.ops.object.mode_set(mode='EDIT')
    bpy.ops.mesh.select_non_manifold(extend=False)
    bm = bmesh.from_edit_mesh(object.data)

    is_watertight = True

    for v in bm.verts:
        if v.select:
            is_watertight = False
            break

    # Only check for self intersection if manifold
    if is_watertight and check_self_intersection:
        bvh_tree = mathutils.bvhtree.BVHTree.FromBMesh(bm, epsilon=0.000001)
        intersections = bvh_tree.overlap(bvh_tree)

        if intersections:
            is_watertight = False

    bpy.context.view_layer.objects.active = old_active_object
    bpy.ops.object.mode_set(mode=old_mode)

    return is_watertight

if __name__ == "__main__":
    object = bpy.context.view_layer.objects.active
    if is_watertight(object):
        print("It's watertight.")
    else:
        print("It's not watertight.")

References:

[1] David Stutz, A Formal Definition of Watertight Meshes, 2018. [Online]. Available:
https://davidstutz.de/a-formal-definition-of-watertight-meshes/. [Accessed: 2019-12-05]

[2] C.-K. Shene, Mesh Basics, 2010. [Online]. Available: https://pages.mtu.edu/~shene/COURSES/cs3621/SLIDES/Mesh.pdf. [Accessed: 2019-12-05]


why solidify increase beyound the height

That's the way the Soldify modifier works. It basically adds thickness to faces in the direction of their normals. As you can see on the animation below, the face is extruded in the direction of its normal (the cyan line).


How can I create this type of lighting effect in Blender Cycles?

There are two main differences I see between your render and the reference image: the shader and the lighting.

Shading

It looks like in your render you have only used a glossy shader with a red color for the cubes.  However in the real world, the glossy reflections are rarely colored (except on metallics), the color comes from the diffusion.  See how the glossy reflections on the reference image are actually white (the color of the light and background), not red?

Here is my node setup for a general plastic material.

The base is just a diffuse with a little bit of SSS and gloss, then a sharp Fresnel gloss mixed in.

Lighting

There are 3 main differences I noticed about the lighting in your reference image versus your render.

The white backdrop.  To make a white backdrop like what is shown, create a plane, extrude the back edge up, add a subsurf modifier, and add some proximity cuts near the corner to hold the curve to the corner.  Just use a pure white diffuse shader for its material.

The shadows are very soft.  To create soft shadows in Cycles you need to use larger values for the Size parameter on your lamps (found under the Lamp rollout of the Object Data properties panel).  This effectively blurs the edges of shadows produced by that lamp.

The shadows are directly underneath the object.  To create shadows like this I like to use several sun lamps aimed in slightly different directions with different shadow sizes and strengths.  I usually have one slightly brighter main light, and two dimmer backup lights with even larger shadow sizes aimed in opposite directions and angles from the main light.

Result

Here's my result:


Aligning rotation to target along z axis

With this snapping options, and in particular with "align rotation to target" checked:

Moving an empty, you can notice that the Z axis is align to the target face normal and Y axis is up for the lateral faces:

But strangely this is not the case for a mesh:

Though, if you place a first mesh, then duplicate it, you can have the wanted result:

Duplication is not actually needed, you can place the object on a first face then move it again.

In my opinion (this is only an opinion), the code behind may do so that the rotation is minimal when snapping.

PS: locking rotation is not needed here.


How do I use a UVmap in renderman for Blender?

The UV maps work the exact same in Renderman as they do in Cycles. However there is something to be aware of.

You must have the image texture node loaded with the image to view it in the UV editor. (Do not have the node connected to anything just have it in the node editor by itself).

Also make sure you click "convert cycles materials to renderman materials" in the materials tab. (They wont copy exactly but it will get you started).


How can I ensure a minimal precision of 1cm in my project?

Based upon my experience, there are three things be required in the project you describe to ensure a minimal precision of 1 cm. First, Blender has a maximum order of magnitude of a dimension of 10,000 units, so for your 15 km project, you're going to want the project centered about the origin point so the minimum x, y, and z dimensions are a negative 7.500 km and the maximum x y and z dimensions are plus 7.500 km.

Next, it will be good practice to break the project down into multiple objects spread across multiple scenes. If there will be a checkpoint (guard shack) at the entrance located (to pull a location out of the air for the discussion) at 4.7 km in the positive x direction, and 5.9 miles in the positive y direction, make that guard shack as one or more independent object. As an independent object, you can track the dimensions of the guard shack / checkpoint to within 1 cm (actually smaller than that) more easily than tracking the four corners of the shack from the center point. Treating the guard shack separately also allows the guard shack to be constructed as multiple objects. This will be a necessity if at some point it is necessary or desirable to make some of the parts—sliding windows, or swinging doors, for example—movable. It is possible, of course, to collect all of the bits of the guard shack, and its accompanying devices (like entry gates) into a blender Group.

There is a precedent for making smaller groups of objects, not just within the main file, but moving some objects into other ~.blend files. Even if done on a full architectural plan, the architectural materials detailing the construction of the guard shack are going to e separate from the overall site plan. Putting some elements of the plan into other groups, or blend files is simply an extension of that already standard practice.

Third, Blender allows the movement of vertices (and groups of vertices) by changing values in the numeric boxes in the transform panel of the properties (N) shelf. If you change the location of a vertex (or a set of vertices) using these numeric values, you can help maximize the chances of the precision you want. There are two caveats to this. First the numbers displayed in the dimension boxes of the Transform depend a bit upon the width of the button. If the Properties shelf is too narrow to accommodate a ten digit number (with decimal point), it will truncate (or round) the number to fit. Second you might not get the precision for each set of corner vertices of the hypothetical guard shack referred to above if you choose to use global attributes. However, you can get the center of the guard shack to within a centimeter from the global center, and if you switch to local transformation orientation for the guard shack, you can certainly come within a one centimeter level of precision in the local object or group of objects.


How do I sharpen video strips in Blender?

Currently there is no sharpen strip effect in the VSE (although you might be able to build one with blur).

The only solution currently is to load the strip media as a node in another scene and apply the sharpen filter node there.

Then use that scene as a source replacement for your VSE strip.


I discovered my fault.
the auto update texture only works while selecting your model on the EDIT MODE of the 3d View window, then selecting the desired texture on the UV/Image Editor window.
i was selecting the texture without entering edit mode. :9


How to make Blender remember STL export settings as default

Solution

Manually

To remember unit settings make your adjustments then File > Save Startup File (Ctrl-U)
To change STL Export defaults navigate to
C:\Program Files\Blender Foundation\Blender\2.74\scripts\addons\io_mesh_stl
and open the __init__.py file.

global_scale is at __init__.py#L166, change default=1.0 to 10.0

use_scene_unit is below at __init__.py#L172, change default=True to False

Windows PowerShell Script

Configure Blender STL Export default settings - GitHub Gist


Your texture is getting stretched. What you want to do is to go into the UV tab, go into edit mode in the other window, and select the stretched faces. Then, you want to go into the UV workspace, go to the top where it says 'New' and 'Open', and click the picture icon next to that. Click on the texture in the dropdown menu, and the texture should pop up. You should see the selected faces un the UV editor. Scale them up, and that should shrink your texture.


bpy/file browser: get selected file names

If you take the TextEditor Templates -> Python -> Operator File Import

add from bpy.props import CollectionProperty
and add this special property  in the ImportSomeData operator

inside the importer class

class ImportSomeData(Operator, ImportHelper):

    # edit for brevity

    filename_ext = ".txt"
    files = CollectionProperty(type=bpy.types.PropertyGroup)

Then self.files, with 3 files selected, gives you

... <bpy_collection[3], IMPORT_TEST_OT_some_data.files>
>>> self.files[0]
... <bpy_struct, PropertyGroup("filename_mine2.txt")>

Then to get the fullpath of those files you use the self.path dirname

import os
dirname = os.path.dirname(self.filepath)
for f in self.files:
    print(os.path.join(dirname, f.name))

.../home/zeffii/filename_mine2.txt
.../home/zeffii/record_label_ep2.txt
.../home/zeffii/splines.txt


How to get smooth & low-density wireframe

If you throw a "Decimate" modifier in "Un-subdivide" mode (shown here: 2 iterations) in-between the Subdivide and Wireframe Modifiers, I think that gets roughly what you described.


Final image with Compositing:

Different Color Ramp and Mapping node setups.

Scene overview:

Scene has three elements Emission source, Glass mesh and mesh to enclosed both of them. Also HDRI lightning.

Emission source:

Three Spheres with Emission shader mixed with Transparent (pure white, #FFF) by Light Path > is Camera Ray. We don't want to see'em.

Glass mesh and material:

Material:

Most important thing here. It's colored Transparent Shader mixed with Glossy by Layer Weight to have glass like reflection and to let light go trough. Don't forget to set Mapping node accordingly to your mesh.

You can control how much white, orange and red color you want.

Mesh:

This is just quick mesh created with Poke Face.

Final thoughts:

I've used also Glare node in Compositing to have nicer overall look.

Blend file:

Without HDRI lightning.


Blender remove fireflies (Substance painter node)

Really good question Duarte! This is a common problem that I have faced many times. There is a despekle node built into the Blender compositor, as well as other third party softwares that can help you with this. Try rendering with a higher sample count. 20 is very low. GIMP is a free image editing software that you can use to remove fireflies, as I have many times! Video tutorial on removing fireflies in blender - Remove noise in GIMP I have included an image below on how to get rid of fireflies in GIMP. Hope this helps you some!


How to avoid violating energy conservation when making shaders and node groups?

It is impossible to say whether the groups you show conserve energy, because whether or not they conserve energy depends on what values you send them, and they don't output shaders anyways.
If you want to conserve energy, and you don't want to clamp unless you have to, there are only various things to know:

If you send a shader a color outside of the 0,1 range of color, you probably don't conserve energy.
If you use emission, you don't conserve energy.  (Emission creates energy from nothing.)
If you use an add shader node, you probably don't conserve energy.
If you use specular values outside of the 0,1 range in a principled shader, you probably don't conserve energy.
If you use sheen or clearcoat in a principled shader, you probably don't conserve energy.  (Not 100% sure about sheen, but 100% sure about clearcoat.)
If you send a mix shader a fac outside the 0,1 range, you probably don't conserve energy.

That's a lot of "probably"s.  Because there are corner cases.  Is it safe to add shader a 1,0,0 diffuse to a 0,1,1 diffuse?  Yes.  Because the output cannot exceed 1,1,1.  Is it safe to add 0.1 clearcoat to a 0.9 diffuse principled?  Yes, because the output cannot exceed 1,1,1.  Is it safe to mix shader a 0.5 diffuse shader at fac 2.0 from a 0.0 diffuse shader?  Yes, because you cannot exceed 1,1,1.
I'm sure I could have missed some examples.


That appears to be artifacts from the denoiser. Try disabling the denoiser or tweaking the denoiser settings to reduce the artifacts (reducing Radius and/or Strength can help).
Alternatively, such artifacts can be caused by saving the image in a 'lossy' format (such as JPG) with too low a quality - check your Output format settings.


Use Windows PC tablet as Wacom Tablet for Mac

So it turns out TeamViewer can do the job. It is possible to run a connection over the local network (which increases speed). In the end, I simply TeamViewered into my Mac from my PC and worked like that.


Have a look at the UV map.
The leaf takes a lot of texture UV space but it's fairly small in 3D space. That way it has a lot of details (=compression).
But the eyes get very little texture space and are big in 3D space. So they have only little texture details (=stretching).
A checkerboard texture can visualize this for you. Ideally, the chess patterns should all be the same size.
You can try to unwrap again with Smart UV Project (What is the difference between Unwrap and Smart uv project?).
Or edit the UV map

scale down the leaf in the UV editor (hover mouse over an UV island and press L to select it).

and try menu: UV → Minimize Stretch. The editor will then try to give the eyes more space (hopefully).


I think you want to make something like fake IES lights. I don't know how to make it with spotlights, but maybe this will help you. So here we go!

Final result:

Steps:

Create simple Circle filled with Ngon or Triangle, or even fill it as you pleased and scale it down to 0.1.
Create this node setup (I'll explain it later):

Most interesting stuff:

Light Falloff.
You can control here light strength and smoothness.

Color Ramp.
This will make gradients as you like. Try adding/deleting/shifting colors and you'll see the magic.

Blackbody.
Real deal here. It's simulating temperature of light. You can delete it and set any color you want.

That's it. You have now fancy fake IES lights with color temperature.

Blend file:


Impossible to select edge loops with shortcut

You've likely enabled Emulate 3 Button Mouse in the preferences (Edit > Preferences > Input). The shortcut doesn't work with this option enabled.

When the emulation is enabled, you can select edge loops by double clicking on the edges. If you hold Shift you can add additional edge loops by double clicking on another edge. For selecting edge rings hold Ctrl and double click (*).

In case you don't need to emulate a 3 button mouse, you can disable the option in the preferences. Alt + LMB (or Alt + RMB for right-click select) can then be used to select a single loop and Shift + Alt + LMB (or Shift + Alt + RMB) for multiple edge loops, with the option to toggle the selection.

(*) This option was added in commit bb70594c1bc2a3c859c45fcd35776327be5e8e04, which was missing when the original question was posted.


Video won't render properly, only audio?

You have once let Blender create the 25% proxy files and then moved your footage or *.blend file to a different location afterwards so that Blender can't find it any more...

You have to look for the original footage - your clips source video files and put them back in place where they originally were. There's a menu entry in the File menu helping you to find lost files. Or just look at one strip in your VSE and see where it points to and if your source footage is still there or if you can put it back there again. There already are some questions with good answers about this here on BSE...


autoexec python code / script doesn't seem to work

Found a solution !

Ages ago (before we were relying only on Internet), I was told "If you try searching for some explanation start with man man and dig further from there (yep, I was surrounded by prehistorical nerds)". So an old reflex just came back, I've done an old fashion man blender from my terminal and found the following option :

--python-text <name>
       Run the given Python script text block

Since your text editor creates a block called Text by default, you just need to specify this block name ... and it works as expected !

While it shouldn't, the online manual seems, somehow, providing less information than the one available locally !

So, execution of random python code can be executed automatically with the following command :

  blender -y yourfile.blend --python-text Text

or

  blender --enable-autoexec yourfile.blend --python-text Text

where Text is the name / label or your text block (you can get it from the header of your text editor view)

As pointed by batFINGER and dr. Sybren, another easy way is to modify the name generated by default when you create a new text block, by adding ".py" extension to it !


Make several (same level) objects children of new empty?

Here is a script that create an empty and make it a parent for all selected objects, select the objects and run the script

import bpy

selected_obj = bpy.context.selected_objects.copy()
bpy.ops.object.empty_add()
for obj in selected_obj :
    obj.parent = bpy.context.object

the script at the end is in an addon for reuse , install it and you can trigger it with pressing P, you can change this in the user preferences :

select the objects
press P
select the Empty type ( axis, arrow, cube ...)
select the empty position ( world center, median point, at cursor, active object )
check parent inverse if you want to set the inverse
you can set the name of the empty in name field

bl_info = {
"name": "Add a parent",
"author": "Chebhou",
"version": (1, 0),
"blender": (2, 65, 0),
"description": "Adds a parent for the selected objects",
"category": "Object"}

import bpy
import sys
from bpy.props import BoolProperty, EnumProperty, StringProperty

def add_parent(self, context):
    selected_obj = bpy.context.selected_objects.copy()
    if self.position != 'None' :
        exec("bpy.ops.view3d.snap_cursor_to_%s()"%self.position)
    bpy.ops.object.empty_add(type = self.type)
    bpy.context.object.name = self.name
    inv_mat = bpy.context.object.matrix_world.inverted()
    for obj in selected_obj :
        obj.parent = bpy.context.object
        if self.inverse :
            obj.matrix_parent_inverse = inv_mat

class AddParent(bpy.types.Operator):
    """Create a new parent"""
    bl_idname = "object.add_parent"
    bl_label = "Add a parent"
    bl_options = {'REGISTER', 'UNDO'}

    type  = EnumProperty(
        name="empty type",
        description="choose the empty type",
        items=(('PLAIN_AXES', "Axis", "Axis"),
                ('ARROWS', "Arrows", "Arrows"),
                ('SINGLE_ARROW', "Single arrow", "Single arrow"),
                ('CIRCLE', "Circle", "Circle"),
                ('CUBE', "Cube", "Cube"),
               ('SPHERE', "Sphere", "Sphere"),
               ('CONE', "Cone", "Cone")),
        default='PLAIN_AXES'
        )

    inverse = BoolProperty(
                name = "parent inverse",
                default = 0,
                description = "check to set the inverse"
                )

    position  = EnumProperty(
                name="parent position",
                description="where to create the parent",
                items=(('center', "World center", "World center"),
                       ('None', "Cursor position", "Cursor position"),
                       ('selected', "Median point", "Median position"),
                       ('active', "Active object position", "Active position"),),
                default='center'
                )

    name      = StringProperty(
                name ="name",
                default ="Parent")

    def execute(self, context):
        add_parent(self, context)
        return {'FINISHED'}

addon_keymaps = []

def register():
    bpy.utils.register_class(AddParent)

    wm = bpy.context.window_manager
    kc = wm.keyconfigs.addon
    if kc:
        km = wm.keyconfigs.addon.keymaps.new(name='Object Mode', space_type='EMPTY')
        kmi = km.keymap_items.new(AddParent.bl_idname, 'P', 'PRESS')# you can chnge the shortcut later
        addon_keymaps.append((km, kmi))

def unregister():
    bpy.utils.unregister_class(AddParent)

    for km, kmi in addon_keymaps:
        km.keymap_items.remove(kmi)
    addon_keymaps.clear()

if __name__ == "__main__":
    register()

link to Addon file


Problems like this typically occur when your cloth mass is too light.
Try to give it higher mass value, then do a simple animation that just lets the cloth fall down naturally then try to render some good middle frame that looks good.

Also, check you gave it enough subdivisions in edit mode.

And if you are doing an animation make sure you set the cloth collision and self collision and up their qualities.


Why is mirror modifier not being applied symmetrically?

My guess that your mesh is symmetric, but the symmetry axis is rotated. for example you rotated your Mesh in object mode. I am pretty sure that you did something like that, because you presumably used the default 32 vertices number cylinder, and in that case 4 vertices must be aligned  to the coordinate axis by default, if you add your object to the center of your world, without tweeking the Add circe tool option... so it should look like this:

My hint:

Delete your extrude.

Apply Mirror.

Rotate your object (in object mode), to make the axis "cut half" the edges. Like this:

Apply rotation (Ctrl-a)

Recreate mirror modifier, and you good to go.

In the future for similar objects, you should rotate circles/cylibders like this if you wan them have symmetric handlers.The general formula for rotation for blender circle:

360/vertices_number/2 (if you use degrees. You can write it directly to the rotate property field)

(it will not work on your current object, because it is already rotated)


How to set the origin point of each bone differently?

OK, There is only one object origin because it's the origin of your object. It's the 0,0,0 point of reference for all bones inside the armature. All bones share this one origin. It's the ball joint that connects the invisible shoebox with the outside world. In that invisible shoebox lies the armature.

In Object Mode, the whole armature rotates around this.

In Pose Mode, every bone usually rotates around it's own root unless constrained in some way.

You are in Edit Mode where neither necessarily applies. There, stuff rotates around the pivot point. That can be, for example, the center of your selection or, if chosen: the 3D Cursor. It changes violently depending on your settings and your selection.

That also means you are often not merely rotating, you are rotating and moving bones.

Example: you select an entire bone (orange, Edit Mode) and it rotates around its middle. That's not a rotation, that's moving its tip and root in a circular motion. Tip and root will have changed their coordinates.

You select an entire bone (blue, Pose Mode) and it rotates around its root. This is a true rotation because only the direction in which the bone points has changed.

Tip: use CTRLF3 with 'Fullscreen' disabled to make screenshots. Without the header or the properties (N) it's hard to see what you are doing.

I think learning by doing is beginning to reach its limits for you. Flying blind can be tiring. You will run into lots of roadblocks if you keep using Blender without knowing it's fundamental concepts of how it organises its data and its hierarchies.

Make it a sport to read a few pages of documentation every day. Otherwise you keep having blind spots creeping up on you when you need it the least ( :


Weird export noise after appending object

The reason for the noise are the other lights and objects in the scene that are placed inside the planet. That's probably not where they are supposed to be because they can't be seen, but they have impact on the rendering and cause more noise. If you move them to another scene or exclude them from rendering it will look just like before. If they are supposed to be placed there and remain visible, you will need to increase the render sample to reduce the noise or you could enable denoising in the view layer.

Disable rendering for problematic objects.

Problematic objects

Before

After


Rendering Clear Glass with Shadow Catcher and Transparent Background (Glass looks white instead of clear)

Under "Film" also check "Transparent Glass"
You must use a Glass Shader on your glass, adding a Gloss Shader mixing a with Fresnel works, too.

It is possible to save the alpha channel separately.


There are three reasons why you can't use the AMD Radeon HD 6770M for GPU rendering on your system:

GPU rendering on macOS with an AMD card isn't possible since Blender 2.80, due to the deprecation of the OpenCL compiler by Apple (see this answer for more information).
The GPU is below the minimum requirements for GPU rendering. The AMD Radeon HD 6770M has the TeraScale 2 micro-architecture, but GCN second generation or later is required on supported operating systems.
The GPU is below the minimum requirements for running Blender 2.8x. Only AMD graphics cards with GCN first generation or later are officially supported.

Therefore, the GPU is neither suited for GPU rendering nor running Blender 2.8x on any operating system. You may have to use an older version of Blender with lower minimum requirements.


Starting from 2.80 to NOT produce extra pixels, you can change brush falloff graph in way shown on the gif above.
Make a sharp transition from brush center to it edges.
As you can see radius is setted to 1px, Anti-Aliasing is disabled, 4x4px texture size.


Smooth Realtime-Audio Reaction in Animation Nodes?

As you have guessed, the Attack and Release are the values that controls the smoothness of the visualization. But there are couple of things to note:

An attack or a release value of 1 doesn't mean maximum smoothness. It means the values will nearly never change. So use the values responsibly, don't just enter values arbitrary and expect things to work. Usually, a release value around 0.6 and a low attack value works best.
In order for Animation Nodes to compute the spectrum at a certain frame, a number of preceding frames have to be computed in order to perform the smoothing. The number of frames computed is exposed in the Advanced Node Settings as the Smoothing Samples option. Higher values means more accurate smoothing, however, all values higher than a certain value converge to the same result. So don't increase this value too much, it will needlessly increase the execution time.
There is a theoretical limitation on the smoothing capabilities of the node. So you may not always get the result you are looking for. This is especially apparent in songs with a high tempo (BPM).

To have a better understanding of the inner workings on the node. I present a somewhat messy explanation. The names Attack and Release come from the concept of ADSR Envelope in music synthesis, which is short for Attack, Delay, Sustain, and Release. When you press a key on a piano, the Attack of the note is the time taken to reach the peak of the note, so a small attack value means the note reach its peak faster and snappier while a high attack value means the note reach its peak slowly and more smoothly. Similarly, the release is the time taken for the note to stop after the key is release.

In the context of music visualization, the attack and release usually have different interpretation. Lets say at frame zero, we computed the spectrum to be 10, and at frame one we computed the spectrum to be 3. This is a decrease of 7 units in just one frame! This certainly won't look good! So, instead, we give the user a "smoothed value", this value is a linear combination between the computed value and the value computed at the previous frame. The factor of the linear combination is the attack or the release value depending on whether the value increased (attack) or decreased (release). Since the value in our example decrease from 10 to 3, then the release values is utilized. And instead of giving the user 3 which implies a decrease of 7, we give the user $10 - 7(1 - \delta)$ where $\delta$ is the release value. A high value of $\delta$ translates to an output closer to 10 (Which we interpret as smoothing because it is a lower decrease) and a lower value of $\delta$ translates to an output closer to 3.


Uninstall The Blender 2.79b Then Reinstall It . If the problem still occurs try installing the blender 2.79a version of it.
HAPPY BLENDING


how to achieve this grid falloff with animation nodes?

Similar setup found here:
HERE

Many thanks to Omar Emara @OmarEmaraDev helped me to find this old post


Object appears Black while rendering ? while other objects look normal

Edit: actually my first answer was not accurate, you have an Auto Smooth enabled, in order to make your Auto Smooth work you need to go in the Properties panel > Data > Geometry Data and press the Clear Custom Split Normals Data button.

As explained here: "Your model has a custom split normal data (probably due to a normal edit modifier that has been applied or because the mesh was made with another software...) that keep some face shading in that way."


How to get Cycles viewport output in compositing

Well there is a way but it really is a cart before the horse thing. If you really need the image you can only get it by a screenshot, which will be limited to an 8 bit depth and the size of your viewport, obviously.

When it is saved you can then use a file node to import it into the node editor.
As I said this is a nuts way to do it but it can be done.

Don't do it though use F12.


Parenting with orientation constraint for the game engine

Use Vertex Parenting to a single vertex.

Select child right mouse button
Add parent to selection shift+right mouse button
Switch to edit mode tab
Select a single vertex from mesh right mouse button
Establish vertex parent ctrl+P
Leave edit mode tab


Strange Nodes in imported .obj file from Alias .wire export

When transferring data from application A to application B, the challenge is that there is always two potential sources of the problem. In your case, I suspect it to be an incomplete Alias export. You've stated in the comments that you were not able to tessellate the data during .obj export. Just in case, you have been using settings similar to the ones in the screenshot below?

Note that Tessellate is checked (the tolerance depends on your model), and that the output units are set to Meters. Importing such a file to Blender 2.79b worked fine for me in a quick test.

If you still get a faulty export, it's worth converting the data yourself to Meshes before exporting. The NurbsToMesh tool from the Palette is your friend:

If you check use existing tessellation you don't need to enter values yourself. The existing viewport shading tessellation is used instead. Pick the resulting Meshes and export them to OBJ as proposed above.

The preferred way is to use the .fbx Interface, but there were API changes in Alias from 2017 to 2018, resulting in different options available. The screenshot here is from Alias 2018. Note the File Version setting, which is important for Blender to be able to read the .fbx:


I have found the solution to your problem that is pretty simple (but unfortunately can be time consuming)  Luckily it doesn't require much work on your part, that's what computers are for.
Anyways, to solve your problem and make your fluid splash upwards like you want, you have to increase your resolution divisions in the fluid domain settings by a bunch  (see image below)

Doing this gives the fluid much more geometry to work with, and enabling it to behave much more like a real liquid.
Here is an example render that I made, using 212 resolution divisions:

As you can see, it looks much closer to your desired effect, it's not perfect, but it's pretty good looking in my opinion.
Now, the downside to doing this is that the more resolution divisions you add, the more time it will take to bake, however, if you just want a still image for your final output, I would only bake the first 50 frames and then find out which one works best for you.  The image above was taken on frame 20, so it didn't take long for me.
Lastly, for some optional settings, if you want your liquid to splash up more, you can play with the gravity Z axis settings in the fluid domain settings. (see image below)

It is automatically set to 9.8, (which is about what earth's gravity is)  if you make the number higher, things start to get a bit more light and floaty.  the render above uses a gravity of -6 on the Z axis.
In conclusion, more resolution divisions on your fluid equals more realistic behavior, I hope this helps you!


Fluid sim problem: fluid growing in volume

I couldn't really get my head around what's going on in your blend file, but the basics of the fluid sim are all wrong. The domain should not have any key framed properties, and yes, scale should be applied.

My guess is that since the euler scale of the domain is off, the impact value of the obstacle (the bottle) gets calculated as if it was greater than 1. Decreasing the impact value decreases the problem you have, but really, the fluid sim should be set up properly.


Why is my center of mass not calculating correctly?

What Blender's "origin to center of mass" does is compute the center of mass of the faces, i.e. it treats the object as a hollow shell with infinitely thin faces.

This is not the same as the center of mass of a solid object with constant density, as this example illustrates:

Blender's CM is the yellow dot, closest to the broad faces of the base
"solid" CM is at cursor's location, closest to the massive cube on top.

Unfortunately, I don't think there is a simple builtin way to compute the "solid" center of mass.

I have written a Python script that does the actual computation, but it will only give a correct result on meshes that define enclosed volumes (possibly with holes, but the outer boundaries must be continuous). It works by summing signed volumes of tetrahedrons defined by all the mesh triangles.

import bpy
import mathutils
from mathutils import Vector

def triangles (verts):
    """enumerate triangles in a face"""
    for i in range (1, len(verts)-1):
        yield (verts[0], verts[i], verts[i+1])

def cg_mesh (obj):
    """center of mass (and volume) of a mesh"""

    center = Vector()
    volume = 0
    mesh = obj.to_mesh (bpy.context.scene, True, 'PREVIEW')
    for face in mesh.polygons:
        f = face.vertices
        for t in triangles (f):
            a,b,c = (mesh.vertices[v].co for v in t)
            v = a.cross(b).dot(c) / 6
            center += v * (a+b+c) / 4
            volume += v
    bpy.data.meshes.remove(mesh)

    if volume == 0: print ("ZERO VOLUME", obj.name)
    else          : center /= volume

    return obj.matrix_world * center

# puts the cursor at the active object's center of mass
bpy.context.scene.cursor_location = cg_mesh (bpy.context.scene.objects.active)

This example will put the 3D cursor at the "solid" CM location, but you can adapt the script to do whatever you want.

The script applies all modifiers to the object, converting it to a mesh. If you want the CM of your primitive object, disable the modifiers first.

On the other hand, you can use it on a flat object by adding a "solidify" modifier first.

Again, no checks are made to insure the mesh defines a valid volume. If not, the result will be wrong.


In version 2.79 Video encoding settings have been simplified.
Read:https://wiki.blender.org/index.php/Dev:Ref/Release_Notes/2.79/More_Features

Quicktime (.mov) is a Container.

Choose FFmpeg video in the output panel.

Select Quicktime as Container in the Encoding panel.


In Edit mode you will see and edit the active shape Key only , but when you switch to Object mode you will see a mix between shape keys depending on the value of each shape :


Image Texturing - Using cycle's nodes to scale image texture and randomly rotate them

I just faced a similar issue, so I took a look at your file.  In the Tile-able image texture frame, you start with a Mapping node into a Separate XYZ.  I added the following nodes between them.

This all centers around the Vector Rotate node.  To explain, we start by taking the Vector output from your Mapping node into a Voronoi Texture with a Scale of 1.  We have to add another Mapping node in between to align the grid with the original output.

Now we can take the Color output and multiply it by some number and throw it into the Angle input of the Vector Rotate node, and we can take Position and put it into the Center input.  However, we must include yet another Mapping node in between to correct the transformation we made previously.  If we don't, the locations are all off.

This does introduce a slight issue.  The corners of the repeated image will show up as in the following image.

So you may have wondered what this mysterious noodle coming from the Distance output is.  I used this with a Color Ramp set to Constant to generate a mask that we can subtract out of your image and solve for these corners.

Your original Mapping node can be used as a control for x & Y Location, Z Rotation, and X & Y Scale.


To rotate the faces around a specific edge, change to Edge Selection Mode, select all the edges of the face you want to rotate and select the edge that the face will be rotating around as last.

Set Pivot Point as Active Element and change Transform Orientation to Normal.

To rotate the face around that edge hit R button, then Y button twice, then type rotational angle and hit Enter.

For dodecahedron faces to meet the rotational angle should be around 63.5 degrees (arccos(1/√5)) from the grid floor.

To use the function for precise rotation, after hitting R button type:

*180*acos(1/sqrt(5))/pi

To change the angle to negative or positive use Ctrl+- buttons


Magic box, objects inside visible only through hole

For the magic box, the material of the front face is a simple principled shader (the default one) and the material of the side faces is a simple transparent shader.

The material of the other cubes is the same (or at least they both have this structure), like shown in the picture:

(You probably want to disable the little cube's shadow)

So you get this:

if you want to make the internal faces opaque, your sides need to be solid (you can do it with a solidify modifier)

the outer sides are completely transparent, the front is a simple principled shader, in the internal faces you need to use this material:

If you want the red cube to be visible, just make it a simple principled shader.

Here is the final result:

NOTE: if you can still see a dark shadow of the blu cube through the lateral sides, you need to increase the transparency light bounces

NOTE 2: I think you should work a bit on the shadows and decide which objects should cast shadows and which shouldn't (for example right now the front face creates a shadow on the inner faces)


Set new bone length depending on the pose position not rest position

The principle is to take the delta between the previous bone (shoulder) tail and the empty's position (in local coordinate) in pose mode.

Then add this delta to the previous bone's tail in edit mode.

A point where I have spent a lot of time (as newbie here...): 'Vector' in Python is a pointer. So if you don't copy (v.copy()) the vector before you switch between pose and edit mode, the values are changed!

But from that, the result is finally simple:

import bpy

scene = bpy.context.scene
arm = bpy.data.objects['Armbvh']
newbonename = 'My_NewBoneMarker'

empty = scene.objects.get(newbonename)
emptyInLocal = arm.matrix_world.inverted() * empty.location

#Get the parent bone in POSE MODE
bpy.ops.object.mode_set(mode='POSE')

parentBonePose = arm.pose.bones['ParentBone']
parentBonePoseTail = parentBonePose.tail.copy() #Use copy() as if not switching to edit mode will change the values

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

parentBoneEdit = arm.data.edit_bones['ParentBone']

newbone = arm.data.edit_bones.new(newbonename)

if newbone.name != 'Origin':
    newbone.use_connect =  True

newbone.parent = parentBoneEdit
newbone.head = parentBoneEdit.tail
#The tail is the head + the delta between the empty and the tail in pose mode
newbone.tail = newbone.head + (emptyInLocal - parentBonePoseTail)

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


Blender 2.8 how to change toolbar's tools?

At the bottom right corner of the lasso select tool icon you can see a little white arrow head pointing down. Left click on this and slowly drag your mouse downwards.

This will open a menu where you can choose other selection tools.


Sketchfab does not always show the image of your model as published but reverts it to the original state before you modeled it in their viewer, looking for an answer to this issue also but till then I have been using this method to be sure the viewers see the work product I wish to show.
I have been using screenshots loaded to google storage and adding a link
above the model description .


How to animate slices through geometry with a different interior and skin? (e.g. like slicing a watermelon)

Depending on what you want your final outcome to look like you may not need to do anything more then a simple boolean modifier.

Here is a capsule with nothing more then a boolean modifier set to difference, and a animated cube as the target.

You can see it is possible to get a different material for where the boolean cuts the object. Here is how.

Add a second material slot to the object with the boolean modifier (this is the material you want for the "inside" of your object).

The target object (the object that does the cutting) also needs to have the same material.

That's all it takes to get a different material where the boolean modifier has cut.

You can read in further detail about how the Boolean modifier handles materials in the blender manual.


Bisect with boundary edges.
Based on the rectangular nature of the corners of given mesh.

Sample result, far from optimized as some edges above could be dissolved.
A script to create a plane from all the boundary edges. The plane coord is edge center, the plane normal is nominated up direction (Z axis) crossed with edge direction.
Script, run in edit mode.  Note in hindsight should limit this to selected ngons, and edges.  For test sake make the ngon its own object, place in edit mode.
import bpy
import bmesh
from mathutils import Vector

ob = bpy.context.edit_object
me = ob.data

bm = bmesh.from_edit_mesh(me)

up = Vector((0, 0, 1))
def as_plane(e):
    return (
        (e.verts[0].co + e.verts[1].co) / 2,
        up.cross(e.verts[1].co - e.verts[0].co).normalized(),
        )

planes = [as_plane(e) for e in bm.edges if e.is_boundary]

while planes:
    plane_co,  plane_no = planes.pop()
    if plane_no.length < 1e-4:
        continue
    bmesh.ops.bisect_plane(
            bm,
            geom=bm.edges[:] + bm.faces[:],
            plane_co=plane_co,
            plane_no=plane_no,
            )

bmesh.ops.remove_doubles(
        bm,
        dist=1e-4,
        )

bmesh.update_edit_mesh(me)


I'd try Sculpt mode, then hold Shift and drag mouse while holding left mouse button over the ridge to smooth it out.


Rigid body bounces away when starting animation

Apply the scale of your cube (maybe you could also disable the Animated option and switch it to Passive, it depends on what you want to do with it)
Result after applying the scale with CTRL +  A Scale:


How to fix:
Rename folder "Python" in C: and it will no longer try and use that folder.


Try increasing the density in the volume nodes and the number of render samples until the lines and noise disappear.


The "Info" bar on top disappeared and the mouse pointer is misaligned

Consider this solved. It is a driver problem (Intel HD 530 version 15.45.19.4678 doesn't work properly)


Shared and seamless gradient effect between two objects? [EEVEE]

If you use the "Object" output from the "Texture Coordinates" node on both shaders, and then set the origin of both objects to the same location, the seam should disappear.
Example :

Also :


A hook modifier uses additional methods to determine what gets hooked.  It only affects vertices that have been assigned to the hook.  One way to do this is to use "hook to new object" operation (or any of its siblings, ctrl h in edit mode for me) which will automatically assign all selected vertices to the hook.  If you want to just do it manually, you can; enter edit mode on the mesh, select the vertices you want hook, and click the "assign" button on the hook modifier.
Vertex groups work in addition to this.  If you tell the hook modifier to use a vertex group, it will only affect verts that are both assigned to the hook and assigned to the vertex group (to the extent that they are weighted to that vertex group.)


Cloth physics for poly hair and armature

All I needed to do is to select my mesh plus the bone in pose mode and press CTRL+P and set it as parent as Bone


Let's break that down.

  Was wondering if there was a common, base style set up of nodes for
  use in cycles as a good basic starting point to just experiment with
  from with respect to textures and materials.

Yes, there is. Typically your surfaces are some sort of mix between a glossy reflection and a diffuse. Therefore most materials have

A mix node
A diffuse
A glossy

Some materials (basically metals) conduct electricity. They have the property of having a more mirror-like reflection towards the edges and more diffuse reflections towards the center. To model this effect in Cycles one typically used a layer weight or fresnel node feeding into the mix factor.

To find out more about this real world mimicking type of material, have a look at these tutorials by Andrew Price.

  Also, why would one want to use nodes in blender internal to do
  textures and materials? Couldn't you just do the same thing using the
  modifiers panel and properties panel?

Whatever material related work you do through the modifiers and properties panels escapes me. However, the use of nodes in the internal renderer engine allows for some extra effects like mixing two existing materials of different types (think halo and write for example). Related: Mix two materials in the Blender Internal Materials Nodes. Overall it's use cases are indeed quite rare for the average user.,


Rigging Issue, that is effecting animation

Could use more info.  And if you can, can you share the .blend file?  Or just delete the armature and copy this guy: https://www.youtube.com/watch?v=cGvalWG8HBU


You appear to be using glass shaders with high roughness to produce a satin-like effect. Glass shaders can cause a lot of noise and would not seem an ideal fit for cloth (which is essentially opaque). You might be able to get a suitable effect using the Velvet shader or something like the following :

The satin is effectively a diffuse material with an element of glossiness - but glossiness that behaves subtly different to a smooth flat surface. In addition, the reflection off the glossy surface has quite a high roughness with a hint of the 'base' color (since the 'shine' is a mix of diffuse from some fibres of the cloth and glossy from others - so the usual dielectric rule of uncolored reflction doesn't apply here) - hence the Mix node to allow the reflection color to be adjusted. The Fresnel with a high value allows the amount of 'shine' to be adjusted and the Power node adjusts how the glossiness varies based on angle.


One way you could do this is to dynamically create a mask from your marble texture that is used as a mix factor between high translucence and low/zero translucence areas of the material.  So the veins would be low translucence, the whitish parts higher translucence.

This node setup shows the concept in action.  At the bottom on the left is the marble texture I was working with; on the right is a preview of the mask, created using a color ramp.

They say you should always "add" translucence to your other shaders, but honestly I didn't like the way that turned out . . . too bright, hard to see the specularity.  So I used a mix shader instead.  Maybe less physically correct, but I think it looks better.


Resize different sized faces to 1 uniform size?

You could use Smooth and repeat W -> Smooth -> F6 and adjust Smoothing factor and number of Repeats.

Or a small script - at the end of the script all selected faces will have almost identical area. The orientation and shape are preserved.

import bpy
import bmesh
import math
from math import sqrt

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

face_data = []
area_accum = 0.0
for f in bm.faces:
    if f.select:
        area = f.calc_area()
        if area != 0.0:  # avoid divide by zero
            center = f.calc_center_median_weighted()
            face_data.append((f, area, center))
            area_accum += area

            print(area)

area_average = area_accum / len(face_data)
print("average area is:", area_average)

for f, area, center in face_data:
    rescale = sqrt(area_average / area)
    for l in f.loops:
        v = l.vert
        v.co = ((v.co - center) * rescale) + center

bmesh.update_edit_mesh(me, True)

output:

0.009626750834286213
0.01746169477701187
0.020414138212800026
0.009531363844871521
0.012785278260707855
0.016477763652801514
0.010115167126059532
average_area 0.013773165244076933

# if you ran it a second time all areas are as close as they'll get.
0.013773156329989433
0.013773160986602306
0.013773168437182903
0.013773171231150627
0.01377316378057003
0.013773173093795776
0.013773162849247456

(view this image in a new tab to see the difference in area directly displayed on the polygons)

The above script preserves Shape, but uses a rescale factor to homogenize the Area of all selected Faces. If you need to also make all edge lengths the same while preserving Area and Orientation that's possible too.


How to animate perpendicular strips moving along a cable? (visualizing DC electric current)

If you don't mind some stretching and compression - that happens when the segments of the curve don't have all the same length - then you can just bevel a curve and add a procedural bi-color shader that is driven by the frame rate for the animation.

If you don't like the stretching and compression then you can do what moonboot suggested: create a cylinder, apply an Array and Curve modifier. Last but not least, use a procedural shader for the animation. The drawback of this method is that you need one cylinder for each cable. But it can be a linked duplicate, so no biggy.
Shader for animation

Enter #frame + 12 in the purple value field to create the driver. 6 is the speed, and the +12 (=2x6) is needed for a continuous loop over all frames. 2 because it's bi-color. Switch the Add math node to Substract to reverse the direction.


It's an issue with the model of the containers. That strange artifact is in fact 2 faces ocuppying the same space. You have made several different objects and some have overlapping faces between different objects and even with it self. You should do retopology on your model, by just 2 objects: the outer container and the inner container. After you create just this retopologized objects, do the modifiers. You have to check that all edges are well connected, no double vertices, no existance of non-manifold elements.


Fastest way to switch to and from viewports?

Yes first at the top menu where it says default click the plus and name it graph editor now bottom left of blender change window to graph editor  Hold CNTRL on Keyboard and use left or right arrow keys to cycle threw work spaces
repeat this step adding all to the list. when your done setting up click file and save as  MyDefault.blend to desktop you will now have a new blender icon on desktop named MyDefault simply dubble click it and use as your default start up now every time you start up blender simply press CNTRL and arrow keys to switch work spaces.


I see two approaches to this.

You can compile entire blender as python module (completely without user interface) and use it inside an external python script.

https://wiki.blender.org/wiki/Building_Blender/Other/BlenderAsPyModule

A custom solution. as described here.

How to remotely run a Python script in an existing Blender instance?


how to separate one object into different parts?

Try following these steps:

Select the object (In this case it is 'Cube')
Go into Edit Mode (Press Tab)
Press A (Deselect/Select) until everything of that object is selected
Press P -> By loose parts

All of the objects should each have a different 'outline'


Whats the best way to "merge" objects like these

Cleanest way I know:

Add three loop cuts to the blocky object in both directions.
Delete the four middle faces
Snap the vertices to the octagonal object.
go to Object Mode
join the objects
Remove doubles


Modifier Keys using multiple windows of the same file

One way is to use a single Blender window stretched over both monitors. This way there is no need to deal with window focus and your OS can function the same as before. The only downside is when other people open the .blend on single monitor setup with Keep UI setting on.

The other way is to change how Windows give focus to windows. You need to give a window focus when a mouse enters it:

Win7 > Control Panel > Ease of Access > Change How Your Mouse Works (or just search for "mouse works" in search field)

Now the window will get focus when mouse enters it and ShiftMMB will work as it should.

One downside is that every window you enter with mouse will also be raised to the front, which I personally don't like. So this registry hack solves that:

Run regedit (Win+R, regedit, OK)
Open up the key HKEY_CURRENT_USER\Control Panel\Desktop
subtract 40 bits from the first hex value of the REG_BINARY UserPreferencesMask.  That is, if the current value is df 3e 03 80 12 00 00 00, change the df to 9f (df - 40 = 9f).

To make the focus a little slower, so that pop-up windows are useable, you also want to change the focus timing. Change the REG_DWORD ActiveWindTrkTimeout (also in HKEY_CURRENT_USER\Control Panel\Desktop) to the number of milliseconds to wait before focus shifts to the window under the mouse.  Value of 0x00000080 (128ms) is nice, you might like 200ms (c8), or some faster or slower value.

These registry hacks require a log off/on to take effect.

The other downside is that both mouse and keyboard get focus when you enter a window with cursor. So typing in a window won't work when your cursor gets out of that window. I didn't find a solution other than the next way below.

The ultimate way (if you are familiar with Linux x-mouse behaviour) is a 3rd party app to do all that you want: X-mouse Gizmo. There is no install necessary and it is open-source, should also work on Win 10.


Action editor / dope sheet showing extra frame without any keyframes

Found the cause, I had keyframed scale on one bone, should all be loc/rot only. Removing the scale from the bone fixed the issue.


Why does rig work only on one side of the mesh?

Several conditions have to be fulfilled to make automatic vertex group weight mirroring work:

bone names are correctly formatted, usually suffixed by .L or .R, respectively.
vertex groups for both sides exist on your mesh - these may be empty, but must exist for the mirrored side too. First  LMB select the mesh, ⇧ Shift LMB select the armature > ⎈ CtrlP > Armature Deform > With Empty Groups.
vertex groups must be enabled on the Mirror modifier, but they already are by default
make sure the mirror modifier comes before the armature modifier


Just previewing other UVs
There is an option in the UV Editor which - under certain circumstances - allows to see the UVs of other objects. Those circumstances are:

both objects use the same material, the material is active, and the texture is assigned
before entering Edit Mode, both objects have been selected
the Draw other Objects option is checked in the Image Editor (see screenshot below)

Editing other UVs at the same time
Use the Texture Atlas Add-on shipped with Blender to do this. After enabling it in the Add-on manager, you'll find a panel in the Properties Editor of the Render Settings tab. Select all objects which should receive the same UV space first, and then hit the + key to add a new Atlas. Then, hit the Start Manual Unwrap button.

All objects will be joined, you can edit the UVs as if they were one. In fact, at the moment they actually are one object, so pay attention beforehand to your modifiers. When you're done, hit the Finish Manual Unwrap button to separate the objects back to their original state.


Animation import into Unity - mesh deform

The method I use is to select in pose mode all (and only) deforming bones, go to Menu Pose/animation/Bake action, and create a new action, clearing all constraints and parenting, so that the Fbx I'm exporting is a clean rig, with no constraints, associated to the clean mesh. Make a copy of both mesh and rig before any attempt (You'll have to try out some exporting preferences, according to the needs). It works fine.


Texture appears stretched on extruded sections of mesh

This can happen for several reasons, the most common being that you modified the mesh after initially adding the texture, hence the stretched look. A simple fix is to just unwrap the model again.
The fastest way to get a good result with a generic box model like that is to press U > Cube Projection or Smart UV Project depending on how tiled you want certain subdivided parts to look (can read more and experiment with the unwrapping types here).
Extrusions after adding texture

Extrusions after correcting using cube projection unwrapping

Extrusions after correcting using smart uv project


Just lock the transformations in the properties panel (N)- click the padlock icon of the axis you want to lock.


How can a changing angle be measured and used as a property in BGE Logic Bricks?

Assumptions

I assume you have two objects - Object A and Object B.

You need to define what axis of what object you want to measure. Remember each object has three axis (X, Y and Z).

Example

I also assume you want to measure between the local Y axis at Object A (forward vector = [0,1,0]) and local Z axis at Object B (up vector = [0,0,1]).

I assume you have not turned the objects at all. This means initially the angle between the two axis is 90° (when you measure this should be the result).

Vectors in Space

To compare vectors you need to ensure they are given within the same space. Typically you convert both into scene space.

First you need to convert the local axis vectors from local space to scene space.

worldVector = object.worldTransform * localVector

Example

Imagine your object at the origin without rotation. The local forward vector is (0,1,0) facing towards the scene's background. The vector in scene space (world) is (0,1,0) too.

Now turn the object by 180°. The local forward vector is still (0,1,0), but the object is now facing the scene's foreground. The vector in scene space is (0,-1,0).

Formulas

The concrete formula for both vectors is:

import mathutils

forwardVector = mathutils.Vector((0,1,0))
upVector = mathutils.Vector((0,0,1))

objectAForwardVector = objectA.worldTransform * forwardVector
objectBUpVector = objectB.worldTransform * upVector

Example:

Object A is turned by 180°. Object B remains unchanged at the origin.

The vectors will be:

objectAForwardVector == (0,-1,0) # turned by 180°
objectBUpVector == (0,0,1)

Compare Vectors

As both vectors are now given in scene space we can perform operations on it. You wanted to know the angle between them:

angle = objectAForwardVector.angle(objectBUpVector)

Be aware the angle is calculated in radians. You need to convert it:

import math

angleInDegrees = math.degrees(angle)

Example

The final result will be:

angleInDegrees == 90°

Now turn object B by 90° around x. The new objectBUpVector is (0,1,0).

math.degrees(mathutils.Vector((0,-1,0)).angle(mathutils.Vector((0,1,0)))) == 180°

Be aware there is no negative difference. The result is always between 0 and 180.

Snippet

Start with the default scene (one cube). Add a text object. To the text object add an always sensor with True Level Triggering enabled. Connect the sensor with a Python controller that executes this script:

Demo

import bge
import math
import mathutils

UP_VECTOR = mathutils.Vector((0,0,1))
FORWARD_VECTOR = mathutils.Vector((0,0,1))

scene = bge.logic.getCurrentScene()
objects = scene.objects

cube = objects["Cube"]
camera = objects["Camera"]

cubeForwardVector = cube.worldTransform * FORWARD_VECTOR
cameraUpVector = camera.worldTransform * UP_VECTOR #the camera looks against the upvector!

angle = math.degrees(cubeForwardVector.angle(cameraUpVector))

textObject = bge.logic.getCurrentController().owner
textObject.text = "Angle: {:.0f}°".format(angle)

Now apply any logic to the cube that turns the cube (does not matter how). When you run the game p the text will show you the angle between the cube's forward vector and the vector the camera is facing against. This means when the cube's y-face is facing the camera you get 0°.


Character Physics movement = no velocity?

Problem
The "Character" Physics Type does not imply that this object uses the build-in Physics engine. Regarding the Physics engine this kind of object is still a static object.
Therefore you can't apply velocities or forces, nor can you read them. The object teleports within the scene by its own, rather than it is moving in terms of the physics engine.
Solution
Physics engine
Either you use a real (moving) physics type (rigid body, soft body, dynamic),
Character physics
or you record the position at each frame. This way you can calculate the traveled distance from frame to frame via Python. It is simply the difference between the current's frame position and the position of the previous frame.
Remarks
In my eyes

Rigid Body, Soft Body, Dynamic and Static are real physics types.
Sensor and No Collision are attributes (or attribute sets) of physics types
Character, Navigation Mesh and Occluder have nothing to do with physics and should not be at this place. These setting should be at object level not at physics level.


Try creating a new shapekey by pressing the arrow under the add/remove buttons and selecting new shape from mix:

This will create a new shapekey from the current mix. You can then delete all the shapekeys, making sure you delete the new one last.

This gives you a shapekey-free mesh with the shape from the original shapekey mix.


How do I join the output meshes of the Cell Fracture addon?

Your fractured objects are on the second layer. The original object is kept unmodified on the first layer.

The following is a good, detailed video tutorial on the subject: https://www.youtube.com/watch?v=GTq9sLQOiVs


In Blender 2.82, the fluids simulation system has been replaced by Mantaflow which default's caching methods, "modular" doesn't bake on playback. It instead allows you to bake different settings of your simulation individually, which saves a lot of time when you're tweaking your simulation.
You have to manually start the baking via the domain's panel. You can also change the caching method, but honestly the new "modular" is usually a better option).

I'd suggest you follow tutorials specifically made for Blender ≥2.82 or with "mantaflow" specified in the title.


How do I know the number of polygons after adding a subdivision surface modifier without applying it?

This info, blatantly taken from the old manual page, gives you a clear idea on what to expect when subsurfing.

EDIT:
Unfortunately the link to the old manual is gone
http://wiki.blender.org/index.php/Doc:2.6/Manual/Modifiers/Generate/Subsurf
it was worth reading the whole page specially the Performance considerations.
From the new manual:

Performance Considerations
Higher levels of subdivisions mean more vertices, and more vertices means more memory will be used (both video memory for display, and system RAM for rendering). Blender could potentially crash or hang if you do not have enough memory.
When using high levels of subdivision with a graphics card that has a low total amount of Vram, some parts of the geometry will disappear visually. Your mesh will actually be OK, because the render is generated using your Object Data, (even though it cannot be shown by your graphics card).


The .stl exporter already has the option Selection Only to export the selected objects. In Blender 2.80 the exporter options can be found in the lower left area of the file browser. In Blender 2.81 you may need to click on the cogwheel icon to show the options.

Blender 2.80

Blender 2.81 and later


Process meshes that have multiple users only once in script

You could use an array to check if a mesh has been already modified.

theScene = bpy.context.scene

# Store selected objects
theSelected = bpy.context.selected_objects
theObjects = set([obj for obj in theSelected if obj.type == 'MESH'])

#all the meshes here:
meshes = []

# Iterate over selected objects
for obj in theObjects:
    # Set this object as active
    theScene.objects.active = obj
    mesh = obj.data

    # Do something if the mesh isn't in the array yet
    if (not mesh in meshes):
        meshes.append(mesh)

        # Select all edges in edit mode
        bpy.ops.object.mode_set(mode='EDIT')
        bpy.ops.mesh.select_mode(type='EDGE')
        bpy.ops.mesh.select_all(action = 'SELECT')

        print(meshes)

        # Subdivide
        bpy.ops.mesh.subdivide()

        # Toggle Object Mode to select next object
        bpy.ops.object.mode_set(mode='OBJECT')


hello is so easy just follow this steps:
1- add a mix node for your images you want to mix, and plug it to principled shader.
2- set the render sampling to 1 , and tile size to the size of your image.
3- set the bake option to diffuse, and uncheck direct and indirect, and choose a margin size (i recommend 1024px= 4px, 2048 px = 8 px, 4096px = 16px).
4- and then bake your image it should take a few seconds...also if your textures/materials are not in the same uv map it wont bake properly...


How to set a custom center point (pivot point) for the "copy location constraint" (include a simulation video in content)

You can use drivers as constraints: in your example the cursor is at 0,0,4. So X and Y can be managed by the copy location (inverted) constraint. Your new Z value has to be 4 - (Zold - 4). So you can set the Z driver as 8 - Z.

The same can be done with different X and Y values.

Another way can be set the copy location constraint in local space (instead of world space), check the offset option, then move both meshes to the pivot point (Shift S - selection to cursor).


Produce Isometric Rendering with Height / Depth / Normal Map for Dynamic Lighting layer

I think you should approach this a different way.

Using a displacement map to generate your whole world probably isn't a good idea. It will actually lead to lower quality and worse performance.

When making a game, the usual process goes something like this:

Make individual models (assets) for the game. This would mean things like houses, trees, walls, etc. would be individual objects. I would imagine that is how you made your scene initially.
Add materials to these objects. When you export a model to a game engine from Blender, the only information about how the objects look is stored in an image texture. Thus, anything that can't be stored in an image texture (fog, glowing objects, anything that has to interact with the world in real-time like a reflection, etc.) usually shouldn't be done inside Blender, at least not in the way that you'd normally set these things up in Cycles.
Export the individual assets with their textures to a game engine, and build/rebuild the world in the game engine.

When making the individual assets for a game, there is a general process that is usually followed for this too. I'll use a house as an example since you have one in your scene.

Start by making the 3D model. If your goal is to make the house as realistic as possible in the game, you would make a very detailed house model in Blender. If you're not going for really high detail, you can make the house with less modeled detail in Blender. This can still give really good results too.
Texture the house, using whatever methods you want. You can use image textures, procedural textures, whatever it takes.
If you made the house with more modeled detail than you think the game engine can handle, at this point you would "retopologize" the house, meaning making a lower detail version based on the high detail model.
Bake the various kinds of detail into image textures. I think this is the step that will help you the most. Cycles has a bunch of options to bake detail, including normals, roughness, color, shadows, and many more. These settings are all found at the bottom of the Render Properties tab (the Camera icon) on the right side of the screen. If you have a high detail and low detail model, you can bake the normals from the high detail model to the low detail model, making it look like it has more detail than it actually does.
Once you have an individual object made, with as little modeled detail as possible, and you have all the textures that you need for that object, you would import it into the game engine. This process can vary depending on the engine, so if you need more information on how to do that I would look up tutorials or other information on the specific game engine.

I mentioned that using a displacement map will give you a lower quality result, so I'll explain that a bit more.

Let's look at a simple cube. A modeled cube has only 6 faces, which will be converted to 12 triangles when rendered. No matter how close you get, the faces will appear perfectly flat, and the edges nice and clean. If you use a displacement map, you will need a very dense mesh to displace to get even close to the same amount of definition. If you wanted to a get an edge that appears perfectly straight and sharp, you would actually need a mesh that is so dense that each face ends up smaller than a single pixel. Otherwise you would get jagged edges, rounded edges, weird faces on the edge, or other issues. For certain things displacement maps can be great, but in general, a properly modeled and textured object can be more detailed with less faces.

If your concern is realism while keeping it easy to render, I would look up more information on modelling game assets, baking details such as normals, and how to setup game worlds using whatever engine you choose.

I know there's a lot of information here, and this still isn't a perfect guide to making games, but it should give you enough to get you started and help you find more information.

Hope this helps!


You could try something like this. I used a Voronoi texture clamped with a Color Ramp, similar to what you did to make the main dots. I then used another Voronoi Texture, scaled up slightly, and clamped differently with another Color Ramp to get the smaller dots. I also mixed the input vectors of both the large and the small dots with  a Noise Texture to make them less perfectly round.
Lastly, I mixed the whole thing with another (largely scaled up) Noise Texture to give the fine "grain". I also gave a very small subsurface value to emulate that semi-translucent rubber look.


Keyframe animation is lost at FBX export

OK, I've realized I have to bake the animations, so that solved.
But now I have the children of the parent object all over the place in FBX.


Mirror Modifier creates the other part of model far away from the original

The Mirror modifier works exactly "as it should".

Meaning it will mirror the geometry using the object's origin (that orange dot that you see in the girl's forehead) as the axis of symmetry. If your geometry is far away from the origin, the mirrored geometry will be as far away from the origin but on the other side of the axis.

Read the blender manual page to understand how the tool works:
https://docs.blender.org/manual/en/dev/modeling/modifiers/generate/mirror.html?highlight=mirror%20modifier

As an alternative to using the objecct's origin, the mirror modifier can also be used with a control object. As detailed in this answer: https://blender.stackexchange.com/a/49355/1853


How to make game, made with the BGE, without having to provide source code of the game?

Stand Alone:
The Blender Game Engine is GPLed.  There is not a way to release a game made in the Blender Game Engine without including the Blender Game Engine.  Including the Blender Game Engine makes your game GPLed.

Stand Alone, load external .blend:
You can compile the BGE into a standalone player that loads the .blend of your game, and have the .blend be under a different license.  This would make it illegal for someone else to use your work, but it would trivial for people to break the law and poke at the blend file.

Encrypt:
You could obfuscate the blend file using encryption libraries in python.  The executable which is GPLed would contain the key, and a smart enough dedicated enough person could get at your blend file. It would prevent the average Blender user from being able to steal your assets though.  See: https://pypi.python.org/pypi/pycrypto for a crypto library.

Practicality (opinions included, sorry):
There is nothing on your computer that you can't "steal" assets of if you are dedicated enough.  There is no way for someone to both have something and not have it at the same time. Stop worrying so much about "theft", and generate a game good enough that people people are willing to pay. If you get big enough where you see large scale copyright infringement, use the DMCA and other copy right laws if you feel the need; but I think you'll find that over enforcing copyright and preventing modding will hurt you in the market place more than a few free loaders abusing your game assets.


Python command within script to abort without killing Blender

If it is meant to be temporary while drafting the script, raising an exception is probably the easiest solution.

raise Exception()

If it is not meant to be temporary you may consider reorganizing your code using additional functions or logic/control flow. Python actually runs faster if the code is wrapped in functions. (see this post on stackoverflow)

The equivalent to running the code from the text editor is (see api docs)

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

Calling sys.exit() raises an exception which is allowed to propagate and thus exits blender. (see
SystemExit,
exit(),
exec()
)

You may run your script manually with exec and catch an exception, i.e. SystemExit, with try ... except.


I think the answer is you dont use blender for unreal cloth. I think you make the cape in blender same as any other mesh, then import it into unreal and do the cloth there. Unreal used to use something called apex cloth (which it still can), but now also has its own cloth authoring tools.

Here is a link to a video showing unreals clothing system, if you skip to 5:00 exactly it will show you how to author cloth with the new system in ue4.

https://www.youtube.com/watch?v=4ZN3WHh3M9M


How would one go about creating a genetic algorithm and/or neural network for blender?

Seems like what you need is simply to import python machine learning libraries to Blender. Blender has its own python, but you can enable importing machine learning libraries to Blender in two ways:

Install these libraries on Blender's python, hopefully using pip.
Make blender use the system's python (has to be the same Python version as the bundled python installed with Blender).

If you're not sure where to find Blender's bundled python, type this in Blender's interactive python console:

import sys
sys.path

This will show you all the included libraries available to scripts running in Blender, and among them Blender's python directory. Here's the output of this line on my machine:

['C:\\Program Files\\Blender Foundation\\Blender\\2.78\\scripts\\addons_contrib', 'C:\\Users\\tfc64\\AppData\\Roaming\\Blender Foundation\\Blender\\2.78\\scripts\\addons', 'C:\\Program Files\\Blender Foundation\\Blender\\2.78\\scripts\\addons', 'C:\\Program Files\\Blender Foundation\\Blender\\2.78\\scripts\\startup', 'C:\\Program Files\\Blender Foundation\\Blender\\2.78\\scripts\\modules', 'C:\\Program Files\\Blender Foundation\\Blender\\python35.zip', 'C:\\Users\\tfc64\\Anaconda3\\Lib', 'C:\\Users\\tfc64\\Anaconda3\\DLLs', 'C:\\Program Files\\Blender Foundation\\Blender', 'C:\\Users\\tfc64\\Anaconda3', 'C:\\Users\\tfc64\\Anaconda3\\lib\\site-packages', 'C:\\Users\\tfc64\\Anaconda3\\lib\\site-packages\\Sphinx-1.4.1-py3.5.egg', 'C:\\Users\\tfc64\\Anaconda3\\lib\\site-packages\\win32', 'C:\\Users\\tfc64\\Anaconda3\\lib\\site-packages\\win32\\lib', 'C:\\Users\\tfc64\\Anaconda3\\lib\\site-packages\\Pythonwin', 'C:\\Users\\tfc64\\Anaconda3\\lib\\site-packages\\setuptools-23.0.0-py3.5.egg', 'C:\\Program Files\\Blender Foundation\\Blender\\2.78\\scripts\\freestyle\\modules', 'C:\\Program Files\\Blender Foundation\\Blender\\2.78\\scripts\\addons\\modules', 'C:\\Users\\tfc64\\AppData\\Roaming\\Blender Foundation\\Blender\\2.78\\scripts\\addons\\modules']