I have a somewhat imperfect solution for you, but I think you could work it up into a perfect one.

That's a very raw render from the technique I'm suggesting.

And here's the compositor node tree.

I've used two render layers, one for the flask and another for the triangle. I've also given both objects Object IDs and the layers Object ID passes. Rendering uses the Transparent setting in the Film section.

Take the Object ID masks from the two layers/objects, and use the Math converter "Minimum" to create a binary mask of their overlapping areas.

Feed that into an Alpha Over node that takes as its input two versions of the flask layer, one opaque and the other translucent.

Then some more jiggery pokery to make sure that the transparency of the background is preserved, because otherwise it would obscure the triangle. That takes the Minimum of the Alpha values from the previous Alpha Over node and the original Layer.

Then another Alpha Over with the mixed-alpha flask as the second input. It shows the flask in front with the triangle visible through a translucent section.

Unfortunately there is no refraction, as there would be with rays cast through glass. You might be able to achieve it with a more complex set up, if you want to. But as it is, the flask is always in front but with the triangle visible.

Please forgive the crudeness of the models and render.

Edit: Slightly better example:


You need a reference to the material and the object.

import bpy

# alias as D because we'll use it alot.
D = bpy.data

red_material = D.materials["Red_Material"]
cube = D.objects['Cube']
cube.active_material = red_material


Just click off the solid view, whilst in x-ray etc.  If you have wireframe mode on instead it should be fine. Hold z-select wireframe, hope it helps. It just happens with solid view.

You seem to not have overlays turned on in the mode you want, in any view etc.
I tried it, and it shows the same without overlays. I assume it is wireframe-mode turned on in the overlays above icon, that creates the shading you dislike. Turn it off. Then try changing views.


Ball & Chute Interaction - Ball "sits on top" of chute

Sorry, just figured it out. Chutes needed their rigid body collisions to be set to mesh, not convex hull.


If you added it as a reference image, it should be under the Image Properties tab:


Quaternions must be "normalized" in order to represent an actual orientation.  That means 1=w*w+x*x+y*y+z*z.  Fortunately this gets handled for you, and much of the time the result is close enough to what you want that you don't even notice a problem.

However, if the animation system interpolates a value where all of them are zero, then it probably gets changed to <1,0,0,0> .  The only way to solve that problem is to add a keyframe that has the intermediate orientation, preferably in a normalized form.


Arrange the items in a collection randomly on a curve with good orientation in animation node

You can also try using Random List and Copy Object Data node.


Will there ever be support for audio speed control?

You can change an Audio Strips speed by changing/animating it's pitch. Though it has to be done independant from your videos Speed Control strip.

And it will (as it is labled) change your pitch. So if you want to maintain the pitch but only change the speed that has to be done in another audio editor like Audacity.


How can I automatize the separation of flat faces in a geodesic polyhedron?

Look at the edges face angle

This answer https://blender.stackexchange.com/a/177913/15543 separates a mesh into all its faces, and makes the face center the origin of the new single face mesh.

Result, all flat regions separated, showing one "face object" in edit mode

Instead for script below, make a bmesh, find all the edges whos face angle is greater than 1 degree and split them.  Note a boundary edge has no face angle

Then pop into object mode and separate into loose parts.  As in prior answer the origin is moved to center of geom of new object, rather than keeping that of old.

Run the script with object of interest active and in edit mode.

import bpy
import bmesh
from mathutils import Quaternion, Vector
from math import radians

context = bpy.context

tol_angle = radians(1) # one degree tolerance of flat

ob = context.edit_object
me = context.object.data
bm = bmesh.from_edit_mesh(me)
edges = [e for e in bm.edges
        if not e.is_boundary
        and e.calc_face_angle() > tol_angle]

bmesh.ops.split_edges(bm, edges=edges)

bpy.ops.mesh.separate(type='LOOSE')

bpy.ops.object.mode_set()
z = Quaternion()
for ob in context.selected_objects:
    print(ob)
    me = ob.data
    mw = ob.matrix_world
    mwi = mw.inverted()
    c = sum((v.co for v in me.vertices), Vector()) / len(me.vertices)
    n = sum((f.normal for f in me.polygons), Vector()).normalized()

    q = z.rotation_difference(n.to_track_quat())
    M =  q.to_matrix().to_4x4()
    M.translation = c
    me.transform(mwi @ M.inverted())
    ob.matrix_world = M

Note the edge split modifier could be added and applied to emulate the edge split bmesh modifier (may be quicker on large meshes). Would need to be in object mode to apply modifier. Still need to be in edit mode to separate loose.


This feature is known as Light Linking, and it doesn't exist in Blender as of 2.81a

There is a todo item to include this in the future: https://developer.blender.org/T68915

What you can do is render in multiple view layers with only certain objects and lights together in a layer. Create multiple view layers, and enable/disable collections to include them in the view layer. The arrow icon sets a collection to 'indirect only', so the object itself is invisible, but it still contributes bounce lighting.

After rendering, the view layers need to be combined in the compositor.


Render separate "back part" and "front part" so I can place something in between in other program?

A common technique in 3D is to render a Z-Depth pass. With this Z depth used as a mask in your favorite compositing app you can place any object at any depth (you threshold the mask to desired value with levels).

The advantage of this is that you have the freedom to change the Z-position of your 2D objects in postproduction. Exporting a Z-Depth pass is also often faster than rendering multiple times.

You can create Z-Depth pass with custom material, mist pass or remapping the Z pass values:

How can I get a Depth of field render pass?

Compositing fog destroys PNG alpha in Images as Planes when using Cycles

Here is how to use such pass in After Effects:

Video Copilot Explosive training (At 35 mins)

He mixes 3D debris and objects with 2D explosions through Z-depth mask.


While compositing, RenderLayer doesn't move with time

You have to rerender each frame in order to update the comp. You can do this by pressing F12 to render the whole scene or clicking the render icon on the layer node to render just that layer.

It would be simple to add the possibility of rerendering when the frame is changed, but in reality most renders take several minutes (sometimes hours, or days) to render and thus accidentally changing the frame would clear the render and you would have to wait for it to finish again.

Of course this option could be disabled by default, but I don't see any serious use coming from this and thus it's not worth the effort to code.


Can't select vertices of different meshes in edit mode

Distinct objects can't share faces. If you're using blender versions before the (currently Beta) v.2.80 they can't even be edited simultaneously in Edit Mode.

If you need to make two meshes a single object, in order to be able to bridge vertices belonging to both of them, then in Object Mode select both and Join Meshes (CtrlJ). Then Edit the newly created joint object.


Can 3DView Border Select behavior be changed?

Interesting question, never gave it much though, but now that you mention I did some investigation and came to the conclusion that I find it a smart and consistent system even if apparently unexpected at first.

If you border select only one corner, imagining you are in vertex selection mode, you are technically selecting one vertex only; so Blender automatically extends the selection to all the concurrent edges.

If you fully encapsulate an arbitrary number of edge then Blender will assume you want to select them and ignore the "vertex-extension" mode.

If no vertex is selected and no edge is fully encaspulated then "crossing-mode" is used instead, and any touched edge is selected regardless of being fully inside the border or not.


How to rig a switch to swap a bone's parents?

Use Python expression to do that :

Let's say the switch bone change the influence when its Y location is more or less than zero.

Add a variable to the driver which is based on this location, then use its value in a scripted expression, here "var > 0" which returns the value "True" (equal to 1) if var is positive and returns "False" (equal to 0) if var is negative.

For the second driver, do the same, but with an expression "var <= 0" to have the opposite values in return.
You can also choose to say "var < 0" if you want that none of the parent influences the child when exactly 0.

In result :

Note : when you validate something in the second driver, Blender switch back the selection to the first driver... a little bug maybe. So beware at which one is selected in the drivers panel, all the time.


I have a problem with baking - "No active UV layer found"

Your high poly one is the one active, which explain the error you are getting about the UVs for your high poly mesh. Just reselect them and you should be fine.


I'm not 100% positive I understood your question correctly, but here goes:

When you select vertices in a specific order by clicking each vertex individually, then Blender uses that order to join the vertices with edges.

When you use brush selection by pressing C then Blender does not get an order.
So now, when you try to join the vertices by pressing J, an error popup is displayed that says: "Invalid selection order"

To work around that you can simply press F instead of J to make a face of the selected verices and then you delete the face afterwards, so you end up with just the edges.

Here's a gif showing the whole thing:


You can open a second outliner view and drag and drop the collection back to the view layer.

Here from Orphan Data to View Layer:


How did I make this soccer-ball/honeycomb shape?

Bevel modifier

Start by adding an Icosphere with 3 levels of subdivision
Add a Bevel modifier with Vertex Only option enabled. Now you should
have the main pattern clearly visible.

As we want to delete the inner exagon of each loop, we can take advance of the modifier to add a distinctive feature to those faces in order to select them easily: increase the number of Segments to 2.

Then, in order to make the shapes less regular, decrease the Width value to something like 0.09.

Add a second Bevel of wanted Width modifier to create a "corridor" between the "main" faces.

Apply both modifiers, enter edit mode, pick one exagonal n-gon and select similar area faces with a threshold of 0.006, invert selection and delete other faces.

Final touch with Solidify modifier.

Result:


How can I add thickness to a polygonal chain?

In Edit Mode select the whole mesh A, then press Alt+S to "Shrink or Fatten" the mesh by dragging the cursor.


python script to read in .csv file containing quaternion coordinates and turn it into a path/curve for an object to follow

Your data was rather ugly, but I was able to write code that copes with the extra commas and spaces:

From http://www.purplefrog.com/~thoth/blender/python-cookbook/csv-to-fcurve-loc-rot.html :

Here's an updated version that handles the situation where the location and quaternion .CSV files do not have the same number of lines.  This opens up more questions about why they differ.  Are they different sample rates or different time spans or both?

import bpy
import csv

def keyframe_location(obj, fname):
    with open(fname, 'r') as loc_fh:
        r_loc = csv.reader(loc_fh, delimiter=',')
        i = 0
        for row_loc in r_loc:
            row_loc = [ float(x.strip()) for x in row_loc[:3]]
            fr = 10+2*i
            obj.location = row_loc
            obj.keyframe_insert(data_path="location", frame=fr)

            i = i+1

def keyframe_rotation(obj, fname):
    with open(fname, 'r') as quat_fh:
        r_quat = csv.reader(quat_fh, delimiter=',')
        i = 0
        obj.rotation_mode = 'QUATERNION'
        for row_quat in r_quat:
            row_quat = [ float(x.strip()) for x in row_quat[:4]]
            fr = 10+2*i
            obj.rotation_quaternion = row_quat
            obj.keyframe_insert(data_path="rotation_quaternion", frame=fr)

            i = i+1

