How to split objects to increase effective resolution of particle effects

As the particle system is just a way to obtain the result, I propose to do it another way. A script was needed anyway, so the following script does a voxelisation directly.

Instead of PS, it uses a script and dupliverts.

The script creates a mesh with vertices only so that the duplivert can be applied:

It takes a mesh as input
Calculates its boundings
Maps x, y, z inside the boundings at voxel size steps
Then uses a BVHTree to test the distance of these (x, y, z) to the original mesh

Once done, you just have to create a cube at the same voxel size and parent it to the generated mesh (with duplivert).

From that, you may want to make an exportable mesh:

Select the dupli
Use the menu 'object>apply>make instance real'
Select the instances and join them

Performance: tested on this bunny at 2mm voxel size. That's about 350k vertices. So 1mm should be around 8 times this amount.

The calculation is relatively fast, but once the duplivert set up, Blender becomes a bit slow.

The script:

import bpy
import bmesh
from math import ceil
from mathutils import Vector
from mathutils.bvhtree import BVHTree
from itertools import product

# Create an object from vertices only
def create_object( context, vertices ):
    mesh = bpy.data.meshes.new( "voxel" )
    obj = bpy.data.objects.new( "voxel", mesh )
    context.scene.collection.objects.link( obj )
    bm = bmesh.new()

    for v in vertices:
        bm.verts.new(v)

    bm.to_mesh( mesh )
    bm.free()

    return obj

# Get object bounding as min max vectors
def boundings( obj ):
    min_x = min( (Vector(b).x for b in obj.bound_box) )
    max_x = max( (Vector(b).x for b in obj.bound_box) )
    min_y = min( (Vector(b).y for b in obj.bound_box) )
    max_y = max( (Vector(b).y for b in obj.bound_box) )
    min_z = min( (Vector(b).z for b in obj.bound_box) )
    max_z = max( (Vector(b).z for b in obj.bound_box) )
    return Vector( (min_x, min_y, min_z) ), Vector( (max_x, max_y, max_z) )

# Voxel
def voxelize( context, obj, size ):
    # Get boundings
    min_bounds, max_bounds = boundings( obj )
    # Delta vector
    delta_bounds = max_bounds - min_bounds
    # Vertex count in all dimensions
    counts = Vector( (ceil( delta_bounds.x / size ), ceil( delta_bounds.y / size ), ceil( delta_bounds.z / size )) )
    # Reajusted starting position
    starts = min_bounds - ((counts * size) - delta_bounds) * 0.5

    # A BVHTree from the mesh
    depsgraph = context.evaluated_depsgraph_get()
    tree = BVHTree.FromObject( obj, depsgraph )

    half_size = size / 2.0
    vertices = []
    # Cross products of the wanted ranges
    for x, y, z in product( range(int(counts.x)+1), range(int(counts.y)+1), range(int(counts.z)+1) ):
        # Corresponding position
        vert = starts + Vector( (x * size, y * size, z * size) )

        # Test the proximity to the mesh with the BVH tree
        result = tree.find_nearest_range( vert, half_size )
        # If close enough add the location
        if result:
            vertices.append( vert )

    # Create an mesh from the result
    return create_object( context, vertices )

# Get current object
obj = bpy.context.object
# Define voxel size
voxel_size = 0.002 # <<< Change this to change the resolution (in meters)

# Create the voxel
voxelize( bpy.context, obj, voxel_size )

The file with low res voxel:

Another example:

Complements:

To use the script:

This is not an addon to Blender, so you have to open a text view in Blender, create a new text and paste the code in it (same way it is in the uploaded blend file)
The script contains a parameter in the line commented '<<< Change this to change the resolution (in meters)' above. This 'voxel_size' parameter corresponds to the size of the cubes
Then select the mesh (active mesh) in the 3D View and run the script using the button 'run script' which is on the top right of the menus of the text view (you can also use AltP when the mouse is in the text view)
The calculation starts after that and Blender may hang for some seconds. This calculation time depends on the 'voxel_size' parameter and on the mesh dimensions. The ratio 'dimensions/voxel_size' power 3 gives the voxel cubes amount. I preconize you start with a relatively high value for voxel_size so that there is few cubes in result. After that and depending on your configuration lower this value.
Once done, the script has create a new mesh which is vertex only (no faces). You'll have to follow what is written above about dupli and parenting to make a base cube of voxel_size dimension fill the mesh


You can invert the colors of a vertex paint with python. The algorithm to invert the color is as follows:

new_color = 1.0 - current_color

Here is the code to invert the color of a vertex paint. Note that you should substitute the name Cube to the name of your mesh. Same goes for the vertex paint layer Col.

import bpy
import random

# get and store the object in object mode
obj = bpy.data.objects["Cube"]
mesh = obj.data

# set active vertex paint layer
color_layer = mesh.vertex_colors["Col"]

v = 0  # current vertex in loop

# iterate over the verices and invert their color
for poly in mesh.polygons:
    for idx in poly.loop_indices:
        col = [(1 - color_layer.data[v].color[i]) for i in range(3)]
        color_layer.data[v].color = col
        v += 1

# We have to refresh Vertex Paint mode to see the changes
bpy.ops.object.mode_set(mode='OBJECT')
bpy.ops.object.mode_set(mode='VERTEX_PAINT')

Final Result

The advantage of this method is that you do not have to constantly invert at rendertime.


Automatic "Edit Window" popup - Blender 2.8

You can make the box reappear after it has dissappeared by pressing F9 key to change the settings. I hope this helps.


