Force triangles only (or warn user) before exporting with built in blender functions

this script triangulates a model.  If you are in Edit mode it will switch to Object mode before triangulation takes place.  If you add bpy.ops.object.mode_set(mode='EDIT') at the end of the script then it will return to Edit mode when completed.

import bpy
import bmesh

if bpy.context.selected_objects:
    for obj in bpy.context.selected_objects:
        bpy.context.scene.objects.active = obj
        bpy.ops.object.mode_set(mode='OBJECT')

        obj = bpy.context.object
        me = obj.data

        bm = bmesh.new()
        bm.from_mesh(me)
        bmesh.ops.triangulate(bm, faces=bm.faces)

        bm.to_mesh(me)
        bm.free()
        del bm


How do I prevent Blender adding an index-suffix to the objects' names?

When you delete an object, not all information about it will be deleted. Its mesh data will remain in the file. So if you want to delete the mesh data, open Outliner in Orphan data mode and click on Purge All - it will delete all mesh data that are not used in the scene, and free names.

Normally, object and mesh data can use different names, but the obj-import script makes these names the same. That's the reason why a new object gets the  old name, but obj-import gets a new one.


How to delete bezier points from curve splines with low-level code

Surely there's an easier way to do this.

Had a fiddle with this and came up with code below,  which I'm not sure wins on either count of speed nor cleanliness.  Adds a new spline with the same coordinates, and handles as bezier points of spline zero in original, with one point popped off.  Even with all that code didn't copy handle type for left and right.

import bpy

context = bpy.context
obj = context.object
curve = obj.data
s0 = curve.splines[0]
index = 0 # index of bez point to remove.
points = len(s0.bezier_points)
x = [0] * points * 3 # flat list of vectors
hr = x[:]
hl = x[:]
s0.bezier_points.foreach_get("co", x)
s0.bezier_points.foreach_get("handle_left", hl)
s0.bezier_points.foreach_get("handle_right", hr)
# pop off index 0
for i in range(3):
    j = 3 * index + i
    x.pop(j)
    hl.pop(j)
    hr.pop(j)

# one less for removed, one more less for splines new
points -= 2

# add a new spline
spline = curve.splines.new('BEZIER')

spline.bezier_points.add(points)
spline.bezier_points.foreach_set("co", x)
spline.bezier_points.foreach_set("handle_left", hl)
spline.bezier_points.foreach_set("handle_right", hr)

#remove spline 0
curve.splines.remove(s0)


Altering size of emission object without messing up brightness of light in scene

Set the emission using a driver

See this answer for the basics of setting up a driver.

Result


Browse for an Image and assign it as a texture in python?

You could use a callback to detect changes to the filepath field:

def update_texture(self, context):
    print("New image:", self.MyPath)

bpy.types.Scene.MyPath = StringProperty(name="Browse Image:",
   attr="custompath",# this a variable that will set or get from the scene
   description="simple file path",
   maxlen= 1024,
   subtype='FILE_PATH',
   default= "",
   update=update_texture) # callback

In that callback, you would texture the mesh. It really depends on your situation how to go from here, since there could be UV mapping or Cycles textures.

In case of a mesh with UV mapping, note the difference between