def mission2(obj, loc_csv, quat_csv):
    """
     Use this version if the loc and quat .CSV files do not have the same number of lines.
     This opens up the question: why do they have differing numbers of lines?
     Are they covering the same time span at different frame rates, or do they cover different time spans?
    """
    keyframe_location(obj, loc_csv)
    keyframe_rotation(obj, quat_csv)

#
#

mission2(bpy.context.active_object, '/var/tmp/loc.txt', "/var/tmp/quat.txt")


First set the pivot point type to 3D Cursor and snap the cursor to the center of the grid (Shift+C). Then in Edit Mode select the whole rig (A). Press Shift+D, RMB. Then press Ctrl+M, type the axis (in my case Y) and -1. It'll mirror your leg along the desired axis. Then select the mirrored rig and press W-->Flip Names. It'll automatically name your legs properly with .R/.L.


How to render mesh's wire WITHOUT modifier?

If you mean render like this, Wireframe node is the key.


how to attach a camera to a single particle

This script assigns first particle location to another object(In this case Empty). you can parent camera to this object for further manipulation.
import bpy

ob = bpy.context.scene.objects["Cube"]
target = bpy.context.scene.objects["Empty"]

def my_handler(scene, depsgraph):
    eval_ob = ob.evaluated_get(depsgraph)
    particle_system = eval_ob.particle_systems[0]
    target.location = particle_system.particles[0].location

bpy.app.handlers.frame_change_post.clear()
bpy.app.handlers.frame_change_post.append(my_handler)

If you are looking for alternate solution, i recommend Animation Nodes addon, which can do this more efficiently.


Fixing normals after separating mesh into new objects

Unfortunately Blender has no method to adjust vertex normals by hand, so the only way to fix this (well, sorta...) is to separate your mesh in a way that the vertex normals don't change their direction at the cuts.

In a nutshell this means cutting up your mesh in the areas where you have a more even geometry. Depending on your geometry this might not entirely fix your problem but it reduces the amount of difference in the shading significantly. Keep in mind that this also might increase the loopcuts, which results in more vertices/faces.

In the image below I marked the areas where I put the loopcuts with green arrows.


no material are showing instead it takes a still color of the background in viewport

Could be that your normals are going wrong direction and the Backface cooling option is turned on. Check it


Blender to Unity: mesh disappears when updating blend file

It looks like the original name of that mesh was changed at data level (3 vertex triangle tab on properties name is differenr than tab where cube is) on Blender.
Second reason, could be because the prefab is searching for a different hierarchy order. Thus, it breaks it (un parents it because of bone name or mesh name at data level).

BFCT_Schiller


how do i add gloss to, let's say, just over the nose?

I'm only fairly new to Blender, but I believe that if you paint the area you want glossy in Texture Paint mode with a new black image as the base (and the glossy part painted white) you can then save that image. Then create a Gloss Node with your newly created image as the Fac input and use a Mix Node to mix it with your skin node/s.


Weight painting / vertex groups questions

You should follow some tutorials on rigging, like Darrin Lile's or Sebastian Lague's, it's better to first learn from scratch in my opinion.
Before parenting it's always better to make sure that the transforms (scale, rotation) have been applied, and that the normals of your mesh are correctly flipped.
For the vertex groups, when you'll parent the mesh to the armature With Automatic Weight, it will automatically create as many groups as you have bones, and the groups will have the names of the bones that control them. If the mesh already has some vertex groups from previous operations, it will keep them as long as their names are different but it won't interact with the parenting, so you should not have to care about that but you can always delete them if you prefer.
If you parent With Empty Groups, it will create as many groups as you have bones, but it won't affect any vertex to these groups, you'll need to do it either with the Assign button or in Weight Paint mode, this is the best method when you parent non organic objects like machine, robot, etc. as it let you define what part is supposed to be controlled by which bone and doesn't create any gradient influence.
For the armature, you can use the ones you currently have, except it seems incomplete, you should have a root bone, your lower legs or lower arms should have IK constraints, you should have the targets and pole targets for these constraints (you already have targets for your legs though), and make sure that these bones (root, targets, pole targets) have their Deform options disabled (which is not the case for your leg targets).


Is there a way to preserve unfilled areas in stabilized footage?

You may consider to load and save / overwrite source image for the calculation for each NEXT frame:

You can make some blank files with the same name with the target output filename, and put them in the render output folder BEFORE rendering. For example, you have an image sequence of 500 frames, then you should put at least 500 image files with the same name (whatever they are, even blank) into the render output foler. then add them into VSE, put into a channel below the current sequence, set the Blend mode of the current sequence to Alpha Over. and one frame ahead, then render. The output images will overwrite the existing ones, and luckily the calculation for the next frame will always load from disc (not from buffer or memory). Like this:

Before:

After:

NOTE: You have to realize that the offset between two adjacent frames is often more than 1 pixel (unless the camera moves extremely slow), so, as I tested, this idea usually isn't perfect, but works.


Is there a way to know when mesh topology is edited in Blender scripting API

Yes, you can use Depsgraph and handlers (depsgraph_update_post/pre) for that. For example,

import bpy

def mesh_change_listener(scene, depsgraph):
    # check if we need to iterate through updates at all
    if not depsgraph.id_type_updated('MESH'):
        return

    for update in depsgraph.updates:
        if isinstance(update.id, bpy.types.Mesh):
            print('Mesh \"{}\" updated.'.format(update.id.name))
            do_your_stuff(update.id)

if __name__ == '__main__':
    bpy.app.handlers.depsgraph_update_post.append(mesh_change_listener)


Export FBX with shape keys and animations takes FOREVER?

Try 'Selected Objects only' - on my machine, Blender hangs for tens of minutes if this isn't selected as it tries to export every object's animation for every object recursively.


Is there a way to add fake thickness to an alpha image texture?

There is another way - using a similar technique to the procedural hex shader defined here to displace additional Image Textures to "fill in" the faked depth.

The following nodes will generate the required offset based on the surface Normal, the Incoming ray, and the 'depth' behind the image plane :

The output vector can be used as an offset to the Image Texture coordinates and used to mix between a Transparent and Diffuse shader to project a faked "shadow" where the back surface would reside based on the specified 'depth'.

Taking this a step further we can "fill in" the depth by generating multiple 'layers' at different depths - eg, 8 layers at 0.125, 0.250, 0.375, 0.500, 0.625, 0.750, 0.875, 1.000 - by varying the 'Factor' of the MixRGB Subtract node.