In the VSE add a color strip
[

The sample the source frame to change color of effect strip

Press F12 key to render a frame inot UV Image editor window then change to mask mode and add a mask.

Select the color strip and add mask modifier

change the effect strip's blend type to over drop


Sharpen with Crease edges values

If is suitable with your geometry, you can use a high value of Crease Edge amount to the edges that start from the vertex you want pointy.

Pick the vertices, extend selection with Ctrl++ and than Ctrl+E to set the Crease to 1

More purple the edge is, higer the Crease value result.

If you are not interest on the sharp edges but only to create a spiky geometery, you can loopcut the piramid with a loopcut that lay in the plane that has the same normal of the base.

To opbtain this you can use the kinfe tool, or by extruding, or subdividing.

Double press G key to slide the loop near the vertex.


How to load an object from another scene in the bge?

You cannot add objects across scenes. Scenes are completely seperate. What you can do is you can use LibLoad to combine two blend files. So if you have your assets in one blend (assets.blend), you can use:  bge.logic.LibLoad(path_to_blend, 'Scene')
to merge the two scenes. If objects are on an inactive layer in assets.blend, then you can use addObject to add them when/where you want.

(note that the 'Scene' is to tell it to load whole scene, but does not tell it which. There is no way to tell LIbLoad which scene to load - it will do the one that the blend is saved with)


Color faces of a from_pydata mesh depending on face height

I usually do it with the following node setup:


blender is crashing while rendering fluid simulation

Try with Command Line Rendering. It tends to be more stable and faster than normal rendering. Here is a video with explanation on how to do it. It is easy, there isn't much to mess up there if you follow the instructions.
Shortly said, rendering in the Command prompt (CMD) is opening blender in the background, without having it actually opened. When Blender is open, it has to keep the 3d view and much more stuff loaded. But when you run it through CMD, you make it to load only the operation you need it to do.
How to do it
1. Open CMD - In the Windows search bar simply type "Cmd", and open it. It doesnt matter if you open it as administrator or not.
2. Locate the blender .exe file - The easiest way it to use the desktop shortcut, by right clicking  on it --> Open File Location, but can be done from Windows start menu. The copy it and go back to CMD.
3.  Set the working directory of the prompt - In CMD, type cd <blender.exe folder>. Usually its in Program Files --> Blender Foundation --> Blender <version>, but it may vary.
4. Do the magic - What you have to do now is to run blender.exe, but with special settings. One thing to note, the settings are just one letter, like -a, followed by specification. There is a space between the setting and the specification.
First, start by typing blender.exe(dont run yet). This will open blender normally when executed.
Then, add the special settings. At first, you need to specify which project will be rendered - i.e the location of the .blend file. So, to what you have written, add -b- this the option, specifying the location of the file. After it, add the location. So, you should have blender.exe -b <location of .blend file> Dont run yet.
Now, you need to specify which frame are you rendering.
For a still image, you use -f, followed by the frame number - -f <number>.
For animation, you use -s for the start frame, -e for the end frame, and then you add -a to tell the program that you are rendering an animation- -s <number> -e <number> -a
Additionally, you can specify an output location, but thats not really necessary, if you have one in the file. Use -o for it, followed by the output folder.
Now, you should be left with something like this:
blender.exe -b <.blend loc.> -f <rendered frame num.>
or
blender.exe -b <.blend loc.> -s <start frame num.> -e <end frame num.> -a
All you got to do now is to run this command. It shows the progress in the CMD. One really cool thing about it, is that you can actually pause it, even on one frame renders. Just click Pause Break button on the keyboard while the CMD window is active. To resume, click it again However, the render gets somehow slower after resuming, so i dont recommend this.
Thats all you really need to know about it, and even if it doesnt apply for that project, its really good to know it for the future.


How to clean up intersecting faces and edges?

Edit: As your request has changed I give a second answer below.

Maybe you're not choosing the best way to build your object, in your case the Solidify modifier will create unwanted intersection and it will be hard to fix.

What you could do for example is begin with a triangle (3 vertices circle), extrude it up, then select the 3 faces, press AltE to extrude, choose Individual Faces and drag to extrude.

Second answer:

Create a 10 vertices circle, scale one of 2 vertices so that it makes a hexagon.

Move down those vertices, extrude down the whole mesh.

Select one of 2 edges underneath, bevel them, extrude down.


matcap generator

This is a great matcap generator .blend from Ben Simonds.  I'd imagine you could simply apply a texture to the sphere and render it out.

Then, apply the matcap to your model using reflection coordinates, and go to textured view mode to see the results.


Using Python to select Inner loop in my mesh is producing unexpected results. Any suggestions? Blender 2.8

Is this what you want to select?

for v in bm.verts:
    v.select = not v.is_boundary


How can I fill the face just between the vertices and not the inner circle?

What you want is "Bridge Edge Loops". Select the two "rings" you want to connect, right-click, and select it. Do this for both sides. See below:


Bone in wrong position when apply animation

I figured out that this was happening because of the different rest poses of the armatures. Because my character had legs and arms in different positions, the animation was weird. Fixed the rest pose and all works fine. Hope it helps someone.


You could more easily do it through the Graph Editor: open the Graph Editor, select the track that you want to repeat indifinitely, for example the X Location track, open the right panel with N, add a Cycles modifier and in the After dropdown menu choose the Repeat with Offset otion. Do the same operation for the Y Location track as your object move on both these axis.


If you bake only up to the desired frame, that is the easiest solution.

As reference in the comments, this does not appear to be possible.


Change the Coordinate System for Unity Export?

Just model in blender the way it is intended. Before you export your model to unity you can adjust the export settings in the export dialog, there you can switch the axes around however you like.


Preserve Shape of Texture, when Object gets edited?

Short answer - you don't.

The UV layout is tied to the object in a way that each vertex in the UV layout represents a vertex in your 3D mesh.

Imagine a rubber skin that gets stretched around your model. You paint it to look good on your model and afterwards you stretch your model or add new parts to it. Now, the same rubber skin has to cover a different mesh, which results in stretches.

You can make the stretches visible in Blender, if you activate the stretch indicator in the Properties Region of the UV/Image Editor.

Moving vertices around creates stretching in the area and the angles of your UV layout.

If you manipulate the vertices in your 3D mesh, you also need to update your UV layout to avoid stretching.


If you want the Y Axis to be smaller you need to make the Text/Font smaller.

You could reduce the Display Scale under the User Preferences > Interface.

However, this will affect all unsizable text in Blender.


Soften is not a drawing tool, but a tool to 'soften' the range of pixels under the brush like a blur tool. When you paint with it in the 2d editor, you are actually blurring the pixels there in the alpha and causing an error where they then appear black - but that is not a paint effect, but an error. TexDraw is the basis tool for painting when putting down color, and set it to 'mix' to put paint into a zero transparency image. By painting with that and using the image as a stencil, you will get the image into the 3d view as paint - but you really might consider instead using it as a stencil in the Texture Mask and using the alt-rmb combinations to move it around scale it and rotate it. Once you have all your pixels painted in, then you can use a Soften over any harsh edges, or push them around with the Smear to push them around to get variation... here is a screenshot of me painting with TexDraw using your texture as a mask brush set to Stencil

edit: Load up TexDraw and set it to use 'Mix' as mixing mode(default) and then delete the textures from both 'Texture' and 'texture Mask' in the brush tool bar (this doesn't remove them from blender, so you will be able to call them back up later in another brush). Select a color in your color mixer so that it will show up on the surface of your model, and paint across the surface to test - does it show up as a paint stroke? TexDraw used to be just the Texture brush, and Draw was the Brush.., but the original 'Brush' was eliminated and 'TexDraw' was kept. Soften. Smear, Clone all work only if you have pixels painted into the image already from TexDraw, and Fill also is a brush to drop color pixels into the image. Fill can be tricked into becoming an eraser, but that isn't needed here. If you can get paint into the image, then from there you can refine it - Only TexDraw would be my first option to use your image as a Brush or Brush Mask texture to paint in grunge. The Brush will paint in a Color version of the image where ever the white is, and not in the black. The Brush Mask will paint only where the white portion is, but also allow you to use another texture as Brush and create more complicated mask and brush combinations. Often times I use an image as Stencil for the Brush and a procedural like Clouds set to Tiled on Brush Mask so that the clouds chip away from the stencil organically.


Final result

It's extremely simple setup. The one from your image.

Steps

Create UV Sphere and add to it Glass Shader.
Add Plane with choosen image, use Emission Shader for this. You can use Images as Plane Addon then you need to switch from Diffuse to Emission.
Place Plane behind Sphere and...
That's it.

Final thoughts:

If you want clear background behind the orb, select Plane and in Object tab > Cycles Settings, uncheck Ray Visibility > Camera.


The key concept here is linked data.

When you create geometry with the array modifier, all of the instances behave as a single object, they share the a common origin (or pivot point) and any changes made to the geometry of the original will be replicated in all of the instances.

If you apply the modifier you are creating a single object, comprised of copies of the original mesh, but the geometry of the independent meshes it contains is no longer shared. In other words: an object can have different disconnected meshes, and all of them will have a single origin (pivot point), but If you edit any of the meshes in edit mode, all others will remain unaffected as they do not share any data.

Likewise, if you Duplicate an object in object mode, or by adding, you create a completely separate object, that shares no mesh data with the original object. If you parent the objects they will behave as one in the sense that you can rotate, scale and move the parent, and all of the children will follow accordingly, but if you edit the mesh all of the meshes will be unaffected as they do not share the same mesh data.

If instead of a duplicate (⇧ Shift+D) you create a linked duplicate(⎇ Alt+D) you will create two objects that are independent, in the sense that they have different origins and can be rotated, scaled and moved independently, but they share the same data. Editing the mesh of one will change all of the copies that share the same linked data.

Look what happens in the outliner as the linked copies are being created, even though they are different objects (suzanne, suzanne.001 and suzanne.002) the mesh data is the same (suzanne as the original one)

Lastly, those independent objects that use the linked data can then be parented, so that they can be rotated, scaled and moved following the corresponding transformation on the parent object.


Not a solution to the problem (which might be me doing stupid things on my file) but a solution to preserve my work:

I have opened an earlier version of the shot (which was working fine) and imported the actions from the bad version.

Thank you for your help everyone!


Dynamic creation of properties for export script

In addition to what Adhi suggested, you can use CollectionProperty in your operator to store key value pairs (where keys are name of the action and values are boolean values). For this to work you must...

create a subclass of PropertyGroup that will hold single key-value pair.
populate this collection from Operator.invoke method (you might already have it)

So the code goes like this:

import bpy
from bpy_extras.io_utils import ExportHelper
from bpy.props import *

class ActionSelProperty(bpy.types.PropertyGroup):
    name = StringProperty(name="Action Name")
    export = BoolProperty(name="Export", description="Exporet this action", default=True)

class ExportTSA(bpy.types.Operator, ExportHelper):
    bl_idname = "test.export_tsa_op"
    bl_label = "Export TSA"

    actionprop = CollectionProperty(name="Actions", type=ActionSelProperty, description="Select actions to exporet")
    filename_ext = "*.*" # Only needed if subclassing `ExportHelper`

    def invoke(self, context, event):
        for aname in bpy.data.actions.keys():
            self.actionprop.add().name = aname
        wm = context.window_manager
        wm.fileselect_add(self)
        return {'RUNNING_MODAL'}

    def draw(self, context):
        layout = self.layout

        for aindx in range(len(self.actionprop)):
            row = layout.row()
            row.prop(self.actionprop[aindx], "export", text=self.actionprop[aindx].name)

    def execute(self, context):
        for aprop in self.actionprop:
            print("%s:\t%s" % (aprop.name, aprop.export))
        return {'FINISHED'}

def register():
    bpy.utils.register_module(__name__)

if __name__ == "__main__":
    register()

In this case,  name is a key and export is a boolean value.

PS: Invoke by searching Export TSA. Screenshots:

This may not be perfect, but you can investigate more! :)

HTH


Problem solving geometry or camera alignment using tracking

Just moving the camera around, panning and tilting while remaining on the same spot will not work, so don't waste any more time trying to match anything.

You will not be able to get 3d information from a stationary camera.

If there is no displacement (as in: taking a few steps while filming the object) there is no way for blender to determine 3d from parallax. To estimate depth, it is necessary to see the objects from different places.

If the camera is static you can use "Tripod" solve (https://docs.blender.org/manual/en/latest/movie_clip/tracking/clip/editing/solve.html#tripod), but note that the tracked elements will not yield any 3D information, only camera rotation at best. The tracked elements will only be projected in a sphere around the camera.

For detailed explanation read through these related posts:

Problem with camera orientation in motion tracking

How can I get better results when doing camera motion tracking?

Motion tracking is oriented incorrectly; no depth

Using the same tracking marks make another shot (or series of photographs) and walk around that corner of the room. Then you will be able to make a proper camera solution and have 3D information.


On Windows, you can kill Blender easily by opening the task manager,then selecting "end process".
You would not need to use python.
Here's a pic:

You can access task manager by pressing CTRL+ALT+DELETE.
On Mac, you can do just about the same thing, just this is done in the activity monitor Instead.


How to attach a texture to the first object of an array?

In the texture properties, you will find an Image Mapping panel as well as a Mapping panel. In the Mapping panel, you want to select UV as the coordinates value.

You can then get better results by properly UV unwrapping your object to control which part of the image is used.


2.8 UV editing, can't box select polygons in 3D viewport anymore

The answer is to delete the UV Editing workspace and make a new one.

Big thanks to Jachym Michal for the solution in a comment.

Steps

On the tabs across the top of the window (these are Workspaces), right click on UV Editing
Select delete

Click the [+] icon on the right of the workspace tabs
Navigate to General ➡ UV Editing

You'll have a new UV Editing Workspace. You might need to zoom in on your UV and re-apply any 3D viewport settings you had.


How do I make my mesh move 1-1 with the bones

The effect of the armature on the mesh is an accumulation of all bones - to make a section of your mesh follow the action of a single bone you do need to ensure the weights for that single bone are all at 1.0, but also you need to ensure that the weights for that section of mesh are zero for all other bones - otherwise the other bones will also be affecting its deformation, negating some of the effect.


How can I loop through screen areas and point to specific area?

Not sure what do you mean the second one but you can select the second one with further conditional list:
[area for area in bpy.context.screen.areas if area.type == 'IMAGE_EDITOR'][1]

And also there are properties x and y for area type, which indicate the bottom-left corner position in your screen. You can write some sorting function to select the desired one.
Area(bpy_struct) — Blender Python API


Why are all right bones not connected with the mesh?

Thanks guys,i found out that i DIDN'T apply the mirror modifier!stupid me,now it works perfectly!


Export only the selected object to STL file in Blender 2.8x

First select the object you want exported, then begin the export process as normal, by going to File > Export > Stl, then under the Include section, you will see a checkbox for exporting only the selection.


Curve modifier won`t allow for input of object?

It's named "curve" because it was originally a curve, but somehow it got converted to a mesh.

You need to use "Object -> Convert To... -> Curve from Mesh" to make it back into an actual Bezier curve again. Then you'll be able to use it in the modifier.


Baking normal for high poly sculpture not applying to low poly mesh

Bake from multires only bakes the information of the multires onto the same object. Since you used the decimate modifier, you probably changed, if not destroyed the UVs. That's not the option you need. You need to bake the normals with the option Selected to Active checked, with your highpoly selected and your lowpoly active and slightly inside the high poly. Do check the UV map of your low poly one though.
Also: Make sure to check the normals in rendered or shaded view, your screenshot is a bit too low res to really make out what's going on.


How to create a 'ribbon wrapped' sphere?

This shape being created in a 2D illustration program is not entirely possible in 3D without some distortion. That being said a close approximation may be achieved.

It's a bit of an involved process so I won't go into full details here, but I'll try to get the main steps. Here's the rough procedure of what I could come up with.

Create a bezier curve circle
Rotate it so it faces the front view
Rotate it 60º in the Z axis
Erase the back half
Duplicate it in edit mode so it is symmetrical along the Y axis
Repeat the process by duplicating the two half circles and rotating them 90º in Y axis so the produce the two frontal horizontal loops.
Now the tricky part is making sure you selecting the correct overlapping end vertex and connect them to the proper corresponding loose end by pressing the F key
Repeat the process 3 times. For the last closing loop just Toggle Cyclic option for the selected spline from the Properties Window
This will make half the necessary loops. Luckily the remaining ones are just a copy of the current ones rotated 45º along the Y axis, then scaled negatively -1 unit along the 7 axis to complete all the loops.

Afterwards you may add a flat segment bezier curve as Bevel Object to make the ribbon shape.

You may also optionally add a Shrinkwrap modifier to a sphere object to approximate the shape into a more accurate sphere.

If you want thickness a Solidify modifier after the Shrinkwrap will do the trick.


How to prevent specific bones in an ik rig to bend?

As IK is calculated after all modifier stacks, every bone of an IK chain has a properties panel in which you can configure its behaviour.


Maybe u forget to add 'R' before the file path?
bpy.data.images.load(R"H:\blender__texture_maps_ao_normal_height_etc\Wooden_planks_04_2K_Base_Color.png")
It should raise an error in python but my blender doesn't show any error message. Everything works fine in my blender.
Edit: You can use the following code to scale your uv instead of using bpy.ops.transform.resize
See more information here
me = bpy.context.object.data
uv_layer = me.uv_layers.active.data

scale_factor = 2
for poly in me.polygons:
    for loop_index in range(poly.loop_start, poly.loop_start + poly.loop_total):
        # rearrange uv coordinate from 0~1 to -1~1 and scale it.
        uv_layer[loop_index].uv.x = (uv_layer[loop_index].uv.x - 0.5) * 2 * scale_factor / 2 + 0.5
        uv_layer[loop_index].uv.y = (uv_layer[loop_index].uv.y - 0.5) * 2 * scale_factor / 2 + 0.5


Attach objects to every face of one model

Both Particles and Dupliframes have brought me more headaches than happiness so thought I would share another approach. It might not exactly be an answer to your question but it might be helpful.

Take one tile you have modeled and add two array modifiers to create horizontal & vertical tiling. Add a lattice modifier in Object mode and adjust it's shape to enclose the roof. In Edit mode you can reshape the lattice to create the drooping shape in the roof.

While not suitable for hyper-realism it is a relatively easy & effective.


Blender Arm Twists After Applying Automatic Weight Paint

After searching around some more I found a related post here:
Parenting Armature to Mesh with Automatic Weights deforms Mesh
My issue was that my Pose Position and Rest Position were different, as I showed above, however, I wasn't sure if this was normal or how to go about fixing it. I found from the other post that it's actually the reason for the mesh deforming and the fix is pretty simple. Selecting all of the bones in Pose Mode and pulling up the search bar with f3 you can type "Apply pose as rest pose", hit enter, and then parent the armature to the mesh and apply automatic weights and the issue with arm twisting is gone. I'm pretty new here but I think this post may be classified as a duplicate now but I found a lot of similar posts unanswered so hopefully, this is helpful to other beginners running into similar troubles.


Blender 2.8 (python) - input RGB doesn't match hex color nor actual color

TL;DR Enter hex values in the hex tab of the color picker.

Hex values in itself don't specify how they are supposed to be displayed. It depends on the color space that is used to interpret the value and the display transform to show it on your monitor. For the internet, where these hex codes are commonly used, it's standard to use the sRGB color space. It uses the Rec. 709 primaries. The conversion of values from CIE XYZ to RGB values includes gamma correction.

If you want to use your gamma corrected sRGB values represented as hex, then you have to use the hex tab to directly enter them. The RGB selection in the color wheel is using scene linear data / scene referred values that are not gamma corrected, which is why you're getting a different color than you're expecting.

  In Blender, the Hex and HSV/HSL values are automatically gamma corrected however, for the RGB values, they are in Scene Linear color space, and are therefore not gamma corrected. For more information, see the Color Management and Exposure page.


Light point power keyframes not showing up in graph editor

In my particular case I could not see the points in the graph editor because the power of my light was 2000 W and it was way beyond the default view range.
As suggested by AtomicBezierSlinger you could perform a Select All (A) and then View Selected (Numpad .(the period key)):

Alternatively, you could also View All (Home). This is convenient if a numerical keypad is not available.


Here's how the stabilzation's supposed to work in Blender:

The trackers included in the 2D Stabilzation tab get pinned down.
The image then gets repositioned to keep those tracked points in the same place, effectively countering whatever move you had made.
Blender has no way to discern which movement is intentional and which isn't...

A workaround for stationary shots with panning (or tilting) is recreating the move after you have stablized the shot.

To do that you need first to unclick the 'Autoscale' button in the Movie Clip Editor. The repositioning of the clip is done on the compositor adding a 'Translate' or 'Transform' node. Note that you will need to rescale the image a bit.

In this case you're panning from left to right, but Blender is moving your image in the opposite direction. So you need to move it back again on the x axis from left to right, so that your picture stays in the frame.

In the Compositor add a 'Movie Clip' node with with the original video footage (or image sequence) and you plug it to a 'Stablize 2D' node.

On the 'Stablize 2D' node select the tracked Movie clip as source, so Blender can use the tracker information associated to the clip. The output of this node will be the stabilzed image.

Add a 'Transform' Node, and that's where you'll recreate your camera move.

On the Timeline go to the first frame of the clip.

Back on the Compositor change the values on the 'Transform' node to reposition your image so that it fills the frame. Add a key frame on the 'Transform' node by pressing I.
Scroll down the Timeline to the end frame, reposition the image again using the 'Transform' node and set another key frame.

You might need to play with the interpolation curves, or add a couple more key frames. If your image doesn't fill the frame correctly, showing the edges of the original image, then make changes on the scale. After some trial and error you should have a nice panning shot with no jitter.

Notes:

It's possible that the lens distortion become more obvious. Undistorting might help for that.
Also, since you are rescaling the image, know there will be some quality loss (your image might be softer). The only way to prevent that is to shoot your original video in a format that is larger than your output...
Another strange effect that might happen, is that the motion blur that is already part of the original image looks completely wrong. In that case you might want to have the stabilization be "less perfect" by playing with the "location influence" values on the '2D Stabilization' tab, to let the image wiggle a bit.
Blender doesn't have a one button solution like the "warp stablize" found on Adobe's "for rent" software.


Blender hair simulation fine in viewport, but half of it won't render

For others having the same problem: I found that it worked to just use the same settings in a different particle system. I'm not sure what actually happened, but I'm just glad that it works!


Camera render button in view layer window is set to "off".


Import-Export:Import images as planes not working Blender 2.8

It is under Images below the objects, putting it there with reference images as well

If you still can't find the option, make sure that the add-on is enabled. Open the preferences window and enable the images as planes add-on.


Can't see any indication in the 3D view , when changing mesh properties from python console

Make sure you aren't in edit mode. If this is part of a larger script (your example looks like Python Console code), the standard practice is to go into object mode, perform your actions, then enter edit mode again, ie.

import bpy

cube = bpy.context.active_object

# store editor state
is_editmode = (cube.mode == 'EDIT')
if is_editmode:
    bpy.ops.object.mode_set(mode='OBJECT', toggle=False)

# make your changes
cube.data.edges[0].bevel_weight = 1

# restore editor state
if is_editmode:
    bpy.ops.object.mode_set(mode='EDIT', toggle=False)


Adding an edge split modifier might help. Set the split angle roundabout 15° or a similar value...
This modifier splits all edges, which form a sharp boundary (which shouldn't look smooth).
Often this also solves some surrounding smooth errors which are caused by smoothed edges which are quite sharp.


Scene color/contrast changes based on camera perspective

I lowered the "Specular" slider for the objects material that has the image using the shading tab. I did this for each object that has an image.


Exported fbx and obj files getting hidden faces in substance painter

It is a mistakes in the normals, is there a chance the legs are scaled in the negative? If yes you should apply the scale and maybe rotation too, then recalculate the normals. If you work in blender 2.8 you can activate blackface culling in the Viewport settings. Or the face normal direction to ease it a bit.


Wrapping a flat object around a cylinder and joining it

There is no direct way I can think of to achieve your goal. However, I think it would work if you set your array modifier to object offset and then select an empty of your choice. By moving and rotating the empty, it should give you more control to find the best position.

I doubt it would work, but the Shrink wrap modifier might also be able to solve your problem. If you want, I'm willing to look at your file and see what I can do.


Why does the water keep escaping in my fluid simulation?

As others have mentioned, it's the resolution that's key here. However, I see that you've baked at two separate resolutions: 120 for final and 45 for preview.

You can see from the render view that the "final" quality bake has less "escaping" water. To preview that in your viewport without rendering, change the "Viewport display" dropdown to "Final." The downside of this is that it may slow down your viewport.

If you want even better quality, you could either:

increase the resolution, or:
Alt-D to linked-duplicate the cup object, then scale it down a tad (maybe 95%) and position it inside the real cup. Turn off the viewport and render visibility. Set its parent to the "real" cup, but mark both as collision targets (Physics → Fluid → Obstacle). This will essentially shrink the bounds of your cup and may or may not completely solve the problem.


Can I use previously rendered frames as texture in Cycles?

The answer to this is basically the same as Is it possible to use the output of a Renderlayer in the material nodes of another RenderLayer?, except you must render the first frame repeatedly until the replicated images of the render are smaller than can be seen (this of course depends on the resolution)

I've thought about this, and as far as I can tell, there is really no true way around it using compositing.

The reason for this is that this is a feedback loop;
The rendered result depends on the lighting, which is affected by the texture of the rendered result, which is affected by the lighting, which is affected by the rendered result, etc.

The only thing you can do is try and make the initial render a reasonably close approximation of how it will look after enough iterations have been done to make it appear infinite (i.e. emitting bright pink doesn't help). This way it will look "good enough" in fewer iterations.

Using the setup in my other answer, rendering a single frame will write a file via file output node which will then be read by an image sequence node in material nodes the next time the scene is rendered. So all you have to do is press F12 repeatedly..

To automate pressing F12, you could render an "animation" where nothing changes for as many frames as you want iterations.


Can't get power button symbol right. Need help cutting letter 'O' and filling gaps

Here is how you can create a power button:

Add a circle.
Enter edit mode.
Selected it(A) and extrude + scale it inwards.
Delete(X->Faces) some of the at the top of the circle as such:

Add a plane into the scene.
scale the plane so that it takes the shape of the line:

Select All(A), and extrude it upwards until your power button is as thick as you want it.
To add rounded edges: select the line, as well as the faces on the inside of the cut. also select the rings(Shift-Alt) that make up the edges of the '0'.
With all those vertices selected hit Ctrl-B. Use the scroll wheel to control the amount of cuts(I'd recommend 4).
Select all and hit W->Shade Smooth.
Rotate it on the Y axis to 90 degrees (RY90) .

Done!


I can't see your baking settings in the video, but this behavior can be caused if your particles aren't baked, or if they are baked to a Disk Cache.
From the Manual:

Only Frames Baked to Memory are Editable!
If you cannot edit the particles, check that you are not baking to a Disk Cache.

To change this, uncheck "Disk Cache" in your cache settings.


For your first question regarding comments, check this out:https://meta.stackexchange.com/questions/214173/why-do-i-need-50-reputation-to-comment-what-can-i-do-instead.

To add the Space control for playing and pausing your animation in the timeline, that can be done by opening the User Preferences and going to the input tab. Find the Timeline and click the little arrow to expand it. Then click Add New to create a new shortcut. Set the control to be Keyboard and set the key to Space, then set the operator to be screen.animation_play. I found the operator by searching for AltA and using the Key Binding search, then copy pasting the operator. Since this is a timeline specific key binding, all other Space shortcuts will still work.


How to create an alias for an object's properties?

You can't rename an object's properties, but you could extend it via its RNA, or add a custom ID.  IIRC, you can then add a driver to the original property, so head.nod ->> head.rx.  See here:

https://wiki.blender.org/index.php/Dev:Py/Scripts/Cookbook/Code_snippets/Properties

That said, if animation channel usability is what you're after (judging by the names of your example) you might be better off just making a bone called 'nod' and then driving whichever axis is going to rotate that head downwards.

Not as extensible as Maya, for sure!


Paint on UV'ed model with external editor

UV unwap the object, enter edit mode, go to the UV editor, click UVs at the bottom and finally click Export UV layout. It will give you an image with a UV template image, which you can paint over and then load back into blender.

Update: Based on your comment, try cutting the object in half using K and deleted one half. Then use the mirror modifier to restore the other side. Then position the viewport in the position you would like the final 2D texture coordinates to be. Now go into edit mode, press U and then unwrap from view. Follow the remainder of my steps from there.


Blender cycles glass from sideview not transparent at all

Your normals are facing the wrong way - press Ctrl-N in edit mode (with everything selected) to recalculate them.

How they were before (wrong):

After recalculating:

The reason the glass looks bad with inverted normals is because glass uses a fresnel function to calculate where the most reflections should be:

(both spheres use exactly the same material)


Bones and mesh relationship is wrong (Bug?)

Your example file shows a mesh that does not match the armature in Edit Mode.

You have the choice of either building your bones inside the mesh - or - modeling your mesh around the position of the bones...

Before parenting your armature to the object it is also good practise to Apply the Scale with CTRL>A as this can also cause complications.


If you made the hole through Boolean operations, you must Apply the modifiers before baking

Boolean not applied (still in the stack):

Boolean applied (no more in the stack):

I don't think it's possible, at the moment, to bring the Boolean modifier above Fluidism, or to Use Modifier Stack in the Fluid Obstacle settings


You have to parent the camera to the player object by pressing Ctrl+P,
then move the camera where you want it by pressing G.


Texture Paint draws somewhere else than where I want

Turn off Symmetry in the toolbar. This option is used when you're texturing stuff like faces or anything that is symmetrical, but if you're going for ones that aren't symmetrical then just turn off symmetry.

Just scroll down to the very bottom and you'll see it there.


The straw in the thatch texture is lying vertical from top to bottom, so we need to try and straighten out the Uv's so that they are aligned (more or less) to this texture.

In the following example the roof has a Mirror modifier acting along both X and Y axis. Also, to avoid unnecessary horizontal seams, the roof is being unwrapped as a single UV island. The roof has already been assigned the thatch texture.
Start by selecting everything and Unwrapping:

In the UV Editor we need to align the edges to the X or Y axis. This is done by selecting a single edge loop, opening the UV Contextual menu with the right mouse button and choosing the appropriate axis to align to:

Once the Uv's are straightened, in the 3D editor check for obvious problems in how the texture is now mapped onto the model:

These problem areas can be alleviated by adding seams and unwrapping a second time. Before Unwrapping remember to Pin the vertices we don't want to be moved. (Pinned vertices are marked in red in the UV editor):

The final part is to scale up the UV island and move the 2D vertices about by hand until you are happy with the mapping. Keep in mind that when UV unwrapping curved surfaces its always a compromise between stretched/squished textures and having lots of seams:


One way to get an effect like this is by using a noise texture to vary the Size input of a blur node. Note that Variable Size must be enabled:

By mixing different sizes and types of noise textures, and perhaps throwing in a bit of displacement, you can control the effect to get any sort of look you want. For example:


Restrict Particle force influence by Area

Use the Falloff on your effector, enter a power value (here 4.3) and limit it's maximum distance to whatever suit your scene.

Also add a drag force, and set it up like in the screenshot, to avoid the cubes flying away after they were pushed (the drag isn't shown in my gif just to be clear).


Is there a way to set the direction of the sun light on an object (without rotations)?

One way to do this is with a Track To constraint:

Select the sun lamp
⇧ Shift select the object you wish to point the lamp at
Press ⎈ CtrlT and choose Track To Constraint.

The sun lamp will now always "look" at that object, so you can move it around with G for easy adjustment.

You can adjust the constraint (or remove it) in the Constraints tab of the Properties area when the sun lamp is active:


Does anyone know why I can't screen cast play mode in BGE?

Here are some possible options:

You use BGEs internal screenshot function, either in python or with logic bricks. Here is a logic brick test setup which quits the game after 120 ticks and makes a screenshot on every frame:

The good thing: You end up with high quality PNGs without compression artifacts. The bad thing: On my laptop (and probably any other non-high end machine), this heavily reduced framerate as I would expect from every software-based screen recorder which tries to compress/dump a massive amount of frames. Edit: The release log of 2.77 says, it already uses another tread. However, my laptop still can't handle Full HD output without losing framerate.
You buy one of these hardware game capture devices, which will capture the HDMI output in a standalone system. Ask amazon for "game capture HDMI". The good thing: It doesn't eat your machines resources. The bad thing: You may have no control about compression. And it is not for free, obviously.
Your graphics card supports hardware accelerated screencapture. Modern NVIDIA cards have shadowplay.
You try one of these broadcasting softwares and stream to another machine, where you record your gameplay. With this solution you outsource the file operations to another machine.
On recent Win10 OS, you can use Win-Key + G and follow the User interface. Microsoft has built a screencapture feature which dumps recordings in the users "videos" folder.

For work, I stuck with solution 2 because my laptop could not handle the others.


No attribute "rotation_euler" on a KX_GameObject?

Details
A KX_GameObject has no attribute called "rotation_euler".
What you request for is KX_GameObject.worldOrientation or KX_GameObject.localOrientation as you mentioned in your question description.
Be aware the orientation is a 3x3 matrix. The setter accepts Euler and a 3-tuple with Euler coordinates for your convenience. It will automatically convert it to a 3x3 matrix.
I'm pretty sure your observation of

[...] it rotated the object to a number which seemed independent of my input.

is not correct.
Answer
You answered your question by yourself: own.worldOrientation = (10, 10, 10).
Remarks:

A rotation matrix does not deal with angles, it is a linear equation system. It is a Cartesian coordinate system. You will never be able to directly read any angles from it. But you can convert the coordinates to a different coordinate system e.g. polar coordinates via mathutils' Matrix.to_euler(order, euler_compat).

Euler coordinates are angles given in rad (not degree). It is a Polar coordinate system.

The value 10rad will automatically reduced to the first period of the radian angle measure system's range (-pi ... +pi) which is -2.5664rad or -147°.

To convert degree to radian you can use the python library math e.g. math.radian


Make a 3D tube with a Bézier curve, bevel not working

the Bevel is working fine just the scale of the curve on X and Y axis is too small (0.05) compared to Z axis scale (1.0)  just fix the scale ( set them all to 1.0 or 0.05) and the bevel effect will be clear


Access only filtered/visible F-curves through python in graph editor

context.selected_editable_fcurves

New to blender 2.79.1 is context.selected_editable_fcurves  Test script.  Prepends a toggle button to graph editor header.  Runs update code on each toggle that will print the visible fcurves to console.

Edited to include all "visible" fcurves in the graph editor.

import bpy
from bpy.props import BoolProperty

def foo(self, context):
    selected = context.selected_editable_fcurves[:]
    bpy.ops.graph.select_all_toggle(invert=True)
    others = context.selected_editable_fcurves[:]
    others.extend(selected)
    others = set(others)
    print("-" * 72)
    print("%d selected of %d visible" % (len(selected), len(others)))
    for fc in others:
        fc.select = fc in selected
        print("action:", fc.id_data.name,
              "data_path:", fc.data_path,
              "{%d}" % fc.array_index,
              fc.select)

    return None

bpy.types.Scene.testfc = BoolProperty(update=foo)

def testfc(self, context):
    scene = context.scene
    self.layout.prop(scene, "testfc", toggle=True)

bpy.types.GRAPH_HT_header.prepend(testfc)

Even before this context attribute became available, the same thing could be done by deselecting all fcurves (using a.fcurves.foreach_set("select", [False] * len(a.fcurves))) in all actions, then selecting all with bpy.ops.graph.select_all_toggle, those selected will be the visible ones,  and reinstating to original selection.


Animate tori around surface of another torus

Because the Curve modifier on a cyclic curve is itself cyclic with respect to the deformed object's location, you can do this with 2 curve modifiers.

Create a curve-sheet made of multiple. straight, subdivided segments (note the orientation):

I created mine by taking the loops out of a subdivided plane, and converting to a curve.

In the next step, we will create a circle to deform this sheet into a tube.To get the measurements right, arrange for the Z-dimension of this curve-sheet to be 2*pi*[the circle's radius] with the scale applied, and then delete the top line.

Create a Curve-circle of the minor radius, which we will use with a Curve modifier to roll the sheet into a tube (again, note the orientation of its local axes)..
..and create a second Curve-circle for the major radius, at right-angles to the first, but with local axes aligned in the same way as the first, as shown:

Assign 2 Curve modifiers, the first to roll the sheet into a tube around the minor circle, and the second to roll the tube into a torus. Both modifiers and their settings are shown here, with only the first active in the view):

..This is with the second modifier active, too:

(You can use either the curve object's native profile to give it thickness, or give it a bevel object)
With these orientations you can get a cyclic animation by keying 2 (linear-interpolation) frames of the sheet's Z location. 0 at frame 1, a whole-number multiple of the Z-gap between the segments on the last frame:

It's probably sensible to parent the whole lot to an empty, so you can move it about without it falling apart.

2.79 version here (which will open in 2.8, too):


For loop splines amplified ! , why? How can I stop it?

I FOUND THE SOLUTION!!!
I resume the problem to be sure to be helpful:
you have a dataframe or 2 list of points , and you need to connect pairs of points. the faster way is to create splines between them but ....
..in my case blender was generating the connection in different position than expected and unexpected lengths ... but not really randomly .
The problem was  bpy.context.scene.cursor.location  that was not in the center of the world origin
The solution is to reset at every loop the position of the cursor in the center of the world origin.


Problem with seamlessly fitting objects together

What's going on is you need to actually separate the geometry before you add those faces.  Bisect just adds an edge loop, it doesn't actually separate the geometry.  So as far as Blender knows, those two pieces are still one surface, and then adding those faces in the middle is creating a kind of geometry that simply doesn't work; this specific problem is called "internal faces."  Internal faces should always be avoided, because 3D modeling software simply isn't built to handle such geometry; for example, creating these weird shading artifacts around the edges of the internal faces.
So, make sure you actually separate the geometry before you add those faces.  You can do this by selecting the bisecting edge loop and pressing Alt-M and choosing "Faces by Edges," or you can select all the faces on one side of the edge loop and press Y.  Both produce the same result.  You can make sure everything really is separated by hovering your cursor over one of the sections and pressing L, which selects all the geometry that is connected to that section.  If it only selects the individual section, you're good to go.  If it selects the whole thing, it still isn't separated.
After you do the separation, you'll have to create those inside faces for each piece.  Once you do this, the smooth shading will inevitably show where the cracks are; you can counter this by toggling on "Auto Smooth", which I show how to find in this screenshot.


How can I create polgyon primitives aligned to the world

After adding the mesh, press T to open up the Tools panel. In the operator menu at the bottom, deselect align to view.


How do I make baked ambient occlusion surfaces appear white instead of gray?

This depends on the diffuse color of your object.
Make sure the color is set to white and the intensity is set to 1 before baking:

Result:


You need to reduce your topology to be able to make the joint. Try to avoid triangles because it can create ugly artefacts. Typically you can use the method above, but it won't work every time. Here a site about topology. Maybe share your file here so that we can test some solutions?


Is it possible to unwrap materials made in Vertex Paint?

You can bake Vertex colors to a texure.

Starting from a vertex color layer as in the picture below

you must unwrap your model (which may consist of one or multiple meshes) and create a new image to bake onto ("untitled" in my case)

Than go in the Bake panel of the Render tab and set Bake mode to Vertex color.

When the process is completed you should see something like the picture above.


Applying weight paint caused my mesh to rotate 90 degrees

I got it to work while typing the question. I guess I just didn't have it selected because in Makehuman the mesh has its origin at the very bottom. So I thought I had it selected when I applied the transform. But yeah, I box selected all the meshes that I needed and the rig and apply all transform.


Are there such things as "root objects"?

If you want to make an object the parent of several objects, select the objects, then, at last, the parent, and press ctrlP (Set Parent To) > Object. You can also create an empty, shiftA (Add) > Empty > Plain Axes, and make it the parent of your object with the same Set Parent To operation. To deparent, select the object and altP > Clear Parent. You can know what's the parent of an object if you select it, go in the Properties panel > Object > Relations > Parent.

Does it answer?


Making a HDRI map more subtle creates a drop shadow

It's because you're blurring the Environment Pass. The Environment Pass is not inclusive of the area behind the building. In other words, there's a black hole where the building is that's being blurred... therefore some of the blue is going to be darker around the edge.

I've been hoping and waiting for the Blender devs to include the capability of making only specific layers transparent.  As far as I know, this doesn't exist yet.

If you want to blur the environment without having a halo and without having to save a separate render to disk and then composite the image to your scene, you can use the "Glass Sphere" trick.

1.) Set Transparent under Render Properties >> Film:

2.) Add a Sphere object (low poly) with Smooth Shading enabled and set the material to be Glass with a IOR of 1.0 and a Color of 1.0 White.  Make it large enough to encompass your Camera and then Parent it to the Camera:

3.) Create two render layers... one for your setting and one for the sphere.  Exclude the Sphere's layer from everything else (this ensures that the sphere itself doesn't affect the lighting on any objects in your scene).  Set the Number of Samples on the Sphere Layer to 1 (it should only take a couple of seconds to render):

4.) After that, blur it as you were with the Environment pass:

EDIT: I forgot... the reason this works is because you now have a shader (albeit a perfectly clear shader) covering the camera plane.  Blender must render the shader and all the rays that are affecting it, hence the environment on the other side of the glass must be visible.  For obvious reasons, a Transparent shader will not work for this.


How to create tentacles moving with the wind?

You can achieve this by using a Soft Body Lattice to automatically deform your mesh and react to the physics. The advantage of this over making the whole mesh a Soft Body is that each tendril can be given its own soft body settings (so some could be stiffer or heavier than others) and also your actual mesh geometry will not affect the simulation (making it simpler and quicker to simulate without having to change the geometry of your mesh).
To start, create a Lattice object and increase 'U' to give it enough detail in that direction. Scale it and position it over your 'tendril'. After re-scaling, ensure you 'Apply Scale' to ensure the simulation is consistent.

If you need to you can reposition each vertex of the lattice in Edit mode so that it evenly surrounds your mesh (in my case I used a straight extrusion for simplicity).
Anchor the 'base' of the lattice by adding a new Vertex Group (we'll call it 'Anchor') and assigning the 'base' vertices to that group.

Similarly, on your mesh, create a new Vertex Group (in my case named 'Tendril') and in Edit mode assign all vertices in the tendril to that group.

Select the lattice, hold Shift and select the mesh, press Ctrl+P and parent the lattice to the mesh so that it follows it.

Select the lattice and add Soft Body physics. In the Goal, set the Anchor as the Vertex Group, increase Stiffness to 0.999 and Default Strength to 1.0. Set the rest of the soft body settings as desired. For me I set the Object Mass as 0.1kg, set the Edge Springs to 0.8 Pull and Push and Bending to 2 and enabled Stiffness.

Select the mesh, add a Lattice deform modifier and set the Target to the lattice, with the Vertex Group set to Tendril.

Now run the simulation and you should have the tendril reacting to the soft body physics.

The mesh should now respond to forces and movement. For multiple tendrils, simply repeat the process - adding more soft body lattices and further groups and modifiers for each tendril.
Blend file included


Alpha in Render Layer Without Combined Pass?

In case the reason behind this is saving time, I was researching the same thing and found "accidentally" a semi-solution. Combined pass still renders, but I assigned a material in the Render Layers, this overrides the objects assigned materials, assigning a simple diffuse shader this way, will make the Combined pass render much faster, specially when you have lots of reflections, refraction and light emitting objects in the scene, and it's a non destructive process, since you simply need to click the X icon next to the assigned material in the Render Layers tab to go back to your original scene materials. I know this is not the perfect solution, but at least it will save render time in most cases.


Can I play a sound effect when I click a button?

There is no facility for this. Of course you can do it, but it would require you to edit Blender's C code and write it yourself.


How to remove unlinked/disconnected parts of a bigger mesh?

One thing I could recommend is to select the large object with the hotkey [L]. If there are several islands (isolated parts of the mesh) that you want in the physics simulation, you can select those too. once you have all of the mesh you want selected, then press control I (invert selection) and delete. That should get rid of any unconnected geometry


How do I make Front Ortho the Active Camera?

Go to the front view by pressing NumPad 1. Then press Ctrl+Alt+NumPad 0 to set the camera to the current view. Then switch the camera from perspective to orthographic.

Unlike with a perspective camera, the local Z location of an orthographic camera is irrelevant. To render more or less of your scene, you must change the orthographic scale.


How can I map an image correctly over my texture?

Since you are using a subsurf modifier you are experiencing interpolation issues over the large polygons on the label.

Add a few cuts on the edges of the label:

Then select the area for the label, unwrap it again and scale and rotate the UVs to get something like this:

Where the UV mapping uses the top and bottom of the image and is twice as wide as the image (since it will use the image for the front and back of the bottle).


How to make trilateral (3-fold) symmetry?

You can use an array modifier to duplicate your object three times, and an empty rotated 120° for the offset.

The empty needs to be in the same place as the object origin for the rotation to be correct.

Now, when you edit one object, the other two will also change.


cutting a hole in cube with subdivision surface modifier already applied

First things first. Boolean is not a good choice in my opinion to receive simple shapes like that.

If I understand you right, you only want a cube which has rounden edges with a rectangular whole in the middle.

This is how I would do it.
First create a simple Cube.

Than subdivide it twice

Delete the inner faces

Now select "Bridge Edge Loop" under the "CTRL +E" Sub Menu

Last but not least, round your edges

Now you can still add a subdivision Modifier to make it even more smooth.

To keep the whole sharp, select all edges and increase the Mean Crease to 1.

Now select the faces you want to be sharp and click Faces -> Sharp under the "Shading"-Tab


As @m.ardito correctly noticed I had disabled rendering for the objects, which is clearly visible in the outliner.


Freely move and rotate tip of bendy bone?

Solved: https://youtu.be/BsJ3Grq_3GM
stretch to constraint and also start and end handle in bendy bones menu


Whats this weird crease in my subsurface mod?

1 year later...
If you have a mirror modifier, make sure it's above the subdivision surface modifier (at least in Blender 2.7).


Can A Deleted Material From A Fractured Object Be Re-applied?

Select one piece and add your second material again.
Then select all of the other parts and select that one part with the second material as the active object (select it as last object). Then press Ctrl+L and click on materials!


Go to properties panel below in out put change from png to MPEG and u will get more options below then go to audio codec change from none to MP3
and then render hope u get the audio and video


Overlay two videos and match/track background

It sounds indeed like a non-trivial solution, that will require you to get proficient with motion tracking and/or compositing.
For a 3D way to do it you would need to track the footage and solve the camera.
The success of the operation would depend entirely on the kind of motion from the cameras, if there is parallax on the scene then you might be able to recreate 3D info. If you track features for which you know the scale in the real world, then use it to set the scale in the 3D reconstruction.
You could then to re-project the image into some geometry, so that you have a reconstruction of the 3d space as fixed points, and a image projected from each of the positions on the camera at a given frame, the UVproject modifier will allow you to use the camera as a projector or you can use a lamp that is parented to the camera to project the image as texture.
You would need to do the same for the other image and manually reposition the camera so that the projected images coincide with those of the other camera.
A non-3D would be to create two un-distorted and stabilized images out of the video. Those new pieces of video can be overlaid using difference mode in a mixRGB node for clarity. One of the videos would need then to be rotated, scaled and possibly distorted so that some the features of the track correspond to those in the other image. Note that the difference in perspective from both images might prevent you from getting a perfect match. You won't be able to invent what the camera did not see.


This isn't really the sort of question that is readily answerable on this forum.

If you have a problem with a specific script that you are working on then we can help but the subject you refer to is overly broad.

In an attempt to provide you with a useful answer, the best way to learn is to look at the source cod eof the add-ons to which you refer.  You will learn far more from that than anybody will be able to provide you with here.

The beauty of open-source is that you are able to both learn from and adpt existing code for your own purpose.  I hope this helps.


Thanks to batFINGER, I found the error. The ray_cast function should be supplied with a point (v1, in my example) and the normalized direction, reached by (v2 - v1).normalized(). Now it is working as expected.


x-mirror in weight paint mode is meant to mirror your actions between mirrored groups.

Let's say you have group four your right and left arm. If you paint the weights in the left arm group, x mirror will do its job on the right arm group.

In order to paint in symmetry inside a single group, you need the purposely named symmetry tool :


Blender explosion animation not rendering

Found out that I just needed to put on a material for my domain. Now there is no box. But when rendering there is no explosion either. 1 frame just renders for like 10 minutes and there is no explosion. Guess I'll have to try to make my explosion from scratch.


Shwinkwrap with evenly spaced face edges

Ok guys, solved my problem.
What follows is a brief tutorial through the steps I used.
Simple example here, but a better possible implementation is decribed at the bottom.

-I started with a sphere I deformed a bit to get it to be irregular
-Went in edit mode and selected a loop ring (Alt+RMB)

-Duplicated the loop ring (Shift+D, Enter). Separated it from the original shape (P), moved it +2 on Z-axis

-I converted the loop ring from Mesh to Curve (Spacebar -> "Convert")
-Created a Plane and scaled it to the size I needed. Applied to it an array modifier and a curve modifier (along the loop ring)

-Applied the modifiers. Merged the two ends (select vertices in Edit Mode, Spacebar -> "Merge". Or Alt+M. At center)
-moved the plane -2 along Z-axis (G Z)

These planes are not "parallel" to the object's surface. I reckon you could repeat the process for two separate edge loops (the closest to the area you want to cover). Create two separate planes, or segments (?) and array them for the same number of times. Merge the "ring" ends you get. Only keep the inner edge loops, delete the rest (if you used planes). Join the two edge loops in one object. Bridge the two edge loops. This way you get trapezoidal planes, which give the right angle to child objects in case you want to dupliface the loop's faces. :)

Ask if you need any other help :)


Skl files have to be unicode or it wouldn't sometimes work correctly.

That's a really vague statement. I'm pretty convinced they are binary files, which may or may not contain some unicode-encoded strings. But you definitely need to open them as binary files:

file = open(filepath, "rb")

You may then decode binary strings:

binary_object.decode("utf-8")

Reading the file in binary mode will prevent decoding errors caused by non-strings (which can be a simple '\x89' of a binary integer.


How to change objects texture using python in BGE?

You don't even need to write python code, you can change the material with level of detail (LOD)

Create different objects (or duplicate the same mesh Shift-D if don't want lower polygon count)

Assign the textures to the objects -
And all to the highest resolution object as LOD objects.
Adjust the distance for where they should be displayed.
Move all but the highest resolution object to an invisble layer.

The effect is visible in the viewport:

A python soultion would be to combine snippets from:

Python - Set material to material slot
How to get the distance between two objects in the game engine?


Access Audio Strips Sample data in Python for a Cross-Correlation

The audio Sample Data doesn't seem to be directly accessible via python.

However, there is a workaround that suits my needs:
I can use Bake Sound to F-Curves which actually results in an already project frame rate based curve. This will add an .animation_data.action.fcurves entry for my Object I added my FCurve to with an attribute sampled_points. These sampled points have lots of FCurveSample entries that include a co Vector. Each is a pair of my frame and the corresponding sound hull curve point. Iterating this Vector I can "extract" a value for each frame which is enough to perform a cross-correlation on:

fcurves = bpy.data.objects['Empty'].animation_data.action.fcurves
samples = []
for value in fcurves[0].sampled_points.values():
    samples.append(value.co.y)

Afterwards I can delete the FCurve again.

When I do this twice, I will get two sample-lists that I can feed into correlation = numpy.correlate(audio, video_strips_audio, 'valid') to perform the cross-correlation. Afterwards I can get the time shift difference between the two sound files by correlation.tolist().index(max(correlation)).

Though this doesn't work directly yet when the second sample-list starts before the first one, but I'm working on this to get it right as well... This depends on the optional mode parameter from the correlate function. I will update this answer when I get this working in general.

Why I do all this: It allows me to automatically shift two Audio files between each other until they match and can be synchronously played back even though they were recorded at the same time but their absolute start time was a bit off. So I can timewise align two or more cameras that recorded simultaneously but weren't started recording thogether. Or a Camera outputted video files audio track and an Audio Recorders Sound file.

The main advantage using this method is, that I don't need to use WAV-files only as with the mentioned add-on, but can rely on any media format including Video files that Blender can already handle via ffmpeg internally as opening a Sound file to bake to an FCurve will be handled the same way any other media/movie file I want to add to the Video Sequence Editors timeline.


Can we add or remove bones to a Metarig with Rigify add-on?

Short answer is yes. The process is a bit more involved if you want to use all the features.

To delete the face, highlight/delete all the face bones, including a bone inside the head called "face". I suggest you hide the head bone,  or "spine 06" in 2.79, box-select, delete and unhide.

For the toes, add them as children of the "Toe" bones. For the extra functionality, you will want to:

Pose Mode > select the root of each toe bone you just created
In the Bone Properties Panel and find Rigify Type (bottom panel) you can choose limbs.simple_tentacle, limbs.super_finger or basic.copy_chain.
In that same panel, choose the layer where you want the Tweak Bones to be. You can look them up in Object Mode under the Data Panel > Rigify Layer Names


Material turns black through Glass material (Internal)

To enable shadows from objects with transparency you need to enable Receive Transparent in Shadow section in material tab.


Why is the cursor not at the expected position?

Answer was simple enough: dimensions of the object have been manually changed, it messed with the scale of the object and Z scale value was a little bit under 1.0. Distances appear to be mesured before taking scale into account.


How can I fill the texture of a leaf like this?

There is a compositing node called Inpaint that does exactly that:

It can be found iin the compositing nodes add menu shift+a in the Filter section:


Smooth part of mesh geometry / subsurf only faces on one side

Actually found it myself

Just set corners of sharp edges to required crease level and they gonna be untouched.
So simply, experimenting gives surprises. Also somehow this time no random lines breaking, clearly new quads symmetrically follows the base shape.


My UVs are not in the same scale when I apply 'Average Island Scale'

It works with Areas

Average Island Scale is (to my kowledge) based on the 3D faces surface area, not it's dimensions. This would make more sense with more complex, irregular figures coming out from the unwrapping of a character, for example.

Take as instance the following example: two faces with the same area (1 square unit) and individual UV island. Running the operator doesn't affect the UV mapping in any way, wether the two figures have different dimension.

If I alter the scale of one of the two islands, and re-run the operator, all the selected faces are being scaled in order to show the correct ratio: they have the same surface in the 3D viewport, so their corresponding islands have the should cover the same area in the UV.

In the example you are providing, everything is going fine in my opinion. The portion with the trapezoidal face has less surface in the 3D viewport, so it should be smaller in the UV map.

If you would to get UV island that shares the same units, the faster way is to unwrap them at the same time (your figure n°3 is probably what you were looking for).


How to make a grainy material in Blender Cycles?

Use a noise texture. You can change the scale and detail. Hooking it up to a Color Ramp (or curve, or gamma or Bright/Contrast) node will allow you to set the contrast

You can set the color directly.

Or use the texture to control the mix of other colors.

Or different shaders.

Or you can use it to combine with other textures and types of noise, as described in this answer: How do I make a Decal look worn?


Rigid body simulation of helical gears/oblique pressure vectors

I don't have the technical knowledge to explain why, but the Bullet physics library seems to like denser meshes.

Subdividing the tooth surfaces 4 times (equivalent to 15 cuts) made these gears work.


UV's not on top of texture in UV Editor - How to repeat texture?

Sure, just go to: Sidebar > View > Repeat Image


I cant give a wave modifier to fluid domain. Help?

The domain is just the area where the water/smoke simulation should be calculated.
You can add another shape (inside the domain) as an effector/collision to manage what you are asking for (for example the wave modifier to move the fluid).
I'm not sure that the wave modifier is the best way to give the water a shake..
check this simulation (I did not used the wave modifier, I just animated the internal cube, the one that is set as effector):


Match the size of multiple background images

Your background images are scaled to different sizes. Scale them consitently to 27.6cm.

Then just place them just changing the x and y values of the backround images.


You can evaluate a Delay Falloff and use a multiple of the output as the z location of the objects as follows:

You may also randomize the order using the Offsets input.


Can't see live changes in edit mode on character

The shape keys were pined I found this in my search: Unable to edit the meshes for shape keys

It now works.


Difference between Add Shader and Mix Shader?

Add Shaders aren't necessarily physically correct. Simply put the values of the two input shaders are added up for every pixel

value_out = value_1 + value_2

It is possible to reflect more light than received.

If you mix two shaders with the Mix Shader Node you get more physically correct values because it calculates a weighted (by the Fac param) average

value_out = value_1 * Fac + value_2 * (1 - Fac)

This way you reflect at most as much light as you receive provided both inputs are physically correct.

When in doubt use the Mix Shader.


How to make this thorny decimated effect?

Using a child object for hair particle system can give something close to what we want.

To do it, I started from a free model downloaded, then:

Added a particle system (the parameters are visible in the image) with an object as render element (a small pyramid)
Convert the particles to mesh using the convert button in the modifiers panel
Here you get individual instances of the initial pyramid. You need to select them all and use the menu "object/relation/make single user" to make independent instances of this pyramid
Once done, select and merge them all using AltJ
I've also added a material, and a rapidly done texture on it.

Variations can be obtained with different ways:

The amount of particles
Scale and scale randomness in the particle system setting
Scale of the particle object and its shape, of course
Add a second particle system with another shape as render object
...

Once the final mesh obtained, you can:

Resize individual pyramids inside the mesh (scale using 'individual origin' as pivot point)
Give a try at "merge by distance" (with a relatively big distance), which allow to link several pyramid parts

I also think that the material and textures on it are important for the final effect. Here the texture is roughly done but you may pay attention to this point if you want to go further.
The blend file below contains several attempts, so you can play with it.


Getting the location of rigid body object at current keyframe

Use:

import bpy

obj = bpy.data.objects["Cube"]
print(obj.matrix_world.translation)

This gives you the location from object's matrix which changes each frame for rigid bodies


Cloth collision with rigid body stuck at starting point

At the physics tab add a cloth physics and scroll down a bit, you should see the Collisions title. Open it up by clicking on it then enable the self collisions.


Deactivating AA and MipMap + Interpolation is the right thing to do. The filters are used with interpolation. The bigger the filter size the smoother the result becomes. But since you don't want any smoothness you should deactivate interpolation. That way you can forget about filters.

Nevertheless Blender seems to sample textures internally with some interpolation.

As a workaround you could use an image manipulation program like GIMP or Photoshop and reduce the colors there. In GIMP you can do it like this: Image > Mode > Indexed.

To automate this task for multiple images you can use BIMP. It is GIMP plugin which is probably already installed. You can find it in File > Batch Image Manipulation...
You can use the filter called "gimp-image-convert-indexed"


Well i forgot to post the answer i found : the 'strange behaviour' was in cases i had no objects selected actually, that is why the exporter was not available. I dont know if this condition existed in the previous exporter too, maybe that was what lead me to ask.


Make an object disappear by moving through a mesh

You could use a Boolean modifier:

Create a cube. It will be the object that will make your car disappear.
In the Properties panel > Object > Display, choose Maximum Draw Type > Wire. In the Properties panel > Object > Cycles Settings > Ray Visibility, disable everything. Your cube is now transparent in both Object and Render mode.
Select your car, give it a Boolean modifier, choose Operation > Difference, and choose the cube as the Object.
Now when you move your car, the part that touches the cube becomes invisible.


How to achieve this spline and particle effect

Animation Nodes Version

Animation Nodes v2.1 includes a very fast and efficient noise functions and so I will be using this version in my answer. However, I also provided an alternative using older versions of Animation Nodes, though it is not as efficient as I stated above.

The Theory

The image you posted above is a trace visualization for what is known as a divergence free vector field. To demonstrate what that mean, consider particles that move along the lines you see above (The field represents their velocity), if the field is indeed divergence free, those particles will never collide. That's what gives this visualizations their beauty, the lines never intersects.

Mathematically, a vector field $F$ is divergence free if $\nabla \cdot F = 0$. In the the paper "Curl-Noise for Procedural Fluid Flow", Robert Bridson described a method to generate those divergence free vector field from simple Perlin noise. He proposed computing the curl of a vector field composed of Perlin noise to get a divergence free vector field, it is a known identity that the curl of any field is automatically divergence free. In particular, he proposed an equation to compute the "2D curl" of simple perlin scalar fields which is exactly what we want to get the visualization above. The equation he proposed is:

$$
\vec{v}(x, y) = \left( \frac{\partial \Psi}{\partial y}, -\frac{\partial \Psi}{\partial x} \right)
$$

Where Psi is the perlin noise field. Don't worry if you don't understand the equation, I will walk you through it. It can be noted that the computed vector is just the gradient rotated by 90 degrees.

Now that we know how to compute the the vector field, we can generate the splines by tracing the vector field using what is known as Euler's Integration, if you don't understand this method, don't worry, you will get it through our implementation.

Implementation

To compute the partial derivatives in the equation above, we are going to use what is known as the Central finite Difference method. I will leave you to study that for study and practice and I will just do the implementation directly:

We just take the input vector, move it a bit to the right and a bit to the left, evaluate the noise at the new location then take the difference. Same for the $y$ axis. When we make the amplitude the reciprocal of the epsilon (the bit we moved the vector by), we won't have to divide by it.

Next we will make a loop that computes the points of the splines using Euler's method:

We start at some vector, compute the curl using the equation above by using the group we did above. Then we move in the direction of that curl and reassign the initial location to be the new location.

Next we will make a loop that generates the splines for multiple points:

And by viewing the output splines:

We get something similar to what you want to achieve. Now by adding the value of the perlin noise as the z location of the spline points, we get exactly the result you are looking for:

It should be noted that there is much more efficient way to make this, but this is the easiest way, if you want to know the other way, let me know.

This should be it for splines. I think particles are not hard to create and you should create them as a practice. Let me know if you need elaboration or help on any part.

Edit 1

Using Older Versions Of Animation Nodes:

The only node that is not available in older version is the Vector Noise node. The mathutils python module provide an alternative, but it is much slower and doesn't give a lot of control, and that's why I didn't want to use it.

All you have to do is replace the Vector Noise node with an expression node that takes a vector list and returns a float list with an expression:

[mathutils.noise.noise(x) for x in vectors]

Making sure you have imported mathutils and named the vector list vectors:

There are also other types of noise that you can experiment with, you can find the API here.

Deform It Along A Grid

Notice that in the Splines loop, we set the z location to be the value of the noise. Instead, you can just set it to anything else. In your case, if you want to deform it along a grid, you can use a BVH tree:

And yes, this works with lattice deformed grids as you may see in my example above.

Edit 2

What To Put At A

The hidden nodes are Get List Element Nodes with indices, 0,1,2,3 from top to bottom.

How To Add A Generator

In the Loop Input node at the far left, there is a plus button called new Generator Output, search for vectors after pressing it.

File for v2.0 to study

Edit 3

To assign different colors to each spline, you should separate splines to different objects (This is your best option), this can be done using such node tree:

Then assign the material to all the generated splines by adding it to a single one, selecting all and then Ctrl+L >> material. For this material, we will use such a node tree:

Which will assign a random color to each spline.


This technique is not a physics based simulation, it is just a fake approximation but might yield what you are after.

Just add a single faced small planar object above your "wave surface" object.

Add a Shrink Wrap modifier to it and set it to Project mode. Make sure you tick the Negative option if necessary.

This will make your object stick to the waving surface. Now just parent whatever object your want to this plane and use Duplifaces from the Properties Window > Object Tab > Duplication > Faces to duplicate it at the face center.


Can I select every object in the scene that is touching the active object?

An addon to do that:

For 2.79:

It uses a BVH tree to check if meshes are overlapping. BVH trees are built from boundings at first step (presuming boundings are a box) then with bmesh (for the intersecting bounding objects).

Important though: the overlapping test will fail if meshes do not intersect. For instance a mesh which is entirely inside the active one will not be detected.

For information: using bmesh.transform to obtain object's coordinates in world is mush faster than a Python calculation.

bl_info = {
    "name": "Select intersect active",
    "category": "Object",
}

import bpy
from mathutils import Vector
from mathutils.bvhtree import BVHTree
import bmesh
import time

#In this context, utility/debug function to check if bounding test are ok
def BoundingsToMesh( obj, scene ):
    name = obj.name + "_bounds"
    meshData = bpy.data.meshes.new( name )
    meshObj = bpy.data.objects.new( name, meshData )
    meshObj.matrix_world = obj.matrix_world.copy()

    meshObj.data.from_pydata( *BoundingsGeometry( obj ) )

    scene.objects.link( meshObj )

    return meshObj

#Create bounding geometry from an object
def BoundingsGeometry( obj ):
    verts = [Vector(co) for co in obj.bound_box]
    edges = []
    faces = [ (0,1,2,3), (4,5,1,0), (7,6,5,4), (3,2,6,7), (6,2,1,5), (7,4,0,3) ]
    return verts, edges, faces

#Translates bounding geometry in world coordinates
def BoundingsGeometryInWorld( obj ):
    verts, edges, faces = BoundingsGeometry( obj )
    return [obj.matrix_world * v for v in verts], edges, faces

#Get vertices and polygons from an object in world coordinates
def MeshGeometryInWorld( obj ):
    return [obj.matrix_world * v.co for v in obj.data.vertices], [], [p.vertices for p in obj.data.polygons]

#Create a BVH tree from bounding (world co)
def BVHFromBoundings( obj ):
    verts, edges, faces = BoundingsGeometryInWorld( obj )
    return BVHTree.FromPolygons( verts, faces )

#Create a BVH tree from mesh (world co)
def BVHFromMesh( obj ):
    verts, edges, faces = MeshGeometryInWorld( obj )
    return BVHTree.FromPolygons( verts, faces )

#Create a BVH tree from bmesh (world co)
def BVHFromBMesh( obj ):
    bm = bmesh.new()
    bm.from_mesh( obj.data )
    bm.transform( obj.matrix_world )
    result = BVHTree.FromBMesh( bm )
    del bm
    return result

#Test if a bvh tree overlap an object
def IntersectBVHObj( bvh, obj, toBvh ):
    objBvh = toBvh( obj )
    result = bvh.overlap( objBvh )
    del objBvh
    return result

#Test if two objects overlap
def IntersectObjObj( obj, others, toBvh ):
    objBvh = toBvh( obj )
    result = [other for other in others if IntersectBVHObj( objBvh, other, toBvh )]
    del objBvh
    return result

#Test if two objects overlap using boundings method
def IntersectBoundings( obj, others ):
    return IntersectObjObj( obj, others, BVHFromBoundings )

#Test if two objects overlap using mesh method
def IntersectMesh( obj, others ):
    return IntersectObjObj( obj, others, BVHFromMesh )

#Test if two objects overlap using bmesh method
def IntersectBMesh( obj, others ):
    return IntersectObjObj( obj, others, BVHFromBMesh )

#Select objects which overlap another one
def SelectIntersect( obj, scene, others, intersectBounding ):
    result = IntersectBoundings( obj, others )

    if intersectBounding == False:
        #startTime = time.time()
        #for i in range( 1000 ):
            result = IntersectBMesh( obj, result )
        #print( "elapsed", time.time() - startTime )

    for o in result:
        o.select = True

class SelectIntersectActive(bpy.types.Operator):
    bl_idname = "object.select_intersect_active"
    bl_label = "Select intersect active"
    bl_options = {'REGISTER', 'UNDO'}

    intersectBounding = bpy.props.BoolProperty(name="Intersect bounding", default=False)

    @classmethod
    def poll(cls, context):
        scene = context.scene
        obj = scene.objects.active
        return obj and obj.type == 'MESH' and obj.mode == 'OBJECT'

    def execute(self, context):
        scene = context.scene
        obj = scene.objects.active

        #Keep only non selected objects (cumulative selection)
        SelectIntersect( obj, scene, [o for o in scene.objects if o.select == False and o != obj], self.intersectBounding )

        return {'FINISHED'}

def menu_func(self, context):
    self.layout.operator(SelectIntersectActive.bl_idname)

def register():
    bpy.utils.register_class(SelectIntersectActive)
    bpy.types.VIEW3D_MT_select_object.append(menu_func)

def unregister():
    bpy.utils.unregister_class(ObjectCursorArray)
    bpy.types.VIEW3D_MT_select_object.remove(menu_func)

if __name__ == "__main__":
    register()

Update for 2.8:

bl_info = {
    "name": "Select intersect active",
    "category": "Object",
}

import bpy
from mathutils import Vector
from mathutils.bvhtree import BVHTree
import bmesh
import time

#In this context, utility/debug function to check if bounding test are ok
def BoundingsToMesh( obj, scene ):
    name = obj.name + "_bounds"
    meshData = bpy.data.meshes.new( name )
    meshObj = bpy.data.objects.new( name, meshData )
    meshObj.matrix_world = obj.matrix_world.copy()

    meshObj.data.from_pydata( *BoundingsGeometry( obj ) )

    scene.objects.link( meshObj )

    return meshObj

#Create bounding geometry from an object
def BoundingsGeometry( obj ):
    verts = [Vector(co) for co in obj.bound_box]
    edges = []
    faces = [ (0,1,2,3), (4,5,1,0), (7,6,5,4), (3,2,6,7), (6,2,1,5), (7,4,0,3) ]
    return verts, edges, faces

#Translates bounding geometry in world coordinates
def BoundingsGeometryInWorld( obj ):
    verts, edges, faces = BoundingsGeometry( obj )
    return [obj.matrix_world @ v for v in verts], edges, faces

#Get vertices and polygons from an object in world coordinates
def MeshGeometryInWorld( obj ):
    return [obj.matrix_world @ v.co for v in obj.data.vertices], [], [p.vertices for p in obj.data.polygons]

#Create a BVH tree from bounding (world co)
def BVHFromBoundings( obj ):
    verts, edges, faces = BoundingsGeometryInWorld( obj )
    return BVHTree.FromPolygons( verts, faces )

#Create a BVH tree from mesh (world co)
def BVHFromMesh( obj ):
    verts, edges, faces = MeshGeometryInWorld( obj )
    return BVHTree.FromPolygons( verts, faces )

#Create a BVH tree from bmesh (world co)
def BVHFromBMesh( obj ):
    bm = bmesh.new()
    bm.from_mesh( obj.data )
    bm.transform( obj.matrix_world )
    result = BVHTree.FromBMesh( bm )
    del bm
    return result

#Test if a bvh tree overlap an object
def IntersectBVHObj( bvh, obj, toBvh ):
    objBvh = toBvh( obj )
    result = bvh.overlap( objBvh )
    del objBvh
    return result

#Test if two objects overlap
def IntersectObjObj( obj, others, toBvh ):
    objBvh = toBvh( obj )
    result = [other for other in others if IntersectBVHObj( objBvh, other, toBvh )]
    del objBvh
    return result

#Test if two objects overlap using boundings method
def IntersectBoundings( obj, others ):
    return IntersectObjObj( obj, others, BVHFromBoundings )

#Test if two objects overlap using mesh method
def IntersectMesh( obj, others ):
    return IntersectObjObj( obj, others, BVHFromMesh )

#Test if two objects overlap using bmesh method
def IntersectBMesh( obj, others ):
    return IntersectObjObj( obj, others, BVHFromBMesh )

#Select objects which overlap another one
def SelectIntersect( obj, scene, others, intersectBounding ):
    result = IntersectBoundings( obj, others )

    if intersectBounding == False:
        #startTime = time.time()
        #for i in range( 1000 ):
            result = IntersectBMesh( obj, result )
        #print( "elapsed", time.time() - startTime )

    for o in result:
        o.select_set( True )

class SelectIntersectActive(bpy.types.Operator):
    bl_idname = "object.select_intersect_active"
    bl_label = "Select intersect active"
    bl_options = {'REGISTER', 'UNDO'}

    intersectBounding = bpy.props.BoolProperty(name="Intersect bounding", default=False)

    @classmethod
    def poll(cls, context):
        scene = context.scene
        obj = context.active_object
        return obj and obj.type == 'MESH' and obj.mode == 'OBJECT'

    def execute(self, context):
        scene = context.scene
        obj = context.active_object

        #Keep only non selected objects (cumulative selection)
        SelectIntersect( obj, scene, [o for o in scene.objects if o.select_get() == False and o != obj], self.intersectBounding )

        return {'FINISHED'}

def menu_func(self, context):
    self.layout.operator(SelectIntersectActive.bl_idname)

def register():
    bpy.utils.register_class(SelectIntersectActive)
    bpy.types.VIEW3D_MT_select_object.append(menu_func)

def unregister():
    bpy.utils.unregister_class(ObjectCursorArray)
    bpy.types.VIEW3D_MT_select_object.remove(menu_func)

if __name__ == "__main__":
    register()


Creating a polygon plane with different sections / components

I suppose you want the extrude part to be strict squares. Here are some ways to do it (among others):

1)

Create a plane and create an edge loop in its middle with a ctrl R.
Scale your plane on the same axis, for example 3 times (S Y 3).
ctrl Rand + to create as many edge loops as necessary on the orthogonal axis.

2)

Create a plane and Subdivide it for example 5 times (use the parameters on the bottom of the left menu).
Delete a part of the plane so that you have the length you want.

3)

Create a plane, subdivide it, enable the Snap option and its options.
Duplicate the first subdivided plane as many time as you want, the Snap option allows you to stick to the previous copy and to merge the vertices.

4)

Subdivide a plane
Add an Array modifier and choose the Count you want
Apply the modifier in Object mode


How to wrap cylindrical object around 2 posts

Try the ShrinkWarp modifier (add more geometry), or try making a simulation.

Try going into wireframe and by pressing the view keys (1, 3, 7,Ctrl + 1, Ctrl + 3, 9) getting your vertices right.


Is it possible to "dissolve" a driver and commit its effects on an animated armature?

Figured it out, with the help of Rich Sedman.

What I'm doing now is establishing a complete animation in Blender, with the use of drivers and empties. Blender drivers are python-dependent, so of course they don't export; but by doing the following I can make the FBX animation-ready.

Bake the movement of the empty. (This option is in the 3D view, under Object->Animation->Bake Action)
Bake the animation of the target mesh in the same way.
Open up the graph view, go to Drivers and then the driver pane on the right, and remove the driver. It's no longer necessary.
Delete the empty that was in use. I suggest this because otherwise, the animation applying to the empty will still export; and FBX doesn't do much for identifying which meshes are associated with which animations. Tools like Unreal and Unity will get confused, and most likely apply it to the end mesh.
Export the animation as an FBX file, and it should be ready to use.


Need to make (node setup) of realistic dirt/ grime/grunge on top of image texture of ceramic tiles

Adding convincing dirt and grunge to any model requires multiple layers of shaders.  I usually use three main layers, surface dirt, crevice dirt, and dust.

Surface Dirt:

Surface dirt is just smudges and such that accumulates across the surface of an object.  To create this just mix your normal shader for your material with a dirty shader using a grunge texture for the mix factor.

Note:  Make sure the image texture you are using for a mask is set to non-color data.

Crevice grunge:

Usually grunge doesn't accumulate evenly over an entire object, it likes to get caught and pile up in corners and crevices where it isn't easily brushed or blown away.  To simulate this in Blender I will be using the brand-new pointiness input from the input > geometry node (so make sure you are using Blender 2.74 or later).  You usually have to tweak it's output with a color ramp to get some better contrast, then just add it to the grunge mask you are already using.

Dust:

Dust usually doesn't stick to an object very much, it just settles on the top.  To get this effect I plug the normal output of a geometry node into a Seperate XYZ node, the Z output of this node will give how much the face is pointing upwards.  Just use this output, multiplied by another grunge texture, as a mix factor for the dust shader.

Here's the final result:


How can I smoothly "blend" between 2 STLs?

You should be able to merge them with Booleans, be that the BoolTools addon or modifier. Take a look!