bpy.context.object.data.polygons[#].material_index, which tells you the # of the material (ob.data.materials[#])
and the image assigned to a face for UV mapping (ob.data.uv_textures.active.data[poly#].image).

You may wanna add a new material to the mesh object:
ob.data.materials.append(mat), which you need to create beforehand: mat = bpy.data.materials.new(...)

Or use an existing material?

Active material slot's material: ob.active_material

First slot's material (if there is one):

try:
    slot1 = ob.material_slots[0]
except KeyError:
    return
mat = slot1.material
if mat is not None:
    # there is a mat in first slow and it has a material

You can load your image from filepath as image datablock and assign it for UV mapped meshes to uv_textures...image, or figure out the index and assign to Polygon.material_index (or both).

Find the index e.g. like:

def material_index(me, material):
    for i, mat in enumerate(me.materials):
        if mat == material:
            return i
    else:
        return None # or -1 or 0??

You may wanna look at the code of the Material Utils addon, which transfers material assignments from Polygon.material_index to UV editor (uv_textures...image) or the other way around.


Why would I use the "Film Emulation" feature?

The key advantage is that it works real-time in the view-port.
Of course all color manipulation could be done once the file is saved.

However having this apply to previews while you're setting up your scene means you can setup a a rough grade, and then build the lighting off of that. This allows you to get a really good idea of where you need more detail in the render, and also gives you a more accurate representation of how your lighting will look once everything is color graded.

The look settings can also help give a rough grade without much work. There's also the plus that they're based off of real life film types.

There's also a log setting. According to the manual, this is intended more as a way to trouble shoot the image, but it can also be used to get a nice flat image for use when grading.


Save the transformation of Boolean Modifier Difference

Modifiers are what is called non-destructive modifications, they are meant for users to be able to do further editing before committing to a final irreversible transformation.

The idea is that you don't apply a modifier until you need to (if at all). It is not uncommon to never apply the modifiers. That way you can experiment or refine the settings, or further combine it with other modifiers, or change the order in which the modifiers act, without effecting the original object.

If you need to make the modification permanent then Apply the modifier. The transformations will now be part of the object and the modifier will disappear.


Cylindrical UV unwrapping should do the job as the model resembles a cylinder and the topology is quads.  Unwrapped cylindrically, they are rectangles.


How do I use the compositor to output colour based on the depth of objects?

and another, more tunable.

the Z-buffer isn't really an image but a grid of distance values mapped from camera clipping start, and end (these settings are found in the Camera Object properties tab).

Use the limits tickbox to visualize the clipping start and clipping end range, (also called near and far clipping planes). Generally keep all your geometry in that range and you will be using the Z-Buffer like a boss.

PS: instead of the Map Range node, you can use the Normalize node and you won't have to set the range values, it will find the lowest/highest values in the Z-buffer and map them to 0...1 range


What's apparent in your image is deformation that differs between the talon and the toe.  The reason for this is that the margin of the talon has different weights than the margin of the toe.  If the vertices have the same weights, they will move together.
This is probably due to using automatic weights on a mesh with non-manifold boundaries-- ie, multiple separated meshes.  Autoweights are not a great way to weight these kinds of meshes.  You can merge the seams and then re-weight, or you can weight by hand, or you can create a manifold "cage" mesh, autoweight that, and then copy weights from it to your non-manifold meshes.
If your problem is that the rig isn't in its rest pose even when all bones have no transforms-- that as soon as you weight a model, it moves at all, even correctly-- then the issue is due to constraints or drivers that you've put on bones in your rig that cause them to transform, even when the bones haven't been transformed in pose mode.


The .obj format specification doesn't contain any description of vertex color attributes. Some software like MeshLab or Agisoft Metashape extend the .obj format and include the vertex colors after the coordinates.

v 3.112696 -9.640543 15.350909 0.592157 0.517647 0.537255

Since it is not covered by the specification, Blender provides no ability to import vertex colors. There are other formats that do allow to store vertex color which can be imported into Blender, for example .ply.


Envelope distance can be set in the properties panel, selecting bone options in pose mode. If you select more than one bone, you can enter a new distance value and  keep pressed Alt key before using Enter to validate the new value, so to assign the new value to all selected bones.
Anyway using bone envelope is just one of the binding methods, the most common is using vertex weights, with automatic weights and/or weight painting and/or direct weight assignements.


Procedural textures not showing in Material view

Unfortunately, as far as I know, this is not possible at the moment.

I do find myself quite often wishing this was possible, but I am afraid it is not.  the closest thing is, as Bithur said in the comments, you can use Shift+Z to activate rendered viewport mode.

I have heard that the devs are working on adding this support, I have no idea when it is projected to come out though.


Is there a way to do mirror Image mapping in EEVEE?

It's possible to calculate mirroring UV coordinates by creating a sawtooth shaped graph.

Here is it implemented with nodes for cycles and EEVEE.
Since modulus is behaving in a different way below zero, the Fract operation is a better choice, but then we also need to scale the value to the 0 - 1 range.


Why does my light source not pass through my glass?

Here, try this setup. The active factor is the "Is Camera Ray" output of a Light Path node, used as a mix factor between the glass shader setup and a Transparent BSDF. I made the glass "double-paned" in my image so you can see the light go through both layers before hitting the back wall. I also included both a Spotlight and a point light to show both their lights and shadows going through. Lastly, as is usual for a transparent setup, make sure your blend modes are correct. See below:


Temporarily disable add-on UI property update callback

Only trigger the update when it makes sense, when the value will be changed. Otherwise then don't set the value to the counterpart.

sizex = FloatProperty(name='Size X', description='Size of plane along X',
                      default=10.0, update=update_sizex)

sizey = FloatProperty(name='Size Y', description='Size of plane along Y',
                      default=10.0, update=update_sizey)

def update_sizex(self, context):
    if self.lockSize and self.sizey != self.sizex:
        self.sizey = self.sizex

def update_sizey(self, context):
    if self.lockSize and self.sizex != self.sizey:
        self.sizex = self.sizey

You can also use a temporary property for this. But in my opinion that makes things too complex. Also be aware that the setting can be set incorrectly making the lockSize functionality not working.

from the outside the do_not_update setting can be altered making the whole lockSize button broken.
when an exception happens during updating.

This can be fixed by a using finaly

try:
    self.do_not_update=True
    self.sizex = self.sizey

finally:
    self.do_not_update=False


How to model those stylized trunks (See image)

I think the best way to achieve trees with branches is to make use of the Skin Modifier.
Begin by enabling a couple of add-ons ("Extra Objects"), if they're not already enabled.

This will give you the ability to add a single vert from the mesh menu.

Add a vertex, and give it a Skin Modifier.

You can extrude points by selecting them and then Ctrl + Right Click somewhere else (where you want to extrude it to). You can then scale the individual points using Ctrl + A.

You can also reselect individual points and extrude them elsewhere to make multiple "branches"

Once you have the tree shape you like, you can add a Subdivision Surface Modifier to make it smooth and round.

The best thing about this method, I find, is that it makes proper "knuckles" where the different branches connect to each other.


Create a Collection inside another Collection with python

Each collection has a children (collection) property. Easy to figure out using the python console:

>>> C.scene.collection.
                       all_objects
                       animation_data_clear(
                       animation_data_create(
                       as_pointer(
                       bl_rna
                       bl_rna_get_subclass(
                       bl_rna_get_subclass_py(
                       children
                       ...

To get the first level of all sub-collections, you can just iterate through the list:

>>> for coll in C.scene.collection.children:
...     print (coll.name)
...
Collection
Collection 2
Collection 3
...

To add a new collection, create a new data-block and then use .link(collection) method to add it to whatever your main collection is:

>>> C.scene.collection.children.link(
link()
CollectionChildren.link(child)
Add this collection as child of this collection

>>> my_sub_coll = bpy.data.collections.new("My Sub Collection")
>>> C.scene.collection.children.link(my_sub_coll)

The same principle applies to all collections, no matter the collection is on the first or any other level. Example on how to add a new (sub) collection to the active collection:

>>> active_coll = C.view_layer.active_layer_collection.collection
>>> active_coll.children.link(my_sub_coll)

You can also specify the each collection by its name C.scene.collection.children["Collection"] or you can even use the index operator C.scene.collection.children[0] but that's error prone. In case the name of the collection or the scene hierarchy changes you're lost. Better practice is using pythons get() method to basically perform a search for the collection in the first place:

>>> C.scene.collection.children.get("Collection")
bpy.data.collections['Collection']

Basic example using .get():

import bpy

C = bpy.context

main_coll = C.scene.collection.children.get("Collection")
if main_coll:
    # Create the new collection
    my_sub_coll = bpy.data.collections.new("My Sub Collection")
    # Add it to the found collection
    main_coll.children.link(my_sub_coll)

Advanced example on how to add a new collection to an arbitrary collection in the scene using a recursive loop based on https://blender.stackexchange.com/a/137866:

import bpy

def traverse_tree(t):
    yield t
    for child in t.children:
        yield from traverse_tree(child)

coll = bpy.context.scene.collection

for c in traverse_tree(coll):
    if c.name == "MyCollection": # Specify the name of you main collection here
        my_sub_coll = bpy.data.collections.new("My Sub Collection")
        # Add it to the main collection
        c.children.link(my_sub_coll)

Notice that you add objects to the collection(s) the same way by just passing an object  when calling the .link(object) method on the actual object (collection) property, which is actually pretty nice and convenient:

>>> my_sub_coll.objects.link(C.object)


Rigid object behaving differently in Object and Edit mode?

I have just solved the problem!

I exported the object from my Blender file as an .obj file and imported it back. Now it behaves perfectly with physics and other stuff!


Is this a possible bug in Blender 2.78a?

I don't have enough reputation to comment, so I'll post this here...

Undo seems to work fine for me.

Workflow:

New scene with standard cube
Press Ctrl-2, then Ctrl-0, then Ctrl-3 and watch how the cube changes
Pressing Ctrl-Z repeatedly goes through the stages of 3 subdivisions, then 0 (which is the cube again), then 2 subdivisions.

You may want to post a .blend file if your problem persists, or at least describe which kind of geometry you are having a problem with.


I've tested tens of scenes using BPT and regular PT and so far there are no major cons at all when using BPT.
Some somewhat minor issues would be, knowing how to tweak the settings manually and slower viewport refresh during the first few samples (samples in BPT are slower)...

Other than that the its easier to test your models using regular PT and at the end of your scene switch to BPT when you know all the details of the shaders you are using...

As far as CPU vs GPU it seems to work the same, meaning it always beats regular PT, at least in all my tests, probably older (2015-2016) versions of Blender had no advantage using CPU, but as far as newer versions (2.78 and up) it is the better.


Moving a movie strip into next free channel

You can aways use the "G" shortcut to grab along the Y axis in most editors, including VSE.

Just press G and then Y.


Why can only one texture display correctly on my model?

From what I can tell from looking from your file, the only affected area is the hair (now that I look again, maybe the eyes too), which seems to lack a UV map. I selected the section and did a crude "sphere projection" unwrap and was able to get a texture on it.

The problem is, that when I connect the texture that came with it, it's not clear how it's supposed to be oriented. I tried several different unwrap methods, as well as different placements in the UV space, but I couldn't get it to line up in anywhere close to a satisfying fashion. Maybe you will have better luck than I.


Using the knife tool on a plane (mesh) makes the cut incorrectly connect to the vertices irregularly

Alright, I honestly don't understand what you are asking. But a quick way to get any flat shape cutout is to delete all but one vertex. Then you can press E to extrude another vertex. These will be automatically connected. Make sure you are in vertex select mode by pressing 1 on the top row, or by pressing the vertex button. Then at the end, you can select your first and last vertex and press F to merge them. Then take all the vertices one side and press E to extrude them and they should extrude into faces. Now you can flatten all the vertices by pressing "S" for scale and pressing Zero. This will automatically shrink all your points into one, press either "X, Y, OR Z" until you get the one that you want. Pressing these will scale only on those axes.


Why did Global Texture Coordinate disappeared in Blender 2.80?

The global coordinates where an option that only existed for the Blender Internal render engine.

  Global

  The scene’s global 3D coordinates. This is also useful for
  animations; if you move the object, the texture moves across it. It
  can be useful for letting objects appear or disappear at a certain
  position in space.

It wasn't and isn't an option in Cycles or Eevee. The closest equivalent would be the Camera output of the Texture Coordinate node.

  Camera

  Position coordinate in camera space.


I want to learn how to create 3D games using Blender and Godot. First Step would be what steps would I need to create a universe?

Sounds like you want to make a game, and really you just want to make some assets.  I'm not sure this it's possible to really answer the high level of complexity here but I can give you some overviews.

LOD is Level of Detail, and it means that you create at least three versions of a planet (Or any other object): A small four point plane with an image mapped to it for when you are too far away to care what it looks like, a low poly sphere with a texture mapped onto it for medium range, And a high detail version which includes multiple sphere's with transparency set on the outer spheres to represent clouds and atmospheres.

Use camera cuts to show show them landing on the surface, and then load up an area with natural boundaries to keep them contained in that area.

As for your universe and the planetary systems, there are quite a lot of ways to accomplish this.  I'm just going to suggest A way.

Create a few basic models of planets and moons together as groups.  Parent them to an empty object at the center of your planets.  Add Array modifiers to the moon to get more than one moon. Use drivers on the rotation of the empty to rotate the moons, and a driver on the moon to turn the base moon. Try playing with array modifiers stacked on array modifiers.

Once you have some variations of planets, you create a subdivided plane and add particles to it.  The particles can be groups and you can add your planet groups to the particle field.  Make sure you use the outline view of the plane to turn rendering of the plane off.  You can add more planes with different geometry to cluster or distribute other planet groups.  Remove geometry in the center of your plane to make room for the black hole.

Use a very large sphere UV mapped with stars with the normals flipped inside to represent deep space.

Use the camera depth to trigger your LOD detail for the planets and moons.

Assuming this is for a game, you CAN use the blender game engine, but you should probably leave it to Unity or the Unreal Engine (UE4) for the actual game environment.


Is there a cloud rendering service for baking in Cycles?

Maybe this might be something for you:
https://render.st/blender-render-farm/

There is also a plugin for Blender:
https://render.st/faq/

You can try it for (free) one day and 1$ and it supports baking of physics and bake caches.


User Login message box when opening blender to choose a different startup file on the start

This question is too open-ended to be answered in detail, so I'll answer generally. Before we talk about how to create such a solution, there are some issues with what you are trying to do.

First, there is no "security" offered by what you are doing, so there is no reason to ask for a password. You can simply let the user choose from a list of startup profiles. If you wish to provide some kind of security, you need to use your operating system's user accounts. You said you are using windows, so you would want to create a separate windows account for each user.

Second, it's strange to be asking for "username", since the startup file is only a set of presets for new projects. If the user saves his work, and loads it later, loading the file will overwrite the startup file information. Choosing a different startup file would more likely be used to choose different "configurations" of blender, for different types of tasks.

Therefore, the only sensible way to use the UI you are suggesting is actually to present a list of "startup configurations" and let the user pick between them. The following will explain one way you might do that.

You will need to create some custom UI for your startup-selector using python. I don't believe you can modify the splash screen from python, so I would do this by making a custom page in the user-preferences UI. This custom page will contain your UI and the logic to load the proper startup file. (See scripts/startup/bl_ui/space_userpref.py)

Once you have your custom UI for picking a startup file and loading it, you can make a startup file which loads this when blender starts. Configure blender the way you want, with only one view on the screen, showing the user-pref space, with your custom space-chooser showing. Then do File->Save Startup File. Now this will show every time blender is launched.

That should give you a startup-file selector on launch.


Your particles will emit in the direction of the face or the tangent (outward pointing ray direction relative to the surrounding vertecies) of the vertex they’re coming from depending if which emission method you’ve chosen (faces or vertex, volume is only necessary if you wand particles generated inside an object). All that is to say, if you have a sphere, you’re particles will emit in the shape of a sphere. A cube, cubed shaped. The random amount does what you think, adds randomness to the direction each particle emits from.

To get the arc you want, your emitter object should be an arc. Use a cylinder and delete the top and bottom flat face, and the degree of the arc will depend on how much of the curved cylinder wall you keep. Delete one half of it, you’ll have a 180 degree arc. Keep the whole cylinder 360 degrees and your arc will bee 360 degrees, etc.


I'm not familiar with SFM, so I googled and found: https://developer.valvesoftware.com/wiki/Phong_materials , which suggests that the image you're looking at is a remapping of specular power (remapped from 0,1 to 1.0, 150.0).
Specular power is used in some engines for gloss/roughness.  A high specular power indicates high gloss/low roughness.  Blender does not use specular power to control gloss in any of its shaders, in either Eevee or Cycles, and specular power does not map linearly (or in any particular way, really) to Blender's various roughness models.
If you wanted to use this perfectly, it would require a separate render layer for every light, where you computed the specular highlight in compositing from raw values.  (Basically, specular = specColor * lightColor * clamp(dot(normal, (light+view)/2))^SP.  Which is then added to a no-specular version.)  This is tedious and doesn't lead to great looking output anyways.
If you wanted to use this in some fashion, you would use a remapped version of this and plug it into any roughness inputs your shaders use.  Like I said, there's not really any mathematically correct way to do this, so you'd be doing it by eye.  Main thing is to realize that a high SP corresponds to a low roughness and vice versa.
Note, that link suggests that different channels may or may not be used in SFM.  The above should be correct for a grayscale exponent texture, which should be the norm.  Technically, it is the red channel that is used as the exponent, while the green channel sounds like its used to tint the specular.  The link does not give any more info on how the green channel is used, other than suggesting it is rarely used and not compatible with all SFM branches.


You have Origins enabled in the Transform menu.
Just uncheck it and those annoying axis will disappear.

(The gizmo shows for each of your 583 selected objects)


Can't get the model weighted, all faces are red painted

For a reason or another the Deform option of most of your bones is deactivate, which gives them zero weight on the mesh, so reactive it for all bones that are supposed to have weight (and deactivate it for the master, the IK controllers, pole targets...).

To toggle several undeformed bones at once, as explained here by  Jaroslav Jerryno Novotny, you can select multiple bones, at last select one with the Deform activated, then right-click the Deform checkbox and Copy To Selected.


I am using the gLTF addon, how do I make my node group glTF Metallic Roughness exactly the same as my Diffuse BSDF

They're different shading models; it may not be possible to exactly match one with the other and vice versa. If you're creating a model for export into some 3D engine, you should try importing both and verify that it looks correct there, as ultimately the engine will determine how it looks.

In the future the glTF Blender Exporter will work with the Principled BSDF node, and then you won't need a special addon glTF PBR node like this.


When I press the camera button it zooms in further than it should

It looks like you are using an object as a camera. Which is not the same as an actual camera object.

In other words you don't get to control the mm of the lens, because it's not a camera.

To change your zoom however, make sure it is active and move it like a camera, including trucking it around via G hold middle mouse and move your mouse up and down (hold Shift if it moves to fast).

If this is a light, and you need it to illuminate something from the distance you view it at you will have to control that through strength and not location, or you will have the same problem all over again.

My guess is that you think you are using the actual camera, and instead you are using some other object as a camera.

If this is the case:

Get out of camera view.
Select your camera.
Ctrl+Numpad 0.


How do I extrude only a small portion of a face?

Let's assume you want the extrude a small portion of the plan(a).
plan(a) is 1m*1m . We will extrude 0.5m*0.5m know as plan(b):

Select plan(a),
(1)use the extrude fonction but do not extrude yet

(2)change to scale fonction and now you can extrude. You have now the plan(b) inside the plan(a). With both plan perfectily aligned.

(3)Now you can extrude plan(b)

In the picture attached the you can see the face and profile view so it will be more clear.


Normalize / Create a unit quaternion number / calculation using Python and Blender

This can be done making and using the function below:

Original:

def normalize(v, tolerance=0.00001):
    mag2 = sum(n * n for n in v)
    if abs(mag2 - 1.0) > tolerance:
        mag = math.sqrt(mag2)
        v = tuple(n / mag for n in v)
    return np.array(v)

Updated Version using batFINGER suggestion: April 26 2020

def normalize(v, tolerance=0.00001):
    mag2 = sum(n * n for n in v)
    if mag2 > tolerance:
        mag = math.sqrt(mag2)
        v = tuple(n / mag for n in v)
    return np.array(v)

Or using the built in Function

import mathutils
quat1 = mathutils.Quaternion((1, 2, 3, 4))
quat1_norm = quat1.normalized()
print(quat1_norm)


You want to enable the 'Use Alpha' toggle in your output compositing nodes' properties (shown in their 'Properties' panel (N key) when they are selected).


Can you edit an imported XPS model in Blender?

How it work? I think that you do not need to explain how to install the addon, and simple operations in the blender!
Launch your blender! In object mode, search menu XPS Tools! (on the left side of your monitor screen)
Or just standart import:  File, Import, XNALara XPS model (ascii/mesh/xps)
Then after loading model, in outliner window (on the right, and up, on you monitor) you see armature of models, in scene!
Click Left-click on Eye icons, and close armature! After that, right-click on any model body, and push Tab! (Or enter edit mode) Enjoy! Your model editible)


It might be too late but in Blender - Viewport settings, if you ever limited the Textures size, then you might want to increase it back. This should fix the blurry images.


In the compositor use the mask node, then choose the mask from the list.

However you need to specifically make separate mask data blocks before drawing all your masks.

See in the Movie Clip Editor when you do your masking you need to make sure each mask you want separate is on its own data block. That is the set of controls in the Movie Clip Editor header, not the Mask Layers in the proprieties side bar.

In this image I have the Mask Layers underlined, that is not going to help separate the masks, all that is for is making a complex mask where separate shapes are used together to make a whole mask.

It can be kind of hard to remember to make a new mask data block (outlined in red in the image) before drawing all your masks.

Now depending on the effect you are making, there are two main ways to use a mask.

Plug it in to a Fac socket.

Here all I'm doing is changing the color of two of the green squares on the floor (final result). I'm using two different masks plugged directly into the Fac on the Hue Saturation Value nodes.

Any time you see a Fac that is a spot a mask can be used.
(Some nodes like the Color Correction node are labeled Mask instead of Fac.)

The Mix node

This is the more common way to use a mask. Plug the mask into the Fac of a mix node (or Alpha Over node). This is how you are going to set up many effects in the compositor.
The principal is simple, do the modifications to the image, then "mix" it with the original using the mask to control where.


The rendered image has nothing to do with my animation

If you look at the top left of your screen it says Object as Camera.

In the scene section choose your camera as the active camera:


short answer: as @cegaton has pointed out, save your image with 16 bits depth. If you are baking like me, this has to be done before bake, because resaving later does not generate information lost while baking.
Go to 'Save as' dialog, there in the lower left corner choose 16 bits depth.

A (not so) technical explanation: if you are not familiar, depth is the number of bits used to store the pixel color. With 8 bits, you store 2^8 = 256 color values at maximum, with 16 bits that's 2^16 = 65536 possible colors. What was happening in my case is the following: for the different height values in the geometry that I was baking, an approximation was generated to store the height. In other words, for heights x-0.01, x, x+0.01s, it would simply put x, because it has no bits to store all the three. Hence the flat areas in your image, where the color gets 'simplified'. For my 8 bits image, I did for learning purposes:

len(set(bpy.data.images['My8BitImg.png'].pixels))

This has returned 256, while

len(set(bpy.data.images['My16BitImg.png'].pixels))

has returned 42891 in my case.


Here's a link to an addon:

http://niftools.sourceforge.net/forum/viewtopic.php?f=13&t=5823

To install it:

Download the folder
Open User Preferences (Ctrl+Alt+U) and under Add-ons, click Install from File. Then navigate to the file and select it.
It should now appear in the window and you can tick the checkbox in the upper right to enable it.

Related: Installing an addon


Place/spawn objects along curve with randomized scale and rotation?

Yes, use a particle system.

Use the techniques described in my answer to array a small plane ver a curve. Add an Array modifier set to fit curve and and a Curve modifier afterwards to a small plane or object that will be the base for ditributing your flowers.

Instead of Duplifaces as described in the answer add a new particle system to your plane object.

Turn on the option to Use Modifier Stack, emit from faces without Random and Even distribution. Then set Particles per face to 1 (if you desired a perfect single item alignement).

Under the Render Panel  of your particle system set it to either Object and pick your flower object or Group if you have a set different ones to distribute.

Turn on both Unborn and Died and turn off Emitter. You may also need to disable the physics set to None

You can now control the size randomness from the Random Size property under the Render panel.

Adjust particle count as necessary to match the number of arrayed items.


You can see the link icon in the object data properties.


Shader that is only visible when the face normal points up

As mentioned in the comments on your question, this can be achieved using the Geometry Node and the Separate XYZ Node. Using the Z output will give you a range of black and white values based on how much the normal of the face is pointing along the Z axis. A ColorRamp node could be used to isolate the parts of the mesh that are pointing straight up (completely white) but the math node works a bit better in this case. I used the Greater Than operation and connected the Z output to the top, and put a number just below 1 in the bottom input. Note that a number like 0.99999 will be displayed as 1, but not treated as such. This will then isolate the parts of the mesh that are pointing straight up or down, and the output can be used as the factor for a mix node.

Here's a quick scene showing my setup on an object:


Why does Eevee make some meshes glitch and disappear as I move away from them?

Setting the Clip Start to 0.001 is what caused this.
Setting it to something slightly higher fixes it.


Audio playback doesn't work in the Movie clip editor.
For Video editing you should use The Video Sequence Editor.


At What Point in My Workflow Should I Apply a Mirror Modifier?

Either undo (CTRL+Z), or File > Revert, or load a backup file, or manually remove mirrored vertices:

Press Numpad 7 if your object was mirrored around X or Y, or e.g. Numpad 1 if it was mirrored around Z, then press SHIFT + Z for X-Ray mode and drag-select all vertices that have been mirrored - and press Del or X to remove them.


How to fix those stretches ? / UV unwrapping

This is because you got n-gons that are "intersecting" with itself.
The easiest fix for that is to triangulate the faces that are causing problems.

Select the faces that are ngons and press

  ctrl + t

or search for Triangulate Faces


How to create a custom colour management profile

If you want to affect color globally, through a variable accessible in the color management controls, you need to create LUTs (Look Up Table), that will allow you to convert values of pixels in an image into other values. Creating LUTs has to be done in a different program, Blender has no tools for this. There are many Lut creation programs available online, DaVinci Resolve would work fine as well.
Once created, the LUT has to be saved into one of the folders where Blender stores the LUTs that constitute the color management system.
To make the LUT accessible in blender's color management, there is a file that needs to be updated with the information for the new LUT. The file is called config.OCIO. Create new definitions (or stanzas) in that file so that the new luts can be applied to the images. Creating new "looks" would work for your purposes.
For detailed instructions, please refer to the following posts:
How to make 3D LUTs and use them in Blender?
and
Can I use my 3D Luts with Flimic?
Note though that LUTs will not self adjust or analize data to convert values from scene to scene depending on varying brighness and ranges. LUTs  are static, in the sense that they will only work for a certain set of data and will not re-adjust to others. For a case-to-case conversion of parameters you would need some scripting and other kinds of trickery before you process information throught luts.


Why is my smoke in such a bad quality (cycles)?

You simply don't have enough resolution. You have 50 base res, and 1x high res. Each high res division splits the voxel along each axis, so with 1x high res your domain container is only 100 voxels high. However, the smoke region alone is over 400 screen pixels high in the final render! Usually there's some padding in the container as well, so each voxel has to cove 4-6 screen pixels! This leads to the pixelated look. You need to just increase resolution.

Adjusting base resolution can alter the movement of the simulation, so try just cranking up high res first. Increase high-res divisions to 3 or 4, and re-bake. See if you like the result. If it looks too obviously like a smoothed low-res sim, drop back to high-res 1 (to save baking time) and do some tests with higher base res, like 70-100. Once you're happy there, bring high res back up to keep even more detail.


How can I make a material that is transparent at the center and emission at the corners of a plane

Some function of (distance from object origin) will give you a circle to do what you want with.. here, using a Map Range to soften the mask, which is plugged into the alpha-channel of an emissive material. If you need to have the center of the circle somewhere else, you could use another object's origin, using the option near the bottom of the Texture Coordinate node.


How do I convert camera coordinates to world coordinates?

Is a scripted version necessary to you? Because there is a very simple node setup to accomplish this:

In this image, I convert the vector 0 0 -1 from camera space into world space. If I look from the top, it will be blue, from the back it will be green, from the right (as here) it will be red. This way the color always corresponds to the orientation gizmo.


Ok I finally figured it out. It is not as good as the color map from above, but its close enough... Here is what I did, if anyone has the same problem:
Add those nodes in the blender shader nodes and click on viewport shading (with cycles renderer) You can adjust the border from the bevel node.


Deleted compositing layout -- How to bring it back?

The custom screen layouts are saved in a blend file but they don't show up when we append data from another file. This leaves two choices, recreate the layout that is missing, or open the file without the screen layouts and replace all of the screens in the file.

To create a new screen layout click the + next to the screen list and give it a useful name. Now adjust the layout so that the editors are where you want them and save your blend file.

If you start with a file (maybe your default startup) that has the layouts you want to use, turn off load UI when you open your blend file so you keep the existing layouts, then resave the blend file with these layouts. Not that this removes any cutsom screen layouts you may have had in your file.


Background Images in the Right Orthographic Viewport Disproportionate to the Other Views

The way I deal with this is to take the three views of the object, and normalize them to the same size. Lets suppose I have the dimensions of the images of item are that the top view is 1000 pixels long by 800 pixels wide, the dimensions of the front view are 1000 pixels long by 1200 pixels tall, and the dimensions of the end view are 800 pixels wide x 1200 pixels tall. In Photoshop (R) [NB: for the record, I don't use photoshop, and do this in GIMP, but it is beyond the realm of my imagination that you can't do the same thing in photoshop] I create a canvas using the maximum of the dimensions of all three, plus a border, so I'd create a base image size (in GIMP, a "canvas") measuring 1100 x 1300 pixels. I'd make three copies of this image, and into one I'd place (so that the center of the desired part of the image is at the center of the canvas) the top view, in a second I'd place the front view, and in the third, I'd place the end view. The amount of border around the three images will vary, but the parts of the Blender image in each viewport should be both the same perceived size, and the same actual size.

I don't usually "waste" the borders around the images, either. Using the image processing software, I'll usually edit into the borders of the background images things like scales and useful dimensions not already provided, or readily apparent, in the drawing.


Change camera start tracking time / change values

You need to animate the influence value on the "Track To" constraint.

If the value is 0 the camera will not track the object.

When the value is 1 the camera will track the selected object.

To animate the value you need to create keyframes, just place your cusor over the Influence value, right click and select Insert Keyframe (or simply press I while the cursor is over the value).

Keep in mind that when the influence is 1 the tracked object's origin will be in the center of the frame, so going from 0 to 1, or from 1 to 0 might change placement of the object within the frame. For smoother transitions make the value change over the course of several frames.


So here is a hexagon grid converted to a staggered rectangular grid with indication of the direction how the rectangles need to "line up":

The rectangles are seamless from top to bottom exactly how you expect. But the left-right 'seamlessness' needs to be rotated +30°(or -30°) because of the staggering.

When you have the rectangle seamless, you create the hexagon from it by cutting and re-arranging the corners like this:

Now you know how to seamlessly tile hexagons. With a bit of skill you don't need to go through the rectangle phase at all, just create tiling with one tiling axis rotated 30°. That's the trick.


How to save the render result within Blender

No, Blender doesn't have this functionality.

Its possible to write an addon to do this, on-save it could save the render result to a Multi-Layer-EXR image, and on load it could check for that image, loading it if its available. (probably not all that hard to get basic functionality, but you will loose render slots).

An alternative which is admittedly little clumsy, you could use a file-output node in the compositor and save this in your user-defaults,
so your renders are automatically saved. In the user default you could have an image view pointing to this file, so on-load it would read the last rendered image.


Texture with a grid of points? With Python?

A wave texture will give you a gradient from black to white. Two of them rotated ninety degrees from each other gives you a grid. A colour ramp can then adjust the size of each square, which with the gradient becomes circular at smaller sizes.

Set the colour ramp to use constant interpolation to get a sharper edge. Adjust the position of the ramp stops to adjust the size of the spots. The mapping nodes and scale of the wave texture will adjust the overall placement.


How do I colour a fluid simulation in Cycles based on velocity?

In Blender 2.82 and later, the fluid simulation engine used in previous versions has been replaced with Mantaflow. When Mantaflow simulates the fluid it provides a particle system that can be used to determine the velocity of the fluid in that region of the simulation.
To achieve this, use a Point Density node set to the Liquid Domain object with the Liquid particle system with a material similar to the following :

This takes the Object coordinates and converts into World coordinates - this is required as the particle system is always defined with respect to world coordinates. The Point Density defined the Object (the domain) and the particle system (Liquid) using World Space. Set the Radius to a suitable value such that the influence of each particle is large enough to prevent gaps and select Particle Velocity for the Color Space. The Color output will now represent the velocity of that section of fluid (with RGB representing X,Y,Z velocities.
In my example I used Separate, Absolute, Combine nodes to avoid negative values for use to colour the mesh for demonstration purposes. You can use a Vector Math 'Distance' node to convert the Color directly into a 'speed' instead, if desired.
Note that the Point Density can only be used with Cycles (ie, not Eevee).


How can I make 2 separate meshes blend seamlessly while keeping them as separate meshes?

Position all mesh joins under the clothing.

In fact you shouldn't need to "join" the meshes, you position a head and shirt so that the shirt is over the top of the neck vertices.

Another option is to have all clothing and head details in textures, so you always use one solid mesh. Maybe a collection of different complete character meshes with different texture options.


What is this group that applies transforms onto objects?

That's an Empty, you could parent objects to that empty and that will become the new world zero for the object. Your object has keyframes (that's why is green) and probably that's the reason for the "incorrect size"


Get Blender X,Y,Z and Bounding Box with script

To include parenting and drivers, use this for the actual object location / origin:

ob = bpy.context.object

ob.matrix_world.translation # or .to_translation()

You can get the bounding box corners Object.bound_box in object-space and multiply by Object.matrix_world for world-space:

from mathutils import Vector
bbox_corners = [ob.matrix_world * Vector(corner) for corner in ob.bound_box]
# bbox_corners = [ob.matrix_world @ Vector(corner) for corner in ob.bound_box]  # Use this in V2.80+

Note that the bounding box is not axis aligned.


How do I make objects translucent but keep background images solid?

Welcome to Blender Stack Exchange!

In Blender 2.8 and on, there is an option to enable translucency in a scene, called X-Ray. It can be found in the shading options in the viewport.

Once that is enabled, everything in the scene goes translucent. Images may also go translucent depending on how you imported them. If you import your reference by going Shift+A, >Image >Reference they will stay fully opaque.


In order to display n-gons they need to be triangulated because video cards draw triangles only to simplify calculations. When the n-gon is automatically triangulated it so happens that there is an edge where you see the 'shadow' that's why it is visible there and that is why your solution works - it includes triangulation without any edges going from one side to another.


How can I get a Depth of field render pass?

Defocus node
There's build-in support for focusing on objects using this node.

In the Properties editor under Object data (with the camera selected):
In the Depth of Field panel, add your Focus object.

Camera Object Data, Depth of Field settings

When setting up your Defocus node, enable Use Z-Buffer.

Cycles DoF
Cycles also has built-in support for DoF. Again in Depth of Field panel, set your Focus object and now increase the Size.

Aperture Size
Also called lens radius. If this is zero, all objects will appear in focus, while larger values will make objects farther than the focal distance appear out of focus.

Creating a black and white depth image

In the Node Editor:

Add | Vector | Map Value (or Shift+A,V,M) and connect the Z-pass.
Right click on the Offset value and select Add Single Driver.

In the Properties shelf (N) of the Driver section of the Graph Editor:

Change the variable type to Distance and set the two object to the camera and your target object.
Set the script expression to -var.

Back to the Node Editor:

Adjust the Size setting in the Map Value node.
Add | Converter | Math(Shift+A,N,M), set to Multiply and the values to -1 and the Map Value node.
Add | Color | Mix (Shift+A,C,M), set to Screen and connect the Map Value and Math nodes.


Artifacts appear when I use the subsurf modifier

Your problem is that along the object you have large and ugly ngons (polygons with more than 4 vertices). Ngons don't work so well with the subsurf modifier.

Use quads instead to connect all of the other vertices, that will give you a nicer edge flow:


Find the texture coordinate node within your tree (it may be helpful to expand out the node groups) and attach a Mapping node.  This allows you to translate and rotate your coordinate space.

Attach the same mapping node to both locations of textures from which you created your Final Texture.


According to the Lego Digitial Designer manual it allows to export LXF, LXFML and LDraw files.

  Export. Export lets you create LXF, LXFML and LDraw files that can be
  opened in other applications

There are community developed Blender add-ons such as ImportLDraw by Toby Nelson that allow to import these models.


You need to get the "Copy Attributes" add-on. Here

This add-on allows you to copy alot more things to objects than with just the "ctrl+L" hotkey in blender. It also allows you to copy "Draw Options" of the selected object to the others with "ctrl+c".


How to scale to a specific point/distance

1.Select the edge that you want the model scaled from and hit Shift+S and select from menu Cursor to Selected.
2. Change Pivot Point to 3D Cursor and enable Proportional Editing.
3. Scale the edge and scroll the middle mouse button to increase or decrease the influence of proportional editing.

To to scale only on one axis hit X,Y or Z buttons while scaling, or to exclude one axis use Shift+X,Y or Z


Edit mode object mesh offset? Not sure how to explain this

It looks to me like you have an un-applied sub-surface (subsurf) modifier assigned to the object. The solid part is the representation of what the object looks like with the subsurf, but since it is not applied, the solid part is not directly editable in edit mode. If you move some of the vertices you can edit, you will find that the solid surface moves, too. An additional clue that this is the case is the normal lines pointing from each face.


Filling objects into a container: it's taking a while

What are your computer's specifications? Generally, it's pretty common since the physics calculations require extensive computation. You should bake your animations so you can play it a bit faster. More info https://docs.blender.org/manual/en/latest/physics/baking.html


Blender 2.79 Camera ortho doesn't show some roofs. But top ortho view does

The problem is mainly due to the camera Z position which is below top roofs (and so due to some limitation can't see them).

Move your camera up.

And adjust the following values:


You can't just turn on collision on the object and expect it to work.

Here is how u do it: first of all create your hair particle system.

Next turn on Hair Dynamics and turn on collision on the object.
Now go to the mesh with collision on and turn up the "soft body and cloth" outer and inner paramaters to say around 5 for both.

Now you can go back to the hair and turn up the steps to about 40 in the Dynamics tab. Now you should have good collision without the other nonsense. Also be careful when changing the other paramaters, it can slow everthing down tremendously.


After copying, you can unlink the action fron the object, by turning the dopesheet into an action editor and pressing the X button near the action name to unlink it.


How to record an object changing its shape?

As you set key frames, be sure to move further down the timeline before setting another key frame. A key frame just sets the value of the properties you are choosing at the current time. If you want to make the changes "live", you can too. In the bottom right of your Timeline, there should be a red button icon that will record your changes and make them key frames as you change it. This isn't quite as advisable IMHO because it gives you less control in the long term, as it marks a new key frame every frame.

I'd advise using an emphasis on the key part of key frame (har har) by creating key frames with a start value and end value at your start frame and the frame where you want the animation/change to end.

For instance, if you want a sphere to grow in size you would set a frame at the start frame with a set value for scale, then 30 frames later set another key frame with a higher value of its scale. This would look like the sphere slowly (or quickly depending on how far apart the key frames are).

This will work for changing the location of the vertices as well, if you use edit mode and select the specific vertices you want to move and change their location. Mark a start key frame and an end animation key frame where they have moved to your desired position.

Edit based on first comment from OP:

For your use I'd probably just create a particle system if you want a bubbling effect like on a cauldron or soda. If you want to use those objects after the burst out of the main object, you can key frame the objects by right clicking the Location/Rotation or Scale slider in the Object Properties tab, and selecting "Insert Keyframes". You will want to set a keyframe at the start frame, and then keyframe another frame further on where the bubble have come out of the object.


The problem is you've set the Shape parameter value to 1 in the Cycles Hair Settings. According to the Blender wiki:

  A shape parameter that controls the transition in thickness between the root and tip. -1 gives a constant thickness equal to the root, 0 gives a linear transition and 1 gives an instantaneous transition to the tip radius.

What happens when you set that value to 1 is it makes the thickness of the hair strand the same as the tip radius, which in this case is 0. That's why it didn't show up in the render.

Change the Shape parameter value to 0 and it'll work.


Try pressing S after highlighting your mesh in the UV editor to scale it downward. There should also be a repeat image setting somewhere in the UV editor.


Is there a way to execute code before Blender is closing?

Yes, this is possible, You can use Python's atexit module.

This can be used exactly as you would writing regular Python code (no Blender specifics are required.).

eg:

import atexit

def my_cleanup_code():
    print("cleaning up!")

atexit.register(my_cleanup_code)


How can I paint a mesh using projections of real photographs?

You might be able to use some of the techniques from this tutorial on camera mapping.

Namely, you may want to try using "Project from View" to project selected mesh faces' UV coordinates based on the current camera view. I've never tried using it via scripting, though.


Can I subdivide vertices in a single direction?

CtrlTab > Edge. Then subdivide as you want.

Comparison:


You might have proportional editing on. If you want to use it you have to press G and then move MMB  up to shrink the size of the area.


This fixed the error for me (taken from another thread):
Turns out my WIndows Update was to blame, installing a .dll file that was breaking both Maya and Blender. This was called igdrclneo64.dll/igdrcl64.dll.  It’s located in C:\Windows\System32 (On my computer it was located in C: \ Windows \ System32 \ DriverStore \ FileRepository \ igdlh64.inf_amd64_250db833a1cd577e.) I moved it to the desktop and now everything works


Not that this is preferable, but at least you can make something happen with bump if you want.
First we set up our object to paint, and set up a 4k image texture to the Bump slot of our object, checking the box to use Float.

Next we turn on Face select masking so that we can make a selection while in texture paint.

Next we use View>Align to View>Top to get our object view to the top of the selection so we can make as straight a curve as possible.

After setting stroke method to 'Curve', use ctrl-click to set points along the features you want from view, making sure to follow the curve of the underlying wireframe as reference.

Turn off Face select masking, and press the Return key to stroke the curve - I use a small brush radius here, but be careful not to zoom in and out because that will mean a lot of variation in stroke width.
Lastly, you can preview the result after switching to Object mode, and then determine if you need to invert the color of your texture to get the opposite direction. White is up, Black is down, and grey is middle.


Creating an Arbitrary Custom Transform Orientation in Python

Test code to create orientation and use in all 3d views in the current (context) screen.

import bpy
from math import radians
from mathutils import Matrix
context = bpy.context
scene = context.scene

# create view

bpy.ops.transform.create_orientation(name="Frank", overwrite=True)
orientation = scene.orientations.get("Frank")
print(orientation)

# make up some matrix
# rotated 45 degrees on (1, 1, 1) axis
m = Matrix.Rotation(radians(45), 3, (1, 1, 1))
orientation.matrix = m

# find 3d views to set to "Frank"
screen = context.screen
views = [area.spaces.active for area in screen.areas if area.type == 'VIEW_3D']
for view in views:
    view.transform_orientation = orientation.name

Note you can override operators to "trick" them into thinking they are running in another area.


Dimensions are just a byproduct from actual geometry size multiplied by a factor determined from objects Scale property.

They are a user-interface convenience to show resulting object dimensions rather than just the actual Scale property of the object, as such they can't be animated directly.

To have size change over time animate the scale of the object instead by keyframing Scale X, Y or Z.

If you still need to obtain accurate dimensions or particular sizes, adjust the intended dimension so you get the length you want on that specific axis, let Blender calculate the corresponding Scale factor automatically, then keyframe the resulting factor from the corresponding axis Scale property instead.


I know it can be confusing, so here we go :)

Flip the header - Right click on header > Flip to top
Remove Status Bar - Window > ✓ Show status bar
Use current layout for new files - File > Defaults > Save startup file

Flip the header

Remove status bar - pretty useful to keep, shows total/selected geometry and available shortcuts


How to model a ridged cone (using modifiers)?

Here is a way to do it:

Create a plane, go in Edit mode, rotate on the X axis and scale it, move it a bit away from its origin on the Y axis.
Cut it in half with a vertical edge loop, give it a Mirror modifier, enable the Clipping option.
Create an empty on the same position as the plane origin.
Select the plane, give it an Array modifier, deactivate Relative Offset and activate  Object Offset, choose the empty as the Object. Choose a Count of, for example, 18. Activate the Merge and First Last options.
Rotate the empty 20° on the Z axis.
Select the plane, go in Edit mode and edit the plane mesh, move the vertices, add some vertical edge loops.
Give your plane a Subsurf modifier, add some horizontal edge loops.
When you'll be glad with the result, keep a copy, then apply all the modifiers except the Subsurf, remove the doubles, close the top with some altM > Merge.


Why Scene Lights are not displayed in Eevee render?

Your scene is not lighted by the scene lights, but by preview environment texture, as "scene world" is unchecked here:

To get the same light in your scene world, you can setup the world material like this:

"studio.exr" is stored on your Blender installation path, under "datafiles\studiolights\world".


Having issues baking normal maps for this small pot, how can I fix it?

Normals around edges tend to look funky because it is  where there is the most visible difference between objects. In this case, it may depend more on how closely the edges of the the two objects are aligned.

Perhaps I can respond better to your question if you share what the lower LOD object looks like with the normal map.

Similar issues related to Normals and visible seams in renders include the following: Make sure the normal map is non-color instead of RGB at the bottom of the node. This is a common issue for visible seams. Also, other programs such as Unreal use a different standard for normal maps where the Y axis (green channel) inverted from what is standrd in Blender, which also makes seams visible and incorrect shading in the final bake. I see from what you've shared this isn't about the render view, but it's helpful to have this info for anyone with related issues.


Scaling (or rotation) object using two random points (helpers, vertexes for ex.)

You can set the pivot point to be the cursor or the active vertice in edit mode. You rotate normally R r double R tho, not grabbing from a specific point. But it should give a similar result


How to tidy messy corners generated by solidify modifier?

There is not any magic way to avoid the overlapping, even with a new complex Solidify Modifier (if I'm not mistaken).

When Solidify modifier was set to Complex mode with Thickness mode Fixed, you can try ...
Weld Modifier
It worked with small distances, but already here it started to change outer topology.

With higher value of Thickness ...

... you would have to apply Solidify modifier, select inner vertex and press L to select Linked and assign those to Vertex Group under Data Properties.

Than use this vertex group as a limit for modifier.

Remesh Modifier
But ... this Weld works only because of the big flat faces inside. Probably useless in your situation. You will probably more lucky with Remesh modifier > Voxel type.


Try  pressing (Ctrl+N) in edit mode of the mesh while all the mesh is selected, that will recalculate all the normals, also very important press (T) and in edit mode of the mesh while all the mesh is selected find button Remove Doubles. If non of this work try unwrapping the object again.


Execute a python function whenever the user interacts with the program

Blender doesn't have a way to explicitly catch user events, but there is a workaround if the user interaction causes the scene to update (which renaming an object does).
You can do this:

import bpy

class Watcher:
    def __init__(self, object, property, function):
        #if the property object needs deep copy
        try :
            self.oldValue = getattr(object, property).copy()
            self.newValue = getattr(object, property).copy()
        #if the property object doesn't need it (and don't have a copy method)
        except AttributeError:
            self.oldValue = getattr(object, property)
            self.newValue = getattr(object, property)

        self.object = object
        self.property = property
        self.function = function

    #Call the function if the object property changed
    def update(self):
        try :
            self.oldValue = self.newValue.copy()
            self.newValue = getattr(self.object, self.property).copy()
        except AttributeError:
            self.oldValue = self.newValue
            self.newValue = getattr(self.object, self.property)

        if self.oldValue != self.newValue:
            self.function(object=self.object, new=self.newValue, old=self.oldValue)

# this holds all the watchers
watchers = []
def add_watcher(object, property, function):
    watchers.append(Watcher(object,property,function))

# create the function to be called when name changes
# it can change scene property or whatever
def name_change(object, new, old):
    print("old value: " + str(old))
    print("new value: " + str(new))
    return

# lets watch your_object_name's name
add_watcher(bpy.data.objects["YOUR OBJECT NAME"], "name", name_change)

def watcher(scene):
    """This function will be run everytime after scene updates"""
    global watchers
    for watcher in watchers:
        watcher.update()
    return

# add handler if not in app.handlers
if watcher not in bpy.app.handlers.scene_update_post:
    bpy.app.handlers.scene_update_post.append(watcher)


Will this graphics card work well for cycles?

Absolutely! Although with only 48 CUDA cores, it might be rather slow... A slightly better one might be this one:
MSI GeForce GTX 710


Save every object in scene as individual .blend files via python?

Take a look at my add-on Splode. It can export individiual objects into individual blend files, and then link those blend files into the current file, replacing the existing objects. You should end up with the same scene, except that the objects are now linked from their respective blend file.


Is it possible to use different CUDA-capable graphic cards to render simultaneously?

Yes, you can use multiple GPUs for cycles rendering even if they are not the same kind (as long as they are not a mix of Nvida and AMD/ATI based cards).

Adding additional GPUs is the easiest way to speed rendering in cylces. Two GPUs will render an image in almost half the time it would take to render with only one. 4 GPUs will cut rendering times to almost 1/4...

In the Compute Device section of the User preferences you can choose the GPUs to be used.

When rendering in cycles, each GPU will render one tile and move on to the next unrendered tile until there are no more tiles left to render. Blender will render simultaneously as many tiles as there are GPUs available.

Each GPU will render it's assigned tiles, but if one of the GPUs is substantially slower it will just not render as may tiles within a frame as a faster GPU, and that might even cause the rest of the GPUs to idle until the rendering of the last tile is done.

The available memory for rendering will not be the sum of all the memory installed on the cards, but will be limited to the vRAM of the smallest card. In other words: adding a new GPU with 8GB to a system that has an old GPU with only 2GB, will make the new GPU only use 2GB of vRAM.

To find the optimal tile size you'll have to experiment a bit, as it varies depending on the the geometry, the size and complexity of the textures used. A good starting size is 256x256 but I suspect the cards you mention might be able to deal with larger tiles.

Other considerations:

Keep in mind that GPUs that are connected to a monitor (or monitors) will not work as efficiently as those that are just used for rendering. Refreshing the screen(s) or using other applications might also take away from the resources available for rendering.

If one of the GPUs is substantially slower or has a very limited amount of vRAM, it might be more efficient to have the less powerful card just take care of refreshing the monitors and not take part in the rendering

Rendering using GPU is generally faster than rendering on CPU, but there are still a lot of processes (ie. physics, particles, baking, etc) that are not dependent on the GPU, so having two or more GPUs will not make simulations cache or bake any faster.

If your scene has very large textures or needs to use more RAM than what's available on the GPUs, your scene will fail and not render, no matter how many cards you put in. For very big scenes with large textures that require a olt of RAM, you might still be limited to rendering on CPU.

Check that your power supply is adequate to handle both cards.

With two or GPUs your machine will generate a lot more heat. Make sure you have an adequate cooling system. If the machine overheats it will slow down and eventually shutdown or fail.


When you hover over the Bevel Start and End Properties you can press I to create a keyframe on them. The keyframes can be offset (move G) and duplicated in the graph editor.

You could continuously Duplicate and Move the keyframes for both of the start and end values, or animate them independently.


Edit > Preferences > Themes > Reset to Default theme > Save Preferences

(after entering the "Themes" tab you might need to load "Dark Blender" from the Presets)


PVRGeoPOD add-on is not found from preference after installation

https://www.cgchan.com/static/doc/sceneskies/1.1/installation.html
That's how to install an addon. It seems like software that has a business behind it, and this question is toward that software. I would ask them how to install.


Blender 2.91 Update: Click on Options in the upper right hand of your viewport. Under Transform > Affect Only, uncheck Locations.
Refer to image below:

This can also be accessed by hovering over viewport and pressing N > Click the Tool tab>Reveal Options>Reveal Transform>Uncheck Affect Only property Locations.
Refer to image below:

Previous answer from 2015:
Oops. I had things locked with Manipulate Center Points.


How to create hotkeys for specific modes that override the default ones?

Maybe you know it already but if you go to edit menu>preference>keymap you'll have the choice of the shortcuts for every windows and mode. Also the trick I use is to right-click and assign shortcut when I'm navigating the menu bars.
Let me know if it works for you!
Cheers
Fred


Layer two PNG images and and having both full color

Copy your 'Black' image, and set it to 'Non-Color Data'
Put in the Mix Shader in place of the Add Shader, and plug the new image copy in as the factor.

You might want to keep your Add Shader for viewport work only.


Python: Convert a point into camera-space (BGE)

The camera_to_world and its inverse world_to_camera transform matrices provide the simplest way to convert between camera and world space. However, the more difficult part is accessing the vertices in the game engine.

Getting vertices in the game engine requires three nested loops. First, loop through a game object's meshes, then loop through each mesh's materials, and finally get a VertexProxy for each index in the material. With the XYZ property on the proxy, we can multiply the world to camera transformational matrix by the vertex position to get the vertex in camera space coordinates.

After processing the vertex, multiple the camera to world matrix by the vertex and assign it to the XYZ property on the proxy.

import bge

scene = bge.logic.getCurrentScene()

camera = scene.cameras["Camera"]
cube = scene.objects["Cube"]

for mesh in cube.meshes:
    for material in mesh.materials:
        for i in range(mesh.getVertexArrayLength(material.material_index)):
            proxy = mesh.getVertex(material.material_index, i)
            vertex = camera.world_to_camera * proxy.XYZ

            #process vertex in camera space

            proxy.XYZ = camera.camera_to_world * vertex


There is no object info node in Animation Nodes addon

I originally called the node "Object Info" because I had no idea how large the whole addon will become. At some point I noticed that I will need multiple nodes that get data from objects and to avoid some confusion I decided to rename some nodes to give them more detailed and exact names.

This is why the "Object Info" node is called "Object Transforms Input" nowadays. Beside that there are Object Attribute/Matrix/... Input nodes.

The Velocity sockets have been removed because they did not fit in very well, they made the code more complicated and (most importantly) did not work in all cases.

If you still want to know the velocity of an object you can get it with a little workaround (this does exactly what the node internally did before):


Particles converted but materials are linked

A quick workaround would be to utilize the Random output of a Object Info node in the shader graph, plugging it into a Hue/Saturation node input. In this way you could randomly vary the hue or the saturation or both. I personally utilize a Bright/Contrast node in between to get the hues I need.

But I think the real issues is to be found in where exactly this material information is stored. You can conveniently decide weather to store it in mesh data or in object data opting in this drop-down menu in the material property panel.

If materials are assigned in mesh data ("Data") every instance (meaning linked copy) of that object will have the those materials and if you change them they will change over all objects. Otherwise if materials are stored in the object data-block different linked object will be able to have different materials.
If you prefer proceeding this way you'll have to change this property before converting the particle system, in the original sphere.


Draw in a region not found in space type

Easily checked.
The type of region available to each of the area types is probably in the docs somewhere, however it is easily checked using the python console.
With a 3d view area as the variable area (C.screens.areas[3] in this example)
>>> area
bpy.data.screens['Scripting.001']...Area

>>> area.type
'VIEW_3D'

>>> for region in area.regions:
...     region.type
...
'TOOL_HEADER'
'HEADER'
'TOOLS'
'UI'
'WINDOW'

if it's not there, it's not possible with python.
Somewhat related https://blender.stackexchange.com/a/161773/15543


You can rotate the view in the Y-axis in 15 degrees increments by holding down SHIFT + ALT and scrolling the mousewheel up/down.


There are several addons to make this process fast, but here's a way to do it in plain Blender.
Select all the objects.  Get the 3d cursor where you want them aligned to (perhaps by cursor to selected, perhaps by typing the coordinates into the N panel's View tab 3d cursor section), and set the transform pivot point to 3d cursor - by default I believe that's the . key, though there's a dropdown for it also at the top of the 3d view.
Next, scale the objects with the modal scale operator (s by default), lock the scale to the axis you want to align on, and type 0.  They will all be snapped to the pivot point along that axis.


What should i do with cloth if i want to rig my character

Here are 3 ways to rig your cloth, the 2 first ones are quite similar. I'm not sure you will avoid any clipping though, you'll probably have to make some corrections:
With Weight Transfer: (2.79 and previous versions)

Parent your body to your armature.
Make sure that your cloth has no vertex groups or is not parented to your armature.
Select your body, then your cloth, switch to Weight Paint mode.
In the left menu (T) > Tools, click on the Transfer Weights button. On the bottom of the T menu you'll see some parameters. For Sources Layers Selection choose By Name, and for Destination Layers Matching choose All Layers.
Come back in Object mode, select the cloth, then the armature, and ctrl P > With Empty Groups. The cloth should move with the bone and be parented the same way as the body.

With Data Transfer modifier:

Parent your body to your armature.
Make sure that your cloth has no vertex groups or is not parented to your armature.
Give your cloth a Data Transfer modifier. For Source Object, choose your body. Click on the Vertex Data option, then on the Vertex Group(s) button. Then on the bottom of the modifier click on Generate Data Layer and apply the modifier.
Come back in Object mode, select the cloth, then the armature, and ctrl P > With Empty Groups. The cloth should move with the bone and be parented the same way as the body.

With the Mesh Deform modifier:
As explained in this video by Daniel Kreuter:

Parent your body with its clothes to your armature (if the clothes are another object, choose CtrlP > Armature Deform).

Delete all vertex groups from the clothes (select the vertices and on the right of the vertex groups list, down arrow menu and Remove From All Groups). Assign these vertices to a new vertex group.

Create a mesh that is fully closed and that will encompass your whole clothes, i.e. that will be your « cage ».

Select your cage, then shift select the armature and CtrlP > With Automatic Weight. Give the necessary corrections in Weight Paint mode.

Give your body a Mesh Deform modifier (put this modifier above any Subsurf modifier) and in the modifier choose the clothes vertex group. Choose the cage as the Object and click on Bind.


Issue with multiple edge selection from vertex in Beldner 2.79

It's hard to tell how it happened, perhaps you've duplicated your mesh by mistake, anyway, select all and W > Remove Doubles and it will fix the problem.


How do I create a nice miter joint between these two pieces?

As always, I'm open to correction, but creating miters at the ends of existing meshes is a fuss in Blender, unless the angle is at 45 degrees, and you can KC cut through with constraints, or ShiftCtrlAltS shear the ends of the stock pieces to a known extent. The shipped 'TinyCad' add-on can help, generating vertices at the intersections of edges, but even then, you'll find yourself creating guides of one sort or another to snap to, removing and creating faces by hand.

By far the quickest way to create miters is with polygonal curves. Create a track and a profile curve (possibly by AltC converting them from duplicated edges borrowed from existing meshes)

The profile curve will be swept along its local Z
Its origin will lie on the track curve
Set the track curve to 2D in its data tab, fill 'None'
Set the Bevel Object of the track curve to the profile curve..

...and miters will be formed at every corner. The rightmost object has beeen converted back to a mesh; you may have to hit CtrlN in Edit mode to make its normals consistent.


How can I make a grip that is like the one on Count Dooku's lightsaber from Star Wars

The grip texture is quite easy to do.
It's just a brick texture with Bump/Displacement.

Use the Brick Texture node. Set Width and Height the same, to get that square pattern.
Connect it to the UV map and rotate it 45° using the Mapping node
Add Color ramp to control the height difference, and use it with Bump or Displacement node

You can use it with the Bump node, to fake the 3D appearance.

Or use the Displacement node, for a real 3D effect. It requires a lot of geometry. Also, don't forget to enable true displacement in the material settings.


Is it possible to make a displace modifier collide with other objects? if not, is there a way to make the food not go through the cooking pot?

See Vertex Groups.  There are plenty of postings here at BSE to be searched.
By selecting the top of the delicious tuna fish casserole in Edit Mode and making it into  a vertex group named say "TCTOP" you can displace only exactly the top of mesh.


Is it possible to take a mask clip and 'connect' it to a specific point on a moving object?

A mostly automatic way to do what you want is to use a Plane Track

The workflow is like this:

Load your video clip in the Movie Clip Editor

Create a tracker on your image by clicking while pressing Ctrl and pressing  the tracking forward button (or CtrlT)

Track at least four points within your video corresponding with the area you want to paste your "decal" to.

Select all your trackers, go to the Solve tab and open the Plane Track control and click on Create Plane Track

A new shape will be created. (you might need to adjust the shape to match your needs) The deformation of that plane is controlled by the trackers.

On the compositor use a Plane Track Deform Node (found in the Distort section). Connect it to your decal image, select your video source, camera, plane track, and mix it with the movie clip.

The decal follows the movement and deformation on the video!


How to gradually reflect the texture and leave the material?

You can make a mask with black and white (image or a gradient texture) and then use [Object] texture coordinate with an Empty selected to determine the physical location of that texture. You can then animate the location of that mask by either animating the mapping node location, or by animating the location of the empty itself. This also works for scale and rotation.

Use this mask then on a mix shader between two shaders, one with blank and one with the materials for the covers.


Your could go to File >> Load Factory Settings

Or you could do the following:

Good Luck


How to supress bpy render messages in terminal output?

The following output redirection proposed here does work:

# redirect output to log file
logfile = 'blender_render.log'
open(logfile, 'a').close()
old = os.dup(1)
sys.stdout.flush()
os.close(1)
os.open(logfile, os.O_WRONLY)

# do the rendering
bpy.ops.render.render(write_still=True)

# disable output redirection
os.close(1)
os.dup(old)
os.close(old)


What you want are particles. This will allow you to have may flowers falling, with minimal simulation overhead. The idea is you have the flowers on "cards" The cards are attached to the particles, and the particles physics replicate the falling.

Steps:

Position you camea
add a plane as wide as the camera in front of it.
Move your flower object to layer 2 M
Add a particle system to the plane, using the particle tab
Particle setup:

Make sure all the circled settings match:

Set the Emit From to Faces, so it comes out of the face of the plane. Verts would have it come out of the corners, where the vertices are and volume would work very well since our plane has no volume.

I set the normal a bit higher to make the flowers a bit faster.

Rotation needs to be set to Velocity hair, so that the planes face the camera, you may have to edit the phase option to the left.

Set the render to Object this will make your particles appear as planes, like you desired. Set the dupli object to match your image of the flower. You can adjust the size to scale the flowers.

Apply these materials to the picture of the flower:

In order to have the transparent background, we need to make a shadeless transparent material. The image will then add alpha back in later.

For the texture use these settings:

Select alpha under influence, then set it to one. The will override the materials alpha.

Render animation.

Note quality has been reduced by high gif compression, it will look fine when rendered

Demonstration:


populate a dropdown (or prop_search) with a string list

You're mistakingly asssuming that an EnumProperty can only hold integers. This works just fine:

import bpy

bpy.types.Object.my_prop = bpy.props.EnumProperty(
    items=[
        ('IDENTIFIER', 'The UI string', 'Tooltip'),
        ('JEMOEDER', 'Je moeder', 'Op je hoofd'),
    ])

For more info, see the bpy.props.EnumProperty API documentation.


Artifacts in Objects and meshes in viewport V2.81

Press N to open up the properties panel. Probably  you are near value 0.0001m, try to change it to 0.1m. Also try changing the end clip to 1000m.


Change Text, Button, and Icon on Button Click With Python in Blender

I got it batFINGER

Thanks! Mine was verbose indeed, but alas not close.

import bpy
from bpy.props import *

def initSceneProperties(scn):
    bpy.types.Scene.MyBool = BoolProperty(
        name = "Boolean",
        description = "None")
    scn['MyBool'] = True
    return

initSceneProperties(bpy.context.scene)

class UIPanel(bpy.types.Panel):
    bl_label = "Property panel"
    bl_space_type = "VIEW_3D"
    bl_region_type = "UI"

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

        if scn.MyBool:
            icon = 'X_VEC'
            txt = 'Cancel'
        else:
            icon = "PAUSE"
            txt = 'Pause'

        layout.prop(scn, 'MyBool', text=txt, icon=icon, toggle = True)
        layout.label(text= txt)

bpy.utils.register_module(__name__)


How can I test if a mechanism works well before printing?

What you may want to try is you can import it into a website called Onshape, it is a free cad software, it requires an account but after that you should be good. You can import meshes into it, there are many tutorials online if you need help.


How to make a curved triangle with exact measurments

I think the easiest way to get the results you want is to start with a cylinder. Simply add a cylinder, choose triangle fan as the cap fill type, and from top view delete the mesh you don't need (3/4 of it). Then fill the 2 flat sides (one face each) and you're done.


Enabling Dynotopo turns my sculpted mesh into a cube

I kinda solved it by applying modifier in object mode too I know it's kind of silly but I am new to blender


How do you join two models together without messing up existing shapekeys?

There is no problem in joining two meshes with shape keys: you only have to be sure that - before entering edit mode - the "basis" shape key is selected in both the meshes. If some shape keys share the same name, change one of them or they will be merged.
All Shape keys are retained as long as you don't modify the vertices moved by shape keys.

If a shape key moves some vertices that you want to stay still: select all vertices you want to stay in the "basis" position, Ctrl V "Blend from shape", in the left bottom corner of the "T" toolshelf panel select "basis" and uncheck the "add" option. This method works also for copying part of a shape key into another.


How to create amazing looking low poly stone wall?

There's a quick way to create this kind of low-poly stones: The Bisect tool:

On the tool panel, keep pressing on the Knife tool button to have access to the Bisect.
Select your object, go in Edit mode, select the edges you want to cut (probably select all), use the bisect.
Change the options in the Operator box (Inner or Outer to choose what part you want to cut off, Fill to keep the object closed).
Select all to redo. There might be some shortcuts to redo easily (and not loose the last Operator settings) but I don't know them.
Add some details with the knife if necessary (last picture).
Link-duplicate (AltD) the stone to only use several ones in your scene.


Textures on animated boolean moves with object

First start by making the texture "stay fixed" on the cylinder.  You can probably accomplish this by making a longer immobile cylinder which is then boolean intersected with a moving cube.  Then use that composite object to make the hole in the cube.

http://www.pasteall.org/blend/31488

The sample blend illustrates this.

http://wiki.blender.org/index.php/Doc:2.6/Manual/Modifiers/Generate/Booleans#Materials documents that any new faces created in the process use the first material slot in the object hosting the modifier.  You will notice the cube has two materials.

You will notice that I have hide_render=True (the camera icon is greyed out in the outliner) for the drill objects.

The immobile drill cylinder has a UV map I created by marking seams and unwrapping with a cylindrical projection.


This is a screenshot from my version of blender (2.83). It seems to be here, if it's not, try re-downloading blender:


To add a Second animation you have to change first to Action Editor at the bottom from Dope Sheet

and then press the New button at the bottom:

And now you can Animate and switching between your animations

EDIT: After you created an Animatin you should press the "x" Button next to it and then press new:

and then press the new button:

It should work


Blender pure video editor - overlay image with transparent areas

Found it out.

When you add an image to the VSE (video sequence editor, where videos, audios, images, etc. appear as bars like a timeline), click the image bar with the right button. A properties panel will appear for that image, containing the filename and other information about it.

Under the "Edit Strip" section of that panel, change the "Blend" combobox to "Over Drop". (Usually it starts with "cross").

That will make the image transparent areas actually transparent on the video.


How to pass command line arguments through Blender without IndexError thrown?

All the parameters before "--" (+ 1 makes it inclusive) have been skipped here. The second line overrides the sys.argv to hold only items that go after "--", which is an array of length 2 containing [1, 2].
index = sys.argv.index("--") + 1
sys.argv = sys.argv[index:]

Array indices start from 0. You are trying to access a third parameter here
angle_movement = sys.argv[2]

This causes the out of index exception.
Should be
foot_position = sys.argv[0]
angle_movement = sys.argv[1]


Buffer property changes / shadow properties / restore properties

What is working for me now is adding the property group to the object type twice as my_props and my_props_shadow. The UI works with my_props_shadow. A reset operator copies my_props back to my_props_shadow. These seems clunky and I feel like I'm unnecessarily polluting the object namespace - but I haven't found something better yet.


Give object A an Holdout material.

That will only work if "Transparent" is enabled in Render Properties/Film, so in case you want a solid background, you'll need to add it in compositing.


As pointed out by @RayMairlot you can rotate the mask in the compositor by addong a rotate node and animating its values:


Armature rotates both sides of mirrored mesh

You need to have the mirror modifier first (on top) in you modifier stack, then the armature modifier.

In the mirror modifier have the Vertex Groups option enabled. This mirrors your vertex groups if they have _R / _L or simmilar endings. The bones on the left in your armature should have the ending _L and the bones on the right _R, so the vertex groups also get these endings.

If you create the armature, while in armature edit mode, you can switch on the X-Axis Mirror option in the tools panel. With this enabled, you can hold down shift while extruding from a middle bone to create two bones: one with the extension _L and mirrored version with the extension _R.


If it is a 3D model of a sprite you want, then I have actually made a Python Script / Addon that takes an image and converts each pixel to a cube with a material of the same color.

https://gist.github.com/MrSprite/ff7fda1ec4bf6850d357.  Go here and click the button that says Raw. Then you can right click on the page that opens to download the .py file.

Install it in Blender like a normal addon.

I don't recommend using images over 100x100 unless you want Blender to lag a lot.  Also it takes around 1 minute to generate 100x100 cubes, but only .39 seconds to do a 32x32 image.

Also, if a pixel has ANY transparency it will not be created, so be careful!


This event is kind of a 'meta event' - you will never get an event of this type (Blender's event system never generates it).

It is used by keymap, as a kind of 'generic' event - it matches any real event that can be interpreted as a typed char. You can find its 'definition' at line 1530 and following of wm_event_system.c in Blender sources:

if (kmitype == KM_TEXTINPUT)
    if (winevent->val == KM_PRESS) {  /* prevent double clicks */
        /* NOT using ISTEXTINPUT anymore because (at least on Windows) some key codes above 255
         * could have printable ascii keys - BUG [#30479] */
        if (ISKEYBOARD(winevent->type) && (winevent->ascii || winevent->utf8_buf[0])) return 1;
    }

Translated in readable english, it means that any event that is a KM_PRESS (key press) from the keyboard and that generates a valid char (either ascii or unicode one) is considered as a TEXTINPUT event.


How to make Blender render in real-time, as fast a computer game?

Use the Blender 2.80 Beta Version to get a new render engine called Eevee. The engine is lighter in performance consumption and can do real  time rendering even more realistically than the traditional Blender Render engine. Note: Before you open the old Blender file in 2.80 Beta, then keep a backup copy. Because once you open or create a project in Blender 2.80 Beta then you can't open it again in older versions. The physics engine is not yet completed. So, don't use the physics engine in Blender 2.80 Beta. If there is a bug or a problem in a feature of Blender 2.80 Beta,  then download the next day's version to get a better working version of Blender 2.80 Beta.


Use the Shear Transform from the Mesh > Transforms menu. I see you are still in 2.79. I would really recommend updating, because the Shear Tool in 2.80, which does the same thing is much more intuitive to use.


Create an IK bone directly at the root of your hand.
Constraint lower arm to the IK bone.
Make sure inhert rotation for the IK bone is turned on.


Expanding my comment above:

The "tracing" method is something like this:

1) Find an image at quite high resolution, like this:

I got this stock image from here.

2) If your image has noise or other unwanted drawings, you need to clean it up a bit. To do this:

Save the image to your computer and open in your favourite image editor (mine is Gimp).
Try to select just the window frame (I used Gimp's fuzzy selection).
Invert the selection (selects everything except the current selection, and deselects the current selection).
Delete all.
Invert the selection again (you'll get the window frame selected again).
Fill the selection with full black colour.
Copy the image.

You end with something like this:

Edit: I just noticed that I "lost" some geometry, in the example... I guess my fuzzy selection was too aggressive :D, but the rest of the example works anyway, Sorry.

3) Open Inkscape and paste the copied cleaned image, now you need to "trace" it:

select the imported image and activate trace tools (path > trace bitmap).
You'll need to find your best settings, try until satisfied, I used these:

4) Trace will create a new vector object: Save it (only it) as .svg
(you can copy it, open a blank file in Inkscape, paste then save).

5) Open blender, delete all (empty scene)

6) File > import > .svg

7) The imported object could be very small, select it in the outliner, and then scale it up enough (I scaled it up about 40 times)

8) What you have now is a curve object, and you can convert it to mesh:
- duplicate the curve object (backup)
- select only one curve object in object mode, press Alt+C and select "mesh from curve".

9) Now you have a 2d mesh from your 2d image! You can extrude it, perhaps before clean the 2d mesh a bit...

10) Looking closely the mesh object is far from perfect: you can refine this or, instead, go back to your first try (create from scratch using beziers), but now you know another trick ;).

If you choose to refine the 2D mesh (before extruding, beveling it etc.) you'll probably want to use snap tools, with reference shapes. Or else, I would probably choose the bezier-from-scratch method, it can seem slower, and it is, but you get perfect shapes. Refining traced objects is a pain, imho, and should be last resort when modelling methods can be used...

HTH, Marco


Nevermind, I did some research and found out 'convex decomposition' is what I want. I ended up using V-HACD Blender addon.


Should I fill every face include invisible one?

Removing the invisible faces means less things to render, which will save you time and require less processing power. So I would advise to get rid of invisble faces and everything that won't be shown in the final render.

I would suggest using a Boolean > Union to unite the two meshes once you have managed to create your desired geometry. It will turn the two meshes into one and remove all the invisble parts without requiring you to do it manually, which can quickly become tedious.

Of course, always make sure that you have copies of the original meshes, in case the Boolean operation gives you trouble and messes things up. It can happen, depending on the meshes involved, their complexity, level of detail and many other factors.


I'm not sure there would be any automatic way to fill the side, you could do it this way: enable the Snap (Vertex mode) and the Auto-merge options, select the vertical raw of vertices and then make successive extrusions on the Y axis, it will automatically snap and merge.


The UVSquares addon is designed to do this easily. Select the uv's you want to straighten out and click a button.


First of all lets start by pointing out what's not ok with your mesh.

It seems that you have there not one coin but three of them. As pointed by @Matt you can select loose parts by hovering over them and pressing L. Remove both of them.
After deleting them Select All (A) then W > Remove Doubles.
If you want to select UV Island in UV Image Editor and see it in 3D view as well, you need to check Keep UV and Edit Mode selection in sync option (marked on the screenshot). Remember to be in Face Select mode if you want to use Island Selection (L).

Consider filling top and bottom faces with Triangle Fan or Grid Fill (based on mesh purpose) as ngons could not be the best choice for texturing.

At the end don't forget to Recalculate Normals > Ctrl+N.

Blend file:


Blender Python convert units to imperial

If it isn't a duplicate q, the answer can certainly be gleaned from the q marked as dupe Is there a bpy function to convert from blender units to Imperial?

scale /= 0.3048  # BU to feet

which pretty much comes from 1bu = 1 metre

import bpy
import space_view3d_panel_measure as pm
scene = bpy.context.scene
uinfo = pm.getUnitsInfo()

def bu_to_inches(scene, d):
    scale = scene.unit_settings.scale_length
    # 1bu = 1 / 0.3048 ft
    return 12 * scale * d / 0.3048

def inches_to_bu(scene, d):
    return d / bu_to_inches(scene, 1)

# 1 bu in scene units
x = pm.convertDistance(1, uinfo)
print(x)
# 1 bu in inches
x = bu_to_inches(scene, 1)
print(x)

# 12.33 bu in scene units
x = pm.convertDistance(12.33, uinfo)
print(x)
# 12.33 bu in inches
x = bu_to_inches(scene, 12.33)
print(x)
# how many inches 12.33 bu is to bu
print(inches_to_bu(scene, x))
# how many bu 1 inch is
print(inches_to_bu(scene, 1))