Since the faked depth is generated on the image plane (it's all one flat surface rather than additional geometry), the surface normal is the same for the projected 'edges' as it is for the rest of the image. For additional realism we need to be able to generate a faked Normal for the projected layers and for this we need to be able to detect the 'direction' of the closest edge for any point in the original image.

To achieve this, take the Alpha channel from the original image and pass it through a Blur filter in an external graphics package such as Gimp (you could potentially use Blender compositor nodes to do this and save as a separate image but it's far simpler to use a tool more suited to the job).

Passing this blurred image into a Bump node will generate a Normal for each point - which will tend to point "outwards" towards the edge of the alpha "island" for each pixel in the image.

We can use the Cross Product vector math node to generate a faked normal based on the bump map that is perpendicular to the actual surface normal and is pointing in the direction of the closest edge from that point.

The Cross Product produces a vector that is perpendicular to both of the input vectors. Therefore, the first Cross Product with Normal produces a vector that is along the surface but that is at 90 degrees to the bump map generated 'normal' while the second Cross Product produces a vector that is at 90 degrees to that (so it's in the direction of the 'bump') which is also at 90 degrees to the surface normal (so it's along the direction of the surface) - ie, the Normal of the 'edge' of the projection.

The generated Normal can then be applied to each of the 'layers' to build up into the associated 'edge'.

Note that the 'edge' will not be correctly shadowed since the 'image' is still only rendered on a single plane - ie, it will not cast shadows on itself and shadows on other geometry will be limited to rays that pass through the image plane. it will also become distorted when viewed at progressively shallower angles. Note also that this will only work be effective if the 'layers' are sufficiently close together to prevent the rays traveling too far 'into' the image (otherwise the normal will be calculated for the opposite edge). However, it can produce quite pleasing results providing the viewing angle is not too shallow.

Note that there are multiple Image Texture nodes and each must be set appropriately - the 'main' Image Texture and the first column should be set to the actual image while the second column set to the 'blurred alpha' image.

Here's the final result :

Despite appearances there is no additional geometry here - the depth is purely faked and the only geometry is the plane.

Blend file attached

While not suited to UV mapping (since the material cannot determine the scale or orientation of the face), it can be used with Object coordinates to allow the pattern to be repeated (change the Image Texture nodes to Repeat). Also, the Color of the Diffuse shaders can be fed from each 'layer' image rather than being set to a single color - so that the 'surface' color bleeds back along the projected surface. This can produce the following effect :


Not able to get the final rendered output(when f12 is clicked)

To configure a render please be sure of the following :

you have an active camera in your scene and that the camera is pointing to your object
go to the render properties panel here and check what rendering engine you're using (Eeve or Cycles)

go in the output properties panel here, and check that you have a good resolution

And make sure you have a light in the scene ! (or an HDRI setted) in order to be able to see something.
Check that you don't have scrolled out too much in the rendering view window

If you still have the issue, try opening a new scene in Blender and render the default cube to check


(Blender Internal) How to time Cell Fracture?

Go to Properties Editor Type, in Scene context, check Rigid Body World on. Once done, go to the Cache options, and set the amount of the cache stored for your simulation, usually the same amount of the Time line, i.e. if you increase the number of frames on the Time Line, do the same in Cache options.


How to set bone rotation in Python script by an absolute value?

Your problem was using the edit bones, not pose bones.

A function I used was like the following:

set_rotation(ob, bone_name, rot, axis='X'):
     mat_rot = mathutils.Matrix.Rotation(radians(rot), 4, axis)
     bone = ob.pose.bones[bone_name]
     bone.matrix = mat_rot

This has the added benefit of using a quaternion I believe. I will need to look into that. axis can also be a Vector.


Do you mean something like this? - just plug an RGB input into the Material output. This is what you could call "unshaded", there will be no shadows or light scattering of any kind.


I don't really want to duplicate @moonboots' answer.. this one takes a slightly different approach, and may help with some intermediate steps for a beginner.

Working in the XY plane, X across.

Import your svg, and convert with AltC to a mesh. The mesh may be a bit messy, with a lot of edges that don't contribute to its shape or integrity. In Edit Mode, X > Limited Dissolve will get rid of a lot of surplus edges, by angle.
Create a plane that covers the geometry, and move it up in Z. Hovering over one of the long edges,  CtrlR > scroll to introduce enough edge loops across the plane to allow for deformation. X Delete > Only Faces to leave yourself with a wire frame.
In Object mode, select the plane, and then the path-mesh. Put the path-mesh into Edit Mode. In the tool region, find 'Knife Project'. Looking straight down Z in an orthogonal view, hit the button. This will project the plane's edges into the path-mesh.

Having rotated the whole mesh in Edit Mode, by 90 degrees in X so it's standing up on XY, assign a Simple Deform > Bend modifier, axis Z, 360 degrees.

This is what the rotation should look like, illustrated with the Transform Orientation set to 'Local', so the Gizmo shows the object's local axes. Note they are still coincident with the Global axes. (If they are not, you can hit Ctrl A > Apply Rotation)

Now you can apply the modifier and edit the mesh to join its ends (the small blue wedge in the picture). Use F or Bridge Edge Loops  between two edges to create a new face.
Now you can assign a Solidify modifier to give it thickness.

This example is quite low-resolution, you could use more divisions in the plane in step 2.

You can apply the Solidify modifier, and go in again with a Limited Dissolve,  adjusting the angle to tidy up as much as possible without losing detail

The topology is horrible for smooth shading or subdivision, but that's not what it's for. In Edit Mode, CtrlAltShiftM selects no edges, showing the object is manifold, and should print.


Gap between objects created using array modifier objects

Tick the Merge checkbox in the array modifier. It is most likely that your instructor too had used Merge option ticked


How to get indices of the faces to which a material has been applied, using Python?

This script iterates over the polys and adds their indices to the appropriate key (material name) if the material is applied to each of the current faces:

import bpy

o = bpy.context.object # Active object

# Initialize dictionary of all materials applied to object with empty lists
# which will contain indices of faces on which these materials are applied
materialPolys = { ms.material.name : [] for ms in o.material_slots }

for i, p in enumerate( o.data.polygons ):
    materialPolys[ o.material_slots[ p.material_index ].name ].append( i )

print( materialPolys )

For this object, an icosphere which has 4 materials (3 of which are actually applied to faces), this is the result:

{
    'Material.002': [7, 12, 41, 42, 53, 54, 55],
    'Material.004': [],
    'Material.003': [10, 19, 34, 35, 47, 48, 49, 62],
    'Material.001': [0, 1, 2, 3, 4, 5, 6, 8, 9, 11, 13, 14, 15, 16, 17, 18, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 36, 37, 38, 39, 40, 43, 44, 45, 46, 50, 51, 52, 56, 57, 58, 59, 60, 61, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79]
}


Does fresnel node corresponds to fresnel-equations?

First,the answer is yes.In most occasions you don't need to worry about reflection amount when using fresnel as fac in mixing shader.
Second,the fresnel equation compeletely characterizes reflection and refraction in a transmissive surface.In blender,the light is treated as unpolarized so that the reflection amount is 1/2*(R_s+R_p).Theoretically,the fresnel node should be used as fac for mixing refraction and reflection.Diffuse is an approximation of subsurface scattering,so for some materials we assume the refracted light is all scattered so we can replace refraction  shader by diffuse shader.


Seams are visible after texturing using UV unwrapping

Use texture paint mode to paint your Mesh from scratch after UV unwrapping for complete control and burden.  You may not feel like a [newbie] after that experience.


To convert the text, press Alt+C in Object mode with the text selected, and select "Mesh from Curve/Meta/Surf/Text", this will convert the text to a 3d mesh and you will not be able write letters like before.


I see at least 2 methods. The one you'll choose will depend on the amount of vertices you want and the time you want to spend on each object.

First method, bevels (faster but more vertices): You can select your object, go in Edit mode, select the angles you want, CtrlB to bevel, and set the bevel values in the operator panel. If the amount of Segments is low you can keep a rather low-poly version.

Second method, bevels + normal map (longer but no additional vertices): You can duplicate your object, bevel the copy, create a normal map from the beveled version, and use the normal map on the low-poly. This way you have zero additional vertex:

Create your low-poly version.

Duplicate it. Select the copy and in Edit mode, bevel the angles you want. Also, pump it up slightly with AltS (Shrink Fatten tool), keep pressing Shift if you want to be more precise. Give your object a Subdivision Surface modifier.

Bake the high-poly normals. To do so, first unwrap the low-poly (Smart UV Project mode), create a new black image in the UV Editor (32 Bit Float option activated I guess), give your low-poly a material with Image Texture > Normal Map > Diffuse > Output. Don't plug the Image Texture for the moment but switch it to Non-Color Data and load the image you've created before. Select the high poly object, then the low-poly, and in the Render > Bake panel, choose Bake Type > Normal, enable Selected to Active, click the Bake button. Set the Ray Distance at the right value, so that you have as less artefacts as possible. Anyway you'll necessary have some with this kind of geometry.

Export the normal map, import it in an image editor software, try to remove as many artefacts as possible, don't try it to make it perfect though, reimport the image, load it in the Image Texture node, plug the Image Texture node into the Normal socket of the Diffuse. You can also bring some corrections on your normal map directly in the 3D View / Texture Paint mode: Plug your Image Texture in the Color socket of the Diffuse to display it on the object, switch the 3D View to Texture shading, and use the Clone brush for example. When you're good, replug the Image Texture in the Normal Map node.


How to add detailed engravings onto a curved surface in Blender for 3D-printing?

You could try and model it with Bezier Curve objects combined with a Shrink Wrap modifier.
Just model use a any bezier curve object, define any desired section and use it as bevel object.

Apply a Shrink Wrap modifier to the curve, but the important part is to activate the option Apply this and all preceding deformation modifiers on splines’ points rather than on filled curve/surface.

This will make it so the bezier control points are wrapped to the surface, rather than the final beveled geometry, so that the curve can be beveled live, but its thickness and shape is kept.

Then adjust and model as desired, you can use curve radius to make certain parts thicker or thinner.


Try changing the Initial Orientation under Rotation from  "Object Y" to "Velocity/Hair".

Keep your other numbers as they are; those in this image are for my particle system.

This will probably mean that your wheat will not stand up right. To fix that, select "Rotation" in the Render section. Then, if the wheat is still not standing up, try rotating your actual "Bugray" object by 90 degrees along first the X, then Y then Z axes.

Each time come back to your main layer with the particle system on it to check the effect, then if the wheat is still not upright, undo the previous rotation and try a different axis.

Eventually the wheat should stand up, and because it's rotation is following the hair, it should be affected by wind and other force fields.


how i make this texture to have rotation but with a large scale at the same time?

So after playing around with math and vertor math for some reason it gives interesting effects but not what i was looking for, so i found the solution after someone above in the comments give me an idea which was quite the solution, i just had to invert the mapping node inputs and then it worked


Tilt a loop cut without affecting the whole form

Just to amplify on @moonboots' comment, you can use the ShiftCtrlAltS Shear tool, (with X or Y to determine the direction of shear,) which works in View space.
If your cube is not aligned to one of the preset orthogonal views, you can align your view to a face of the cube by selecting the face, and hitting Shift7 on the numpad.


Object B's position to Object A as a controller for object A's animation

If I correctly understood what you want, you could do it with a Track To constraint: Give your object A an armature, and give the bone that is supposed to move according to object B a Track To constraint, with the Camera as the Target. Now when your Camera moves, the bone will follow.


How to inset (or fill in) a complicated mesh?

There are a few ways that you could potentially approach this:

Manually select 4 vertices, press f to make a face, and repeat until you go crazy.
Select all of the vertices and press f to make an "n-gon", you'll quickly realize why n-gons are avoided.
Another option is the Face Tools built into Blender.

From the Manual:

  Fill

  The Fill option will create triangular faces from any group of selected edges or vertices, as long as they form one or more
  complete perimeters.

  Note, unlike creating n-gons, fill supports holes.

  Beauty Fill

  Mode: Edit Mode
  Menu: Mesh ‣ Faces ‣ Fill/Beautify Fill
  Hotkey: Alt-Shift-F

  Beautify Fill works only on selected existing faces. It [rearranges] selected triangles to obtain more “balanced” ones (i.e.
  less long thin triangles).

Check out the Manual link. It's got even more information.


Why when I apply my armature modifier the mesh won't move anymore with the bones?

You can't apply the armature. Armature is part of "deform modifiers", when you apply this modifier the deformation gets permanent, and gets rigid. If you can't roll back (ctrl+Z, backed up file or similar) you will have to rigify your model again.


Apply Opaque blend mode to all object at once

I just learned how to do this when trying to figure out an answer for you. Paste and run the code in the text editor after selecting all the objects you want to change.

import bpy

context = bpy.context

for o in context.selected_objects:

    o.active_material.blend_method = 'OPAQUE'

I made a little add-on to make a helper panel to do this, not very fancy but if it is useful then that is great. https://github.com/artistCDMJ/opacity_helper/archive/master.zip


How to make use of custom external Python modules in Blender or an add-on on Linux

update
I found out that the user-configuration folder for Blender, in ~/.config/blender/<version>/scripts/, though only containing   an addons folder by default, can have also a modules and a startup folder. If packages are pip-installed in the modules folder, they are visible from Blender, so, no custom virtualenv, or custom path manipulation at runtime is needed.

In other words, in a modern Linux, to have a Python package available for my user visible in Python's blender, I can do:

mkdir ~/.config/blender/2.79/scripts/modules
pip install -t ~/.config/blender/2.79/scripts/modules <python-package>

On Windows, the scripts folder for Blender will have a modules folder that can be used in the same way, as per the answers in the similar question here: Using 3rd party Python modules

previous answer

What I did do is a small Python function that is run prior to other imports in the add-on .py file to introspect the system Path and add any active virtualenv's to the Python import directory list sys.path.

The final function I came up with may be robust enough to help others. I add this to the beggining of my .py add-ons:

def fix_path():
    """Enable 3rd party Python modules installed in an
    active Virtualenv when Python is run.
    (Blender ignores the virtualenv, and uses a
    Python binary hardcoded in the build. This works
    if the virtualenv's Python is the same as blenders')
    """

    import sys, os
    from pathlib import Path

    pyversion_path = f"python{sys.version_info.major}.{sys.version_info.minor}"

    for pathcomp in os.environ["PATH"].split(os.pathsep)[::-1]:
        p = Path(pathcomp)
        if p.name != "bin":
            continue
        lib_path = p.parent / "lib" / pyversion_path / "site-packages"
        if not lib_path.exists():
            continue
        if str(lib_path) in sys.path:
            continue
        sys.path.insert(0, str(lib_path))

        print(f"{__name__} Add-on: prepended {lib_path!r} to PYTHONPATH")

fix_path()

(import statements follow)


Cannot render from CLI: wm_main_playanim_intern: no filepath argument given

Your command should be:
blender -b '/home/lxif/VFX/OZELOT/vfx clip/VFX/scenes/TREES _ FLOOR/FLOOR_2.blend' -a

You missed the -b option, that tells blender to batch render.
https://docs.blender.org/manual/en/latest/advanced/command_line/render.html


You have to unparent the IK bone from the rest of the rig. Once you have the bone selected in edit mode go to the armature settings and at the top of that menu there's the parent options choose 'clear parent'. That should fix it.


There is a vertex mishmash. Press M to Merge by Distance with value like 0,001

I did some more manual cleaning (Merge by Last to merge some others vertices that were close to each other) and Slide by Edge GG to straight back some edges of cylinder part.

To keep straight cut in some axis I would suggest to use Mirror modifier and as final touch apply Solidify and Mirror and use Bisect tool to cut.
Topology is not good, so if you will have more issues, you would have to retopology your object anyway.


Fingers on hand rig deform until I try to move them

You have dependency cycles in your rig. Running the file with blender --enable-new-depsgraph SimplifiedBlend.blend shows this on the console:

Read blend: /home/sybren/Downloads/SimplifiedBlend.blend
Dependency cycle detected:
  'OBLArm.POSE_INIT()' depends on 'OBLIndex.lindex.BONE_DONE()' through 'IK'
  'OBLIndex.lindex.BONE_DONE()' depends on 'OBLIndex.lindex.BONE_READY()' through 'Ready -> Done'
  'OBLIndex.lindex.BONE_READY()' depends on 'OBLIndex.lindex.BONE_CONSTRAINTS()' through 'Constraints -> Ready'
  'OBLIndex.lindex.BONE_CONSTRAINTS()' depends on 'OBLArm.LArm_Fore.BONE_DONE()' through 'Child Of'
  'OBLArm.LArm_Fore.BONE_DONE()' depends on 'OBLArm.POSE_IK_SOLVER()' through 'IK Solver Result'
  'OBLArm.POSE_IK_SOLVER()' depends on 'OBLArm.POSE_INIT_IK()' through 'Init IK -> IK Solver'
  'OBLArm.POSE_INIT_IK()' depends on 'OBLArm.POSE_INIT()' through 'Pose Init -> Pose Init IK'
Dependency cycle detected:
  'OBLRing.lring.BONE_CONSTRAINTS()' depends on 'OBLArm.LArm_Ring_1.BONE_DONE()' through 'Child Of'
  'OBLArm.LArm_Ring_1.BONE_DONE()' depends on 'OBLArm.LArm_Ring_1.BONE_READY()' through 'Ready -> Done'
  'OBLArm.LArm_Ring_1.BONE_READY()' depends on 'OBLArm.LArm_Ring_1.BONE_POSE_PARENT()' through 'Pose -> Ready'
  'OBLArm.LArm_Ring_1.BONE_POSE_PARENT()' depends on 'OBLArm.LArm_Fore.BONE_DONE()' through '[Parent Bone -> Child Bone]'
  'OBLArm.LArm_Fore.BONE_DONE()' depends on 'OBLArm.POSE_IK_SOLVER()' through 'IK Solver Result'
  'OBLArm.POSE_IK_SOLVER()' depends on 'OBLArm.POSE_INIT_IK()' through 'Init IK -> IK Solver'
  'OBLArm.POSE_INIT_IK()' depends on 'OBLArm.POSE_INIT()' through 'Pose Init -> Pose Init IK'
  'OBLArm.POSE_INIT()' depends on 'OBLRing.lring.BONE_DONE()' through 'IK'
  'OBLRing.lring.BONE_DONE()' depends on 'OBLRing.lring.BONE_READY()' through 'Ready -> Done'
  'OBLRing.lring.BONE_READY()' depends on 'OBLRing.lring.BONE_CONSTRAINTS()' through 'Constraints -> Ready'
Dependency cycle detected:
  'OBLArm.POSE_INIT()' depends on 'OBLMid.lmid.BONE_DONE()' through 'IK'
  'OBLMid.lmid.BONE_DONE()' depends on 'OBLMid.lmid.BONE_READY()' through 'Ready -> Done'
  'OBLMid.lmid.BONE_READY()' depends on 'OBLMid.lmid.BONE_CONSTRAINTS()' through 'Constraints -> Ready'
  'OBLMid.lmid.BONE_CONSTRAINTS()' depends on 'OBLArm.LArm_Index_1.BONE_DONE()' through 'Child Of'
  'OBLArm.LArm_Index_1.BONE_DONE()' depends on 'OBLArm.LArm_Index_1.BONE_READY()' through 'Ready -> Done'
  'OBLArm.LArm_Index_1.BONE_READY()' depends on 'OBLArm.LArm_Index_1.BONE_POSE_PARENT()' through 'Pose -> Ready'
  'OBLArm.LArm_Index_1.BONE_POSE_PARENT()' depends on 'OBLArm.LArm_Fore.BONE_DONE()' through '[Parent Bone -> Child Bone]'
  'OBLArm.LArm_Fore.BONE_DONE()' depends on 'OBLArm.POSE_IK_SOLVER()' through 'IK Solver Result'
  'OBLArm.POSE_IK_SOLVER()' depends on 'OBLArm.POSE_INIT_IK()' through 'Init IK -> IK Solver'
  'OBLArm.POSE_INIT_IK()' depends on 'OBLArm.POSE_INIT()' through 'Pose Init -> Pose Init IK'
Dependency cycle detected:
  'OBLArm.POSE_INIT()' depends on 'OBLThumb.lthumb.BONE_DONE()' through 'IK'
  'OBLThumb.lthumb.BONE_DONE()' depends on 'OBLThumb.lthumb.BONE_READY()' through 'Ready -> Done'
  'OBLThumb.lthumb.BONE_READY()' depends on 'OBLThumb.lthumb.BONE_CONSTRAINTS()' through 'Constraints -> Ready'
  'OBLThumb.lthumb.BONE_CONSTRAINTS()' depends on 'OBLArm.LArm_Fore.BONE_DONE()' through 'Child Of'
  'OBLArm.LArm_Fore.BONE_DONE()' depends on 'OBLArm.POSE_IK_SOLVER()' through 'IK Solver Result'
  'OBLArm.POSE_IK_SOLVER()' depends on 'OBLArm.POSE_INIT_IK()' through 'Init IK -> IK Solver'
  'OBLArm.POSE_INIT_IK()' depends on 'OBLArm.POSE_INIT()' through 'Pose Init -> Pose Init IK'
Dependency cycle detected:
  'OBLArm.POSE_INIT()' depends on 'OBLLittle.llittle.BONE_DONE()' through 'IK'
  'OBLLittle.llittle.BONE_DONE()' depends on 'OBLLittle.llittle.BONE_READY()' through 'Ready -> Done'
  'OBLLittle.llittle.BONE_READY()' depends on 'OBLLittle.llittle.BONE_CONSTRAINTS()' through 'Constraints -> Ready'
  'OBLLittle.llittle.BONE_CONSTRAINTS()' depends on 'OBLArm.LArm_Fore.BONE_DONE()' through 'Child Of'
  'OBLArm.LArm_Fore.BONE_DONE()' depends on 'OBLArm.POSE_IK_SOLVER()' through 'IK Solver Result'
  'OBLArm.POSE_IK_SOLVER()' depends on 'OBLArm.POSE_INIT_IK()' through 'Init IK -> IK Solver'
  'OBLArm.POSE_INIT_IK()' depends on 'OBLArm.POSE_INIT()' through 'Pose Init -> Pose Init IK'

Circular dependencies can cause all kinds of nasty things, so it's better to clean them up. You also always want to enable the new dependency graph  with --enable-new-depsgraph unless you have a strong reason not to. It allows for more granular control, allowing for more complex rigs without resulting in dependency cycles.

To use custom bone shapes, use actual custom bone shapes, instead of trying to incorporate other objects into your rig.


Ideas on covering a whole mesh with (irregular) tiles, following the shape of the mesh?

Two possible options:

use the Tissue addon in tesselate mode.  http://www.co-de-it.com/wordpress/code/blender-tissue

Tessellate tool allows the user to copy a selected object (Component) on the faces of the active object (Generator), adapting its bounding box to the shape of quad-faces. Once the Tessellate button was pressed, then more options will appear in the Operator parameters. Update allows you to update the active the Tessellated mesh according to Component and Generator changes. You can also change the parameters of tessellation.

use Instancing. In the shape of the ship select instancing faces:

Then select the tile, shift select the ship (so that both objects are selected but the spaceship is active) and press Ctrl+ P. Select "Parent to Object". The tile object shold become a space ship made of tiles.


Is there way to access animation-nodes attribute in object-material with OSL script?

I don't think Blender allows such use of properties, see Add custom object properties as usable attributes. For alternative methods. See the Coloring Objects section of this answer.


I am assuming both UV maps are associated with the object?  You can create duplicates of all of your materials.  One material, let's call it A, will use UV map A; material B will use UV map B.  They will otherwise be identical.  You can set the UV map for the material using the "UV Map" input node.

You then need to define which vertices/faces are associated with each UV map.  I suggest using vertex groups to do this.  So you'll have vertex group A and group B.

Finally, you need to assign the right materials to the right vertices.  In edit mode, use your vertex group A to select all of the A vertices.  Then go to the material tab, select your material A in the slot list, and click "Assign."  Do the same for vertex group B/material B.

You'll need to repeat this process for each base material used by your object.


It looks like you have overlapping geometry - where you have two or more faces overlaying each other. This can have the effect of such artifacts. Try editing your model in wireframe mode (press 'Z' to toggle between wireframe and solid 3d view) and check that you don't have overlapping faces.


How disable delete options menu in Blender 2.8?

There is an option for this in Blender 2.80.

Open "User Preferences" then go to "Keymap" and search for "Delete" and go down to Object Mode -> Delete (object.delete) click the dropdown arrow and check/uncheck 'Confirm'

You can also get there by "Keymap -> 3D View -> Object Mode -> Object Mode (Global) -> "Delete (object.delete)" and check/uncheck confirm


Custom pie menu: shift in my hotkeys toggles multiselection mode between vertex edge and faces, how to toggle off previous mode?

import bpy
from bpy.types import Menu

class VIEW3D_MT_PIE_select_mode(Menu):
    bl_label = "Select Mode"

    def draw(self, context):
        layout = self.layout
        pie = layout.menu_pie()
        o = pie.operator("mesh.select_mode", text="Vertex", icon='VERTEXSEL')
        o.type = 'VERT'
        o.use_extend=False
        o.use_expand=False
        o.action='ENABLE'
        o = pie.operator("mesh.select_mode", text="Edge", icon='EDGESEL')
        o.type = 'EDGE'
        o.use_extend=False
        o.use_expand=False
        o.action='ENABLE'
        o = pie.operator("mesh.select_mode", text="Face", icon='FACESEL')
        o.type = 'FACE'
        o.use_extend=False
        o.use_expand=False
        o.action='ENABLE'
        o = pie.operator("mesh.select_all", text="Select All/None", icon='RESTRICT_SELECT_OFF')
        o.action = 'TOGGLE'

addon_keymaps = []

def registerKeymaps():
    wm = bpy.context.window_manager
    if wm.keyconfigs.addon:
        km = wm.keyconfigs.addon.keymaps.new(name='3D View', space_type='VIEW_3D')
        kmi = km.keymap_items.new('wm.call_menu_pie', 'LEFTMOUSE', 'CLICK_DRAG', shift=True, alt=False,ctrl=False)
        kmi.properties.name="VIEW3D_MT_PIE_select_mode"
        addon_keymaps.append((km, kmi))

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

def register():
    bpy.utils.register_class(VIEW3D_MT_PIE_select_mode)
    registerKeymaps()

def unregister():
    unregisterKeymaps()
    bpy.utils.unregister_class(VIEW3D_MT_PIE_select_mode)

if __name__ == "__main__":
    register()

    #bpy.ops.wm.call_menu_pie(name="VIEW3D_MT_PIE_select_mode")

This would work. But I strongly recommend not to use this since it will mess things up a lot. Shift + Left Click is used a lot in the keymap and it's not a good idea to replace it. It will make things inconsistent and I think you will likely regret it later if you get used to it doing something else in the viewport. Keys 1, 2 and 3 for mode selection are not that difficult to get used to, you should just suffer for a few days and get over it.


You need to install nvidia-cuda-toolkit because blender uses this toolkit in order to drive your nvidia card.

apt-get install nvidia-cuda-toolkit

You should also make sure that your nvidia card is cuda compatible.

blender docs related to GPU.

list of nvidia graphics cards compatible with CUDA


How to rig a shirt with buttons so that the buttons follow the mesh of the shirt

You may do it using vertex and object parenting.

Select the vertex where you want to place the button and snap the cursor to it. In Object Mode add an Empty there.

Now select the Empty, then the mesh and enter Edit Mode. Select three vertices around the button and press Ctrl+P-->Make Vertex Parent. Finally parent the button object to an Empty. (Ctrl+P-->Object (Keep Transform)).


This is not possible in Blender. Blender's API is build on defining exactly what type is in a collection. It is not possible to add other types (even if they are subtypes) to that collection.

The reason for this that blender does not store the type of the item with the item. It always uses the class that has been given by the type parameter of the CollectionProperty as the class. If your addon will rename your class Blender will still be able to fill the list as it is defined by the CollectionProperty.

Best way to solve this is to do the reverse and add use a 'type' enum to your PropertyComponent. I assume that your type was already created for this.

class Property_Component_Water(object):
    wave_height = bpy.props.StringProperty(...)
    color = bpy.props.FloatProperty(...)

class Property_Component_Terrain(object):
    max_height = bpy.props.FloatProperty(...)

class Property_Component(bpy.types.PropertyGroup, Property_Component_Water, Property_Component_Terrain):
    type = bpy.props.EnumProperty(items=component_types_array)

class Property_ComponentList(bpy.types.PropertyGroup):
    components = bpy.props.CollectionProperty(type=Property_Component)

Note: You need to be aware of not redefining attributes with the same name multiple times.


Export rendered image corners coordinates

This is how to get camera corners 3D positions:

import bpy

cam = bpy.context.scene.camera
frame_local = cam.data.view_frame(bpy.context.scene)

# Its in local space so transform to global
frame_global = [cam.matrix_world * corner for corner in frame_local]

# Output to System console
locations = ["TopRight   ", "BottomRight", "BottomLeft ", "TopLeft    "]
for location, corner in zip(locations, frame_global):
    print("corner {0}: {1}".format(location, corner))

Here you can find more that might interest you:

Casting rays into the scene for each pixel


This problem can be solved by tweaking the primary and secondary bone axis in the armature tab when importing. (In case of a .fbx)


Subdividing mesh to get equal vertex density in all direction

Use the 'ReMesh' modifier on 'Sharp' mode and adjust the Octree depth to match the desired resolution.


Apply static bump map to normals in Blender 2.82

OBJ exporter is very basic. It's a format optimized for readability and compatibility. I don't think the Blender exporter checks for bump maps, it's fairly basic. In my test it did look for the diffuse map, but it mapped it like this: (inside the .mtl file) map_Kd G:\Libraries\Textures\CIMG2124.JPG So if we copied  it to your machine, the link would break. If at all possible, use .fbx, it's more versatile and better maintained.
Bump maps can't be "applied", every ray hitting your surface will take the normal map into account, meaning calculating its effects in realtime. The trick is to add detail without geometry. To bake the bump map, to your mesh (the opposite of what bump maps are for) you'd have to add tons of vertices. It does not modify the normals, it adds to the direction of the ray that's being reflected, depending on the pixel's color.


How can i create a piece of ground on a cylinder like the one on the picture without having random things happening on the sides?

The following two methods might help to fix your problem:
Method 1
Scale down a cylinder to be the size of your current mesh. After that go in Edit Mode, select all of your mesh by pressing A, and then Subdivide. Set the number of cuts to three. Once that is done, add a Subdivision Surface Modifier and set it to 2 or 3 (Don't forget to add Loop Cuts on the top and bottom of the mesh by hitting Ctrl+R and then dragging. Otherwise you will get a very round mesh) If you are in cycles you can set the feature set to experimental and enable adaptive subdivision in the Subdivision Surface modifier and then in the material properties go to Settings and then set bump only to displacement and bump to save render times.
Then give that cylinder the same material you gave to your current mesh.
Method 2
If you want your current mesh to have the material, then your problem is that your UV's are stretched. Make sure you have given seams on the right places. To make sure there is no stretch, go to the UV Editing Workspace and in Edit Mode select your entire mesh. Then on the side panel on the left, go to Overlays and press display stretch (The colours any other than almost dark blue like cyan or green mean there is stretch).

If there is any stretching, you will have to first go to Object Mode and then press Ctrl+A and click Apply Scale. Come back to Edit Mode, then select your entire mesh and press U > Unwrap. If the stretching is still visible you would have to add more seams at the right place and then hit U > Unwrap again.


Texture paint does not render in cycles or is very light

I believe the Material Preview mode will show you the "pure" image texture without performing the full shader material computing.

On that note, I notice that you are trying to mix the image texture which seems already quite subtle in variations, with a similar color (the one on the bottom input on the Mix node) using the noise texture. It does not seem surprising that the final render result is very faint.

Try a more vibrant color in the mix node to see the difference. Also, a good practice is to use a Color Ramp on the output of the Noise texture to control the  contrast (moving controls left and right.)


How come reflections are still visible using 0 bounces?

Light paths inherit the proprety after the first bounce
Short answer is that the bounces number is not referring to the occoured light bounces but only to the "diffuse/glossy/transparency reflection  bounces" as said in the tooltips:

The manual define the light paths as the following:

Reflection and transmission rays can further have these properties:

Diffuse: the ray is generated by a diffuse reflection or transmission
(translucency).
Glossy: the ray is generated by a glossy specular reflection or transmission.

Imagine the following situation (path tracing actually works the other way around, but let's forget that for a moment):
The photon is emitted by light source, notice that at this moment the ray associated with the photon is "neutral", it hasn't hit any surface so it can't be defined as "diffuse" or "glossy", it's just a ray.
Now the photon hits a surface. If the surface is diffusive it generate a Diffuse ray, if it's reflective it generate a Glossy ray. Now, if the Diffuse/Glossy ray is captured from the camera, how times the Diffuse/Glossy ray bounced?
None. It has just been generated. It is visible by the camera, but has bounced none.
The question those numbers are answering can be better phrased as:

How many times are the Diffuse rays allowed to bounce in my scene?

If you picture yourself that the Diffuse rays are the little arrows and not the long one, you'll have an easier time in understanding the values.

Disclaimer: I dunno if it's the whole truth, but it makes sense and I thought it whort sharing my point of view


You can use curves, give them some extrusion and an emissive material. Then animate the bevel start and end factors, like in these links:
How to create light streaks
How to make an object appear/visible along a path
The main problem you will face is that you need to separate the curves created by OpenStreetMap or create new ones. OSM creates multiple segments on a single curve object and that would not work for animating Bevels.


Selecting all objects that have been specified in Modifiers

Using the bl_rna.properties collection.  This gives the name, type and other properties of the properties of the modifier. If the property is an object it is most likely, both a PointerProperty (prop.type == 'POINTER') and points to a prop.fixed_type of bpy.types.Object.  If so getattr(modifier, propertyname) will be either the object if set, or None if not.
import bpy
context = bpy.context
obj = context.object
for m in obj.modifiers:
    print("modifier (%s): %s" % (m.type, m.name))
    for k, v in m.bl_rna.properties.items():
        if v.type == 'POINTER' and v.fixed_type.name == "Object":
            print("\t", k, getattr(m, k))
            # select mod obj if not None
            ob = getattr(m, k, None)
            if ob is not None:
                ob.select_set(True)


You need to allow Blender to use your graphics card.

Go to Edit->Preferences->System and select the card you want to use.
If there’s nothing there, you don’t have a compatible graphics card.
No worries, CPU rendering works too.

Happy Blendering.


Adding rivets to an object for 3D printing

You could model this, if you're starting with  a topology something like the  one illustrated here:

With Pivot set to 'Individual Origins'

CtrlR add three edge-loops
AltP poke the two middle face-rings
Select a couple of consecutive rivet-vertices (not necessarily just one apart)  on the central loop - use CtrlShiftNumpad+ to select the rest, and then CtrlShiftB bevel those vertices, in 'Offset' mode
Space .. look up the 'Circle' operator, and use it on your newly created faces. (They should still be selected)
perform whichever series of insets, extrudes, and scales create the kind of rivets you want.

I don't know whether you're sub-d modelling, but this is the result after putting on a level of subdivision.

You could use the Loop Tools add-on > 'Space' option at the vertex stage, in various ways, if you want to improve the distribution of rivets.

Although the result is not all quads (before subdivision), it's in the flat, for printing, and is not expected to deform, so that's probably OK?


Blender wireframe without backface issues

For Eevee:
Your node setup is perfect. Make sure to go to material settings and tick "Backface Culling". And right below that check box is Blend Mode. For Eevee transparency to work, you must change Blend Mode from "Opaque" to "Alpha Blend" or something else.

If you want to do this in Cycles, you will need this setup:


How do I gently bend 4 bottle sides inward simultaneously to create a uniform dent?

May I suggest a Lattice?

Create a Lattice object, and link it to the bottle with a Lattice modifier on the bottle object. Set the Lattice object to an acceptable resolution, and in Edit mode, move some lattice vertices closer to the center with the Scale transform tool. The deformation depends on the subdivision of the lattice and the selection of vertices. Experiment until you find the correct values for your situation.


Only one Sculpt mode brush isn't working

I opened 2 instances of Blender, in one of them I hit in the

File>Load Factory Settings

I used the other opened Blender to copy settings and layouts and all the user preferences.

I was hoping for something less drastic but it doesn't seem to be another solution.


You may do it using a cloth simulation, a little bit of sculpting and shape keys.

Select your chocolate bar, apply the transformations to it (Ctrl+A-->Rot&Scale), go to the Physics header and press the Cloth button. Play with the settings in a Cloth panel.

Select the plane, apply the transformations to it as above and press the Collision button (remember to place the bar a little bit above it).

Select the bar and press Alt+A. Wait for the simulation to be finished, then go to the last frame (Shift+Right Arrow). Go to the Modifiers header and press the Apply as Shape Key button in the Cloth Modifier window. Now you have a new shape key in the mesh data header.

Now with a Cloth shape key selected enable the Sculpt Mode. Use the Clay brush to reduce the mesh distortion and the Grab brush to shape the melted chocolate bar.

Use the Smooth brush to make the edges smoother. Press I over the shape key value to keyframe it. Go to the next frame on the Timeline, change the shape key's value and keyframe it again.


Can I change the color of the last selected face?

Yes.

In CtrlAltU> User preferences > Themes > 3D view:

The Face Selected color controls the color of the selected face
The Active Vert/Edge/Face color controls the color of the last selected face.

However, I wouldn't recommend making these colors too similar, as there are differences between the selected faces and the last selected face (active) and it might be confusing if you can't tell if a face is active or selected.

Reducing the alpha can help smooth it a little.
Comparison of default setting and with it set to the same color as selected faces:

Note that this value also affects active vertices and edges as well as faces.


Set up blender for printing/rendering to A4, A3, A2, A1, A0 paper sizes

http://www.papersizes.org/a-paper-sizes.htm

Simple math:

1.) Get paper size from link above... e.g. A4 = 8.27" x 11.7"

2.) Multiply the dimensions by 300... e.g. A4 = 2481 x 3510

3.) Plug values into the Properties >> Dimensions >> Resolution and set scale to 100%

NOTE: You will need a printer that is capable of edge to edge printing.


I cannot import or export anything in Blender. It throws

Blender is definately running its own version of python, which is python 3.
You get that error message because your "Blender Python" is trying to import reprlib and it should find that file in the Blender python directory, which in your case is "F:\Steam\steamapps\common\Blender\2.79\python\lib\reprlib.py". Make sure this file exists.

For some reason your Blender Python doesn't find that file and looks elsewhere. You might have misconfigured your Scripts directory in Blender. Check you preferences, they should look like this:

Uninstalling and reinstalling probably didn't help because the preferences will not be deleted as they are stored in you application data directory.

If that's not the problem, then there is probably something wrong with your environment variables for python. Check your environment variables as described in this link:
https://www.katsbits.com/tutorials/blender/pythonpath.php


Modelling plane with irregular corner radius - how to model this shape?

Here is a way to do it, tell me if it's ok:


It looks like your particles are getting a little normal velocity (i.e. being "pushed" off the emitter's surface).  You need to turn down the Normal value under the Velocity rollout of the particle settings.

Set this value to 0.000 and your particles shouldn't move.


Objects/textures not showing when using command line render (Blender 2.5x)

The problem was that I created the scenes using blender 2.66, but invoked Blender 2.58 on the command line; there are backwards compatibility issues involved here although I forgot exactly what it was (something to do with ngons I believe). Regardless the end result is that precious few object types created in 2.66 will load in 2.58 so the real surprise here was that anything was displayed at all.

Thanks for everybody who kindly tried helping with this. Took me a while to track the issue as I usually need to keep several versions of blender installed so I guess this 'issue' wouldn't affect many people.


When I bake this from the provided blend file, it works.  As such this doesn't directly answer the question, but it's too large for a comment and might be helpful so I will post it anyway - if a proper "here's what you did wrong and here's how to fix it" answer shows up and this no longer seems useful please feel free to delete it.
Here are the steps I took from loading the blend file to having a baked output png saved and the chameleon displaying properly in cycles mode using the texture rather than the nodes:

In the node view of the 'Procedural' material, add a texture setup to receive the bake.  This texture is blank, and in this case is a 1024x1024 black png file which I saved to disk so it existed (blender is sometimes a bit weird about having its files exist before writing to them, also, cycles seems to render from-file rather than from-memory).  It's fine that this isn't connected to anything at this stage

Select the texture node.  Just click on it so the BakedOutput node has a white outline.  This step is important because otherwise it might put the bake somewhere else - probably on top of the chameleon skin texture or something equally unhelpful.

Change the render engine to Cycles.

Set up for diffuse color baking with no lighting information.  I used these settings:

Press Bake, and wait for it to complete

Save the resulting BakedOutput.png or whatever else you have called it.  First because it's good practice and it's easy to lose the bake if you don't, but also, perhaps more importantly, because as mentioned Cycles likes to render with the black blank texture if that's what's on disk.

Attach the texture node to the Color input in the Procedural material to check it works - you may wish to use the texture elsewhere instead, and preserve the Procedural material and just switch to the new one, but I didn't do that, I just swapped the Color input to be faster and more sure it would work.  Screenshot shows disconnected procedural result and connected texture node:

As to what you did that caused your issue I am unsure.  I cannot seem to reproduce it - even baking with lighting information included just produces a badly lit output, rather than the mis-arranged image with the wrong parts mapped shown in the question.  I attempted baking with incorrect texture coordinates but that didn't seem to do it either.  There's only one UVMap provided so I couldn't bake using the wrong one of those... I'm not sure if I can answer the question, so feel free to ignore this answer if it isn't helpful.  Perhaps try recording your own steps and then following mine and see if we get the same result.
I -did- notice that the bake is different (and worse looking, much further away from original procedural output) baked from Edit mode instead of Object mode.  I suspect this might have something to do with it, but it still doesn't match your original image.  Perhaps the pose or armature is involved.


Everything turns black in Netrender mode

If you change your render engine from Cycles to Network render, make sure you specify what render engine you would like to use in the network render settings.

The Blackness may be becase you used the blender internal render engine to render the scene. Since cycle nodes get ignored by this engine its not working properly. -> everything may be black. Because there may be no light.


You could merge the vertices by invoking the Remove Doubles operator

In your case you could create the torus without duplicated vertices, starting with an e.g. an 1/8th

By rotating using the
Spin Tool  Alt-R in Edit Mode


two textures: painting on one of them while the other is still visible (2.8)

Have you tried to turn off overlays in LookDev mode?


How to get a MovieClipSequence Clip File via Python

The active 'clip name' is the only real reference at the moment so avoid 'renaming' in VSE:

import bpy

seq = bpy.data.scenes['Scene'].sequence_editor
strip_name = seq.active_strip.name

print (bpy.data.movieclips[strip_name].filepath)

Console output: /home/user/videos/file_name.mp4

Otherwise (although not ideal) you could iterate through bpy.data.movieclips and compare the duration of the 'active strip' with 'all other' clips:

import bpy

seq = bpy.data.scenes['Scene'].sequence_editor
strip = seq.active_strip
strip_duration = strip.frame_duration

for i in bpy.data.movieclips:
    if (i.frame_duration == strip_duration):
        print (i.filepath)


Blender python math operations on vertex

When you initialize total_points outside the loop it should work

import mathutils
..
..
total_points = mathutils.Vector((0,0,0))

for vert in verts_in_face:
    local_point = current_obj.data.vertices[vert].co
    total_points = total_points + local_point

For all available vector operations you can lookup the mathutils docs


How to merge or move two vertices without affecting the others?

As I see, you are using Ctrl + mouse click instead Shift + mouse click  for selecting multiple vertexes.  Ctrl + mouse click is a Pick Shortest Path function and select road from vertex to vertex.

To add vertex to selection use Shift + mouse click


your example can be implemented as in the following driver :

but for more complex drivers refer to this DOC page , the important part is that you can define your function and add it to driver namespace as in this example :

import bpy

def driverFunc(val):

    return val * val    # return val squared

bpy.app.driver_namespace['driverFunc'] = driverFunc    # add function to driver_namespace

now you can use it the driver scripted expression


When you use the ivory addon, it actually unwraps all of the leaves over another, so you dont need to unwrap unless you aim to export the mesh.


A landscape mesh can be simplified, while retaining most of the shape, using a combination of tools.

The decimate modifier using the planar option
Triangulating the mesh in the edit mode

Example:
This is a mesh for a portion of Bryce Canyon formed from a quad mesh. It has about 21,000 vertices.

Applying the decimate modifier with the planar option selected and 3degrees, then applying removes about 1/2 of the vertices, leaving about 13,000 vertices.

After applying the modifier and entering edit mode, the resulting mesh has the flat regions automatically merged. A final step is to triangulate the mesh in edit mode.

Note, there are other tools in edit mode that can help simplify the mesh:

Select > Sharp Edges to select edges with high angles
Mesh > Clean Up > Limited Dissolve to eliminate edges with low angles
Mesh > Clean Up > Degenerate Dissolve to eliminate long skinny facets


Understanding Fluid dynamics - ridiculously large tmp folder

Cache size

Fluid cashes are BIG. Blender must store the entire mesh (which is considerably dense at higher resolutions) for every frame.

If your fluid mesh comes out to an average of say 500K verts, well, you've seen for yourself what happens when you need to store 1000 versions of a mesh of that density.
 It only gets worse if you want to store additional data such as velocity vectors.

Instead of putting all of it in /tmp you probably want to configure this to go somewhere else by setting the path in Properties > Physics > Fluid:

Simulation time

The way blender's current fluid simulator works with time is rather confusing.

Based on my tests, it seems the fluid simulation always goes from frame 0 to the scene end frame (set in the timeline or in Properties > Render > Dimensions > Frame Range)

The start and end time settings in the fluid panel influence the speed of the simulation. If you want the fluid to move in "real time", you'll have to manually calculate how long the range from frame 0 to the scene end frame is in seconds, at the desired framerate (you can change the scene framerate in Properties > Render > Dimensions).
For 251 frames (counting from 0) at 24 frames/second, that works out to 251/24 ≅ 10.46. So, set the start time to 0 and the end time to 10.46.

Setting the start time to something other than 0 simulates up to that point, but discards prior frames and sets the fluid frame at that time to the scene frame 0. In other words, with a start time of 1 the simulation will appear to "start" one second in, but in order to do this the previous second must still be simulated behind the scenes.

All of this is made even sillier by the fact that you can also adjust the speed of the simulation much more easily with the fluid speed factor, just below the start and end time settings.

This is admittedly a spectacularly messy example of one of the darker sides of Blender's UI. The good news is that the current (ancient) fluid simulator is being replaced in one of the upcoming GSoC 2016 projects (hopefully the UI will be going too).


Is there a way to use a WORLD MATERIAL for lighting, and have another WORLD MATERIAL for visuals?

You can achieve this by mixing your 2 backgrounds (lighting and visuals) using the "Is Camera Ray" output of a Light Path Node. For your situation, plug the same image into both backgrounds, and alter the individual strengths of the Background Nodes (Hard to show what it's doing in an image, so I used red as one background instead for the example):

Though it's really hard to tell what the lighting's supposed to look like, I did my best to show which one is too bright and which one is too dark (for the example). Regardless, your setup should look something like this. Adjust the respective strengths to your liking:


Rigid body animation problems (coin pusher animation)

I've only done 4 coins here.  See if these physics settings work for you.
You can see those in the Blend file below.
Make sure to check those for the slide and pusher also.

You'll notice that all coins have much the same settings, except Coin 1. (leftmost)   Varying those on individual coins will obviously affect their behavior and can be used to break up their similarity if felt necessary.
e.g. Coin 1's "Rotation Damping" is wound down to zero at frame 1 and stays that way to help it flip over when it falls. Once it has rolled over, the value is rapidly increased (keyframed) to 1.00 to settle it down.
There's not a lot more to tell you, except perhaps the significance of the coins' "Shape" being set to 'Cylinder' instead of mesh.  This improved coin-like behavior.
The  "Collision Margin" was set to 0.002 but with it shaded out, I don't think it matters.


Rigid Body Physics: Having multiple rigid body worlds

No, the manual does not say that you can have multiple rigid body worlds. What they mean is that you can have multiple groups that can be selected in the "Rigid Body World" panel. The name of the default group is "RigidBodyWorld", which makes things a bit confusing. I explained these concepts in more detail in my answer to this question: Rigid Body World (Groups) Explained

At a given time (and within a given scene) you can have only one rigid body simulation.

A workaround could be to use multiple scenes (each scene can have its own "Rigid Body World" settings), and composite the results together.


I somehow made edit/object mode monochrome. How do I revert to default render settings?

I don't know if this is what you mean but you are in Texture display mode...see that little red and white checked ball to the right of the "Object Mode" dropdown?  Just hit 'Z' once to go to wireframe, or twice to go to Solid display mode...or click on that ball to choose a different rendering mode.  You probably hit Alt-Z instead of Ctrl-Z.


How to do a simulation of still water being affected instead of flowing water

You can use an Object set to a Flow Behavior of Geometry to convert any part of the mesh that intersects with your domain to liquid particles.  You'd just have to allow a limited amount of time to settle and keyframe the visibility of the object.

Particle sims, and particularly this process, seem pretty finicky right now.  I had to go back and change the number of divisions on my domain to sort of "refresh" the sim and update the size and positions of my emitters.  Just a heads up.


Even though the examples linked are to keyframe an object, there is in fact no difference and the same methods apply to both.

Simple:

scene = bpy.context.scene
scene.keyframe_insert(data_path="gravity", frame=10.0)

Advanced:

scene = bpy.context.scene
if not scene.animation_data:
    scene.animation_data_create()
if not scene.animation_data.action:
    scene.animation_data.action = bpy.data.actions.new("GravityAction")

fcurve = None
for fcurve in scene.animation_data.action.fcurves:
    if fcurve.data_path == "gravity":
        break
if not fcurve or fcurve.data_path != "gravity":
    fcurve = scene.animation_data.action.fcurves.new("gravity")
keyframe = fcurve.keyframe_points.insert(frame=10.0, value=20.0)
keyframe.interpolation = "LINEAR"
#keyframe.handle_left
#keyframe.handle_right


I know you probably know the answer already since this was at May 15th.. But anyway.

The IK should not have any properties. The only ones should have properties with IK's would be the [Lower leg]/[calf] bones and the [lower arm]/[forearm] bones. There are many types of ways to use IK's but you only have them present for the forearm and calf bones. Make sure that they are not parented to the bone that is trying to use its IK. Also under the IK constraint, be sure to have an IK chain length of two. Sometimes you can add the shoulder bone or hips with a three chain but gives odd movements. Also arm IK's also work great with pole bones. Either elbows or knees. I suggest a blender IK rig tutorial.


in the render tab, theres this option, lock interface:

as the description says, it locks your blender when rendering to give more memory
its locked as a default, maybe you accidentaly unchecked it


The curve will make Y "up":

Make sure the wanted top part of the bevel object is oriented to Y with no rotation in object mode.
In your original file, the curve as no width because the bevel object has no size in Y. So all its vertices are along the curve.


Not understanding how message sensor works

Messages

You need to consider the duration and timing of messages.

A message is send between two frames.

Timing:

the first frame it will be send
the following frame it will be received

The duration of a message is .... exactly one frame. A message sensor will receive this message never again (it can receive another message of the same format).

A message is more an event rather than a status.

Your logic: p1de AND p2de expect that a message p1de and a message p2de are received at the same frame.

It does not mean that any of the messages were received in the past.

Solution

The winner is a status. At any moment there is exactly one winner. This status can change.

There are two basic options to do that:

Change on event: The event carries enough information to decide the new winner.
Notification: The object gets notified the winner (might have) changed. The object checks the situation and determines the current winner.

With the first option you need to deal with the situation you might get events that conflict with each other (e.g. you get a message telling the first player wins as well as a message the second player wins). The message recipient has to resolve the conflict.

The second option needs deep knowledge how to determine the winner.

Hint:

Do not combine messages with AND.

It expect both messages to be received at the same time.


Why is my video not YouTube streamable format?

First, videos will only upload as fast as the filesize divided by your Internet connection speed.  There's nothing that will speed that up other than making the filesize smaller or your connection faster.

What Youtube is saying is that your videos will process faster if they're in a streamable format.  MP4 can be a "streamable format" so I believe the problem is that the moov atom is being placed at the end of the filestream.  As far as I know, Blender does not have a "Fast-start" option so Youtube must wait until the entire file has been uploaded before it begins processing the video.  If the moov atom was at the beginning, Youtube would begin processing as soon as the file began uploading.

[Youtube Link]

The solution is either a Blender Add-On that I'm not aware of or simply use third party software to either encode the video or "fix" the file from Blender.  FFmpeg is capable of this.  See: "ffmpeg Using -movflags faststart".

@troy_s highly recommends using Blender to render out to stills and then encode with FFmpeg.  This preserves video quality and can fix some problems that I ran into with gamma/contrast when uploading to Youtube.

As far as only being able to see 720p or lower resolutions, Youtube processes the video file resolution in ascending order, (e.g. 144p is first, 240p second, etc.) so the 1080p option will not show up for at least a minute or so (maybe longer for larger filesizes) and the 1080p option is not available on Internet Explorer... for me it only works on Chrome.


How to change root (first) bone in armature

Just “add bone” from menu to add a new bone that isn’t the child of anything. Then Ctrl+P make it the parent of the existing root and choose “keep offset.” The root is “the bone that has no parent.”


The problem that is happening is that you have scaled it simply by pressing S  .
This is happening because while doing rotation, moving or scaling , blender considers the origin of the object as the pivot point for doing all the manipulations.
If you are wondering how the origin ( the one yellow point shown while selecting an object ) got away from the object's geometry you might have moved the object in the edit mode. Remember that while in edit mode no matter whatever manipulations you do, the origin won't move along with the mesh as in edit mode. To solve your problem you can simply scale it on the y axis by pressingS  + Y .The proper way to do it is by going to object > set origin > origin to geometry and then scale it by just pressing S


You will have to Bake the material before you can use it in unity. Specifically the color data from the material.
Well what pass holds the color data? That depends on how your material is set up. You might have to bake a Diffuse pass, a Glossy pass, or an Emission pass (those are the three most common passes, but there are 11 total passes).

If you are using a Diffused BSDF, Principled BSDF (non metallic),  and Toon BSDF shader then bake a Diffuse pass set to Color.
However the Anisotropic BSDF, Glass BSDF, Glossy BSDF, Hair BSDF, and Velvet BSDF shaders will all output a pure black Diffuse pass. For these you need to bake a Glossy pass set to Color.

If you have an emissive materiel, you will need to use (no surprise here) an Emit pass.

The interesting one is the Principled shader. When set to metallic, it too will be a pure black diffuse pass.

These here are the minimum steps to bake the color of a cycles material to a texture (I'm using a diffuse pass here). You may depending on your UV layout need to create another UV map. Possible to bake texture to new UV map?

With the object in question selected, open the UV/Image Editor and create a new image which will be used to bake to.
In the material nodes add a Image Texture node, select the image you just created and keep it the active node (light yellow outline).
In the Properties Window under the Render tab scroll down to the Bake heading. Change the Bake Type to Diffuse, and choose only the Color pass. Now press the large Bake button.


Refracting and reflecting materials need basically three things to look good:

Proper shape.

Light bounces all around and INSIDE an object. You need to pay attention how every single edge look like - for example just looking at the top edge of your glass I can say you need to give more definition to it. It should be sharper and inflated when compared to the side of a glass.

Also glass surface is never perfect (the only exception would be optical lenses when you are justified to model it as perfectly shaped objects). So what you do is just add a little bit of displacement to the glass, just enough to barely see that distortion effecting reflections and refractions... and you think it's barely visible, just divide it by half and usually that's your sweet spot. Unless of course you are aiming for roughly formed glass.

So first thing - grab a real glass and watch it as close as you can, then recreate every detail you can spot (which usually would be couple more edge loops and that slight displacement).

Proper lighting.

I can't think of a scene (except very very specfic ones) which looks good with one spot lamp. Try three point lighting at least, some high contrast lights or environment based lighting (rich surroundings that reflect and bounce light all around your scene or - which is best to start off - environment hdr light map).

Something to reflect.

Again - hdr map as a lighting source helps here, but if you can build a rich scene that fills the space it would be just as good, if not better. For a quick scene however your best bet would be hdr.

There are some specific shots with bright color and couple white light sources (like catalogue shots for glassware etc.) However those scenes are much harder arrange and they are actually target the synthetic looks of perfect and not very realistic look of clear glass. However if you look closely you still find that those shots still work because of proper setup and contrast.
And when rendering glass objects contast is very important, unless you aim for a milky, rough surface glass - you need very convincing highlights as your starting point and just the right amount of darker contrasting parts that will define your shape.

As an example you could look at these - not perfect or anything, but in the right direction I think:

Single area lightsource:

Two color high contrast light source:


Speed up a multiple video files in a one project

Try grouping all of the clips into a meta-strip with CTRL+G then apply the speed effect to that meta-strip.


Portions of my mesh seem to be locked in place and can't be moved, rotated or scaled. How do I fix this?

Managed to figure out what the problem was. I noticed that when I selected the faces or edges of the 'fixed' portion of my mesh, the transform panel stated that nothing was selected. Eventually I tried unhiding the mesh, which seemed to fix the issue and allowed me to manipulate the rest of the mesh again. Normally when you hide portions of the mesh, they don't appear visually on the screen, so I had not expected that to be the solution when the entire mesh was visible. Rehiding a portion of the mesh properly hides those faces so I have no idea why I could see them in the first place.


How to fix mesh into a more uniform and simple version?

This is called retopologizing, it is something that's necessary for animatable objects or game assets, there are a lot of addons that help with retopologizing, these ease the process, not replace it.

There are some automatic solutions, a free one is Instant Meshes this will require further corrections.

I recommend doing it by hand, enable F2 and Bsurface addons, this can be quite time consuming so you should be happy with your mesh before doing your retopo, always create quads, game engines will always triangulate your model but originally it probably was 95% quads.


If the question is not about mathematical accuracy, that can be done easily with a curve (or some segments), a circular array and a weld modifier, as you mentioned in the question.

Start with a curve circle, in edit mode open it (toggle cyclic) and shift it from the center.
Add an array modifier, with 9 occurrencies, set it to "object" and use an empty as object. Rotate the empty 40 degrees (360 / 9).
Add a weld modifier with a relatively large distance (that makes the next step easier).
Now adjust the "open circle" extremities so that they join.
If you want it in 3d, move the two other vertices up and down.

You can also do something similar starting from a mesh:


You could use a transformation constraint. Where a copy transform constraint always connects the same axis between bones at a fixed ratio, the transformation constraint allows you to mix axes and ratios.

In this example, I have set the X location of the target bone to control the Y scale of the slope bone.

The mapping in the middle is set to have the X axis affect the destinations Y axis.

The minimum location of 1.0 will map to the minimum scale of 0.5 and the maximum location of 4.0 will map to the scale of 2.0. I chose these amounts visually to keep the alignment of the bone over the distance.

That gives the following result, note that enabling the extrapolate option will extend the result past the given limits.

Also note that constraints are really just a visual way of configuring a premade list of drivers, you can configure your own drivers to get more control if you wanted to.


Your question is not clear, you're talking about putting your ice-cream picture in-between the 2 parts but in your screenshot it is on the blue part only. However, what would work in both cases is giving each part its own material, as it is already the case, but reunite the two unwrapped parts, as I've done, and in both the 2 materials, use the same UV (which will be the case by default if you just plug the Texture Coordinate / UV output), then use the picture as an overlay like you've already done for one (with the alpha in the factor). With this nodes organization you will control the position of your ice-cream picture just by moving the UV position in the UV/Image Editor, whether you want it on one part only or in-between. As the UV is common to both materials, what you decide to do with the UV map will impact both the 2 materials.


I would like to know how to use dyntopo with multi-density

1. Avoid going too hi-poly if you don't have to. If you're planning to sculpt at this level of detail on your whole mesh, make sure your computer can keep up. And ask yourself if you really need that much geometry. In my opinion if your wireframe turns black in some spots, that's too many polygons.

You can change these settings to control how fine your sculpt will be. Personally, I find that Constant Detail is easier to manage than Relative Detail.

2. The Smooth operation can help.

Back to basics, just press W in Edit mode and choose Smooth from the Specials Menu. If you Grow Selection (Ctrl+) and repeat, you can smooth over more area in steps.

3. You can always retopo (and usually should retopo after Dyntopo).

Personally, I like to do a Multires retopo to preserve the high level of detail but also be able to still manage the mesh.


How to locate object parts of rigged object visible in camera

Either use an index pass as you suggested, or just mimick one by using an unshaded material with a distinct colour for each body part.

You say you want to do this in Python, but you don't say why or what part of the process you want to automate. If you elaborate in a comment I might be able to give more Python-related info in this answer.


Is there any way to measure angle between edges/faces, or change the angle so that the mesh changes according to the angle we input?

As well as the ruler and protractor option that was added in blender 2.67, you can also display edge length and angles while you are editing.

In 2.80+ you can find the length and angle options in the viewport overlay options menu.

For v2.7x, you can turn on these options under the Mesh Display panel of the properties region - N


How To Delete This Red Box on My Screen?

The red checkered box is a render region.
It's used to render only parts of your screen.
You can clear it with Ctrl+Alt+B
Or through View > View Regions

Read: Render Border's related check boxes - How do they work?


I would use boolean operations to model the curved insets on the gun that you circled:

if you have a solid part of the gun:

Model a second object that is the shape you want your inset to be:

Position your second object to overlap your gun. Then add a boolean modifier set to difference to the gun shape, and select the second object. After hiding the second object, you will easily get a curved inset:


Character model going crazy after parenting

Thanks a lot for this answer! however, how can I correct the parentage?

P.S. I cannot modify it back to high-poly, because older versions of my model are gone. I will try to weight paint now.


Camera renders blurry image in darker part of scene

It seems that your focus point for the camera is attatched to some other object in the scene, so that when you get into the air duct, it is all blurry. There are several ways to fix this, the best one is to add an empty (Shift+A > Empty > Plain Axis). Name it Camera Focus or something descriptive so you can find it easily later.

Now select the camera and go to Camera Settings > Depth of Field and select your empty.

You can now animate the position of the empty, and the camera will automatically focus on that point, so you can have it positioned near where you want to focus while it is still in the room, and then animate it to move into the air duct.

If your preview image is still pixelated like that, try rendering at a higher sample count.


It sounds like you accidentally set the properties window to horizontal aliment. If your properties window looks something like this, that is indeed the problem.

All you have to do to fix it is RMB  in any of the blank area and choose "Vertical."


You may have paused the viewport rendering. Check if the 'pause' button in the viewport menu/header is pressed.


All Objects suddenly invisible in 3D Viewer

I finally figured out: I accidentally pressed Alt+B instead of B for box select, which enabled view clipping.
This way only the small portion I selected stayed visible.

To disable this, just press Alt+B again and the whole scene is visible again.


Export fluid simulation data INSIDE file

The answer to that question is in our (RenderStreet's) knowledge base, search for 'baking'. This is a quote from the first section in the article:

For uploading there are 4 options:

Use our plug-in. The plug-in will collect automatically all baked caches and all project assets and will upload them to our servers. You can download the plug-in from the link in your RenderStreet account
Zip the entire folder and upload via the "add render job page". You'll receive an error message saying that we were not able to find the blend file in the archive. In the process, the archive will get unzipped and then you'll be able to find the uploaded folder at the bottom of the page, in the FTP files section.
Via Dropbox or another cloud storage account .
Via FTP .
Also, when having a question regarding our service, asking our support will get you an answer :)


Turned out you needed an empty  and a separate object to "link it to"


It's true, You have to save the image before saving the file and closing: you can do it in the UV/image window (Image - Save as image, shortcut F3).


Render Layer showing through other Layers

Apparently after fiddling with the scene properties I somehow got it to work, by giving the layer that the object was on a mask layer and then ticking 'all Z' the objects stopped showing through other things. Thank you all for your help on this


Show panel, only when a collection is loaded

You are going to want to use python's membership operator: in

@classmethod
def poll(cls, context):
    return "ThreePointLight" in bpy.data.collections

Using bpy.data.collections[*name string*] would result in an KeyError in the event the name does not exist.


It's very easy,

Go to the compositor
Make sure you check use nodes
Add a glare node in between "render layers" and "composite"
Set it to "fog glow" and try various settings till you get desired effect(s)
"Threshold" controls pretty much how much glow there is
The lower it is the more glow
"Size" controls how blurry is the glow
I normally use only those two settings

Voila !!! Magic lights.


Creating a mesh on any object, duplicating the mesh and editing faces

So, assuming your problem is getting actual geometry out of the Dupli-Objects that you generate in the vertex-positions of your octahedron:

Create the object to be duplicated. In this example: the octahedron
Create the object whose vertices indicate the positions of the Dupli-Objects. In this example: the cube
Parent the octahedron to the cube
Set the Duplication Mode in the Object Tab to Verts
Select the object whose vertices position the clones (the cube)
Create actual geometry from the clones by using the Make Duplicates Real function


Select your mesh.
In the object mode in the left panel of your 3D view there is bunch of options such as trnaslate and rotate and...
In Shading section you can see smooth and flat button side-by-side.
Click on flat then you'll see your mesh as it is.

If you want to use smoth shading option, your mesh should be hi-res (at least a little bit) or it will be like what you can see in your attached image.

Take a look at this (the same object all the time):


(from @Robert's original question)
I found an elegant way to fade to black.
go to compositing, enable nodes.
add an 'rgb' node and an 'alpha over' node.
plug the render layers node into the TOP image input
plug the rgb into the BOTTOM image input
animate the factor in the Alpha over.
you wont be able to see it without a 'viewer' node, but it renders nice.
and uh.. set the rgb to black, or whatever colour you want to fade from
or use an image
or a movieclip
world is your oyster