An alternative solution is to use a Refraction shader. Since this does not require changes to the geometry of the original "image" it can be very easily animated.

The key is to be able to control the bending of each ray hitting a surface (the zoom window) into a particular direction, irrespective of the incoming angle of the ray. This allows the camera rays to be directed towards a specific area of the distant image to visually 'lift' a section of the image closer to the camera (similar to Paul Gonet's excellent answer but without actually changing the geometry).

Normally the Refraction shader will bend the incoming ray based on the refractive index and the incoming light ray path. For rays 'entering' a denser material, the rays will typically bend towards the surface normal. For rays 'leaving' a denser material the rays will bend away from the surface normal - with the amount of bending based on the angle of the incoming ray (so rays along the Normal will not be bent but those at steeper angles will be progressively more bent).

A surface with an infinite refractive index would bend all incoming rays so that they exit along the surface normal. Similarly, a surface with a refractive index of zero will bend all 'outgoing' rays along the surface normal. Since we can control the direction of the surface normal we can use this to control the precise direction of any rays passing through the surface. Note that we can't actually enter a refractive index of infinity (the node doesn't allow it), but the same effect is achieved by flipping the normal (so rays hit the surface from the "back" and use an IOR of zero.

To start with, create a plane to act as the 'start' of the pipe (the 'zoom window'). Set its dimensions as desired and duplicate it (Shift-D) to create an exact copy to be the 'end'. Create the following material and assign it to the 'end' plane - this will be used to highlight the area of the image that is currently being zoomed :

Note that the material mixes between a pair of transparent shaders based on the Ray Depth, each with different colours. The plain white transparency is to ensure the material is invisible when viewed through the zoom window (we don't want that tinted), whereas the coloured transparency highlights the section of the original image being shown in the zoom window.

Create the following material and assign it to the 'start' plane :

Note the Refraction shader with IOR set to 0.000. Flip the normal of the plane (or rotate it around the X or Y axis by 180 degrees) so that the camera sees the back face of the plane. To direct the rays in a particular direction we now only need to feed the desired direction vector into the Normal of the Refraction shader. The nodes on the left-hand side of the material achieve this by calculating the difference in location (in world space) between the 'start' plane (the lower Texture Coordinate node) and the 'end' plane (the upper Texture Coordinate node - note the use of the Object field to indicate that the coordinate should be in relation to the 'end' plane).

The 'zoom lines' are added by way of a Cube that is 'hooked' at one end to the 'start' plane and the other end to the 'end' plane - so that it stretches between the two. I removed the top and bottom faces to avoid z-fighting with the start and end of the "light pipe", then selected each set of vertices in Edit mode and selected 'Hook to new object' - this creates a new empty that can be tied to each of the 'start' and 'end' planes using parenting or a Copy Location constraint. The cube is shaded with a material to hightlight the edges and fade out towards the 'end' :

Final result :

From here it's fairly simple to add decoration around the zoom window and/or change the appearance of the 'zoom lines' cube for the desired effect.

Blend file attached

One drawback of this is that the 'target' area (the shaded part of the target image) must be close to the surface of the flat image - otherwise the direction of the light path can affect the area visible in the zoom window. This can be be best illustrated with a diagram :

If the "light pipe" does not end close to the surface then the rays will hit a region to the side of the target - a second refraction surface can be used to 'correct' the path of the rays so that they are directed towards the surface.

The only issue remaining is that the rays emanating from the end of the 'pipe' are parallel. This works fine where the target is a simple plane but will lose any sense of perspective if the target is a more complicated scene. To fix this we can adjust the refraction plane used for the 'end' of the pipe to act like a lens. Adjusting the focal length of the 'lens' will affect the depth of the perspective.

The material for this is as follows :

(Edit : strictly speaking the Vector Transform at the bottom centre of the above image should be set to Normal mode so as to produce a correct Normal!)

Note that the 'lens' is an approximation since it is a plane rather than an actual curved surface (and the calculation is greatly simplified) - objects close to the lens can become distorted. Adjusting the 'Z' coordinate of the Combine XYZ node will adjust the focal length.


EnumProperty fill dynamically using callback

Since Blender 2.79 you can do the following.

###############################
## Portal plane
###############################

def is_wowgroup_enabled(self, obj):
    return obj.WowWMOGroup.Enabled

class WowPortalPlanePanel(bpy.types.Panel):
    bl_space_type = "PROPERTIES"
    bl_region_type = "WINDOW"
    bl_context = "object"
    bl_label = "Wow Portal Plane"
    bl_options = {'DEFAULT_CLOSED'}

    def draw_header(self, context):
        layout = self.layout
        self.layout.prop(context.object.WowPortalPlane, "Enabled")

    def draw(self, context):
        layout = self.layout
        row = layout.row()
        layout.enabled = context.object.WowPortalPlane.Enabled
        self.layout.prop(context.object.WowPortalPlane, "First")
        self.layout.prop(context.object.WowPortalPlane, "Second")

    @classmethod
    def poll(cls, context):
        return (context.object is not None and context.object.data is not None and isinstance(context.object.data,bpy.types.Mesh))

class WowPortalPlanePropertyGroup(bpy.types.PropertyGroup):
    Enabled = bpy.props.BoolProperty(name="", description="Enable wow WMO group properties")
    First = bpy.props.PointerProperty(type=bpy.types.Object, poll=is_wowgroup_enabled, name="First group", description="First group")
    Second = bpy.props.PointerProperty(type=bpy.types.Object, poll=is_wowgroup_enabled, name="Second group", description="Second group")
    PortalID = bpy.props.IntProperty(name="Portal's ID", description="Portal ID")

def RegisterWowPortalPlaneProperties():
    bpy.types.Object.WowPortalPlane = bpy.props.PointerProperty(type=WowPortalPlanePropertyGroup)

def UnregisterWowPortalPlaneProperties():
    bpy.types.Object.WowPortalPlane = None


How can i use Filmic with Blender Cycles baking

You can't bake directly with Filmic but you can composite the texture baked.

Baking with Filmic

Warning: before baking check if:

GPU baking is enabled
check if the normals are correct, to bake an interior scene the faces need to be oriented inward
for your materials use the Diffuse and Emissive shaders only, the materials should not have reflections. Color texture and normal map can be used but you will loose their quality
unfold the UVs, you can do a Smart UV Project if it is an interior bake with a margin of 0.05 to hide the seams

Baking steps:

you must first create an image using 32 bit Float, this will allow to save values higher than 1 (this is the most important part, if you don't create the image correctly you will need to rebake everything)
assign the texture for every shaders used by the baked mesh, make sure it's the active image by selecting it if you have multiple textures
bake the lighting
import the image in the compositor and plug it to the Composite node
change your render resolution to match your image, don't forget to set the percentage to 100 %
in the Scene tab in the property panel, change the Color Management setting to Filmic instead of Default and you can eventually adjust the contrast in the Look setting by default it's set to None (does the same as Base Contrast)
do a render (F12) and save the new image, I recommend you to use TGA

You can then update your lighting, bake it and press F12 to have your new lightmap.

Do it for every bakes including the skybox to keep a consistent lighting and avoid "burned" areas.

Using it in Godot Game Engine

To use it in Godot, export your OBJ and uncheck "Write Material" this will allow to have only one material slot. Export your lightmap as TGA, this format is faster to load than PNG and use RGB instead of RGBA to save some memory.

In Godot select your texture, in the Import tab set the Mode to Loseless and uncheck Filter (it blurs the texture).
Add your .obj into the scene, create your Material, assign the lightmap as Albedo and make sure the color is set to pure white to display the texture correctly otherwise it will appear darker. In Flags check "Unshaded".

While playing if the skybox (the sphere with the sky texture) isn't visible increase the Far setting of the camera. You can set it to 1000 instead of 100.

Project files: https://drive.google.com/file/d/1luU3j60UTCjijg6BC2hOkintSy8vzXSp/view?usp=sharing

How to use it correctly

When using baked textures the size of your game can become heavy, that is why I recommend you to have small and few rooms, like for example a 3D puzzle game like Portal.

If objects have to move or be collected the lighting won't be updated. That is why I suggest you to make them transparent, like holograms, so they fit in the game, like in this fully baked game: https://youtu.be/H-E7_mn73BI

What is the benefit of this technique

Having fully baked lighting allow to have a great looking scene that uses almost no ressources to run, it can run without a graphic card at 60 FPS even on a web browser or a mobile device as long as you don't fill the memory.

Later denoising will be added for Cycles baking allowing to get a better result with less samples.


You might have checked "Wireframe" in the Viewport Overlays menu by accident. Seeing that you are already in object mode and have switched to solid view, this could be the problem.


Can a Deform Mesh Be Split Along the X Axis?

not sure if this is the only answer but it appears the knife tool.if someone
with more experience with blender can give a more complete answer please do as
I  am very novice


Create a black and white texture to be used as the interlace.

(I did this in blender with a texture on a plane, but it can be done with any image creation program)

Then use that image as a factor to combine different versions of the base image, that have been distressed with different filters.

(Click on the image to enlarge)

If you animate the values for the distortion filters or animate an inversion of the interlace texture you can maybe emulate NTSC in all of its glorious ugliness...


Assuming its perfectly round, set your 3D Cursor to the centre of the bowl, select all the vertices of the bowl, shift-d do duplicate and right-click to dump them in the same place. Set snapping to Vertex, Active and make sure a vertex on the corner of the V cutout is selected last (to make it active)

Set your transform origin to 3D Cursor

Then rotate the new vertices around the 3D Cursor snapping to a verts that puts them in the right place.

Select all and merge by distance.
If your bowl is not exactly as mine you might have some small clean up left to do but this will get the bulk of it done very easily. :)


Snapping multiple vertices but picking which one is primary

For the vertex you want to snap, in the Snap options, you have the choice between Target > Closest / Center / Median / Active. To point out the vertex you want to snap to, use your cursor.

For example Active will snap the last vertex you've selected.


I've found the solution! If you go into Weight paint for the disformed object, you can select individual bones. In my case, I selected the left upper arm bone and then painted the cube blue, so that a rotation of the arm bone doesn't affect the other cube


Imported fbx camera from NUKE is rotated the wrong way

SOLUTION: Import fbx into maya and export that scene using the DAE_fbx export. And then just import into blender using the .dae import option.


Mesh Changes Shape when Parenting Armature

First thing, bend a bit the elbow in Edit mode so that Blender knows in what direction the arm is supposed to bend:

Now correct the IK Pole Angle value, for example the correct value for left arm is -90°:


By keyframing the influence value of the Shape Key I (while mouse over the slider, RMB to open the context menu) you can edit a the F-Curve in the Graph Editor.


I had a similar problem, where it requires OpenGL 3.3 and the GPU doesn't support that version. Please provide GPU information to confirm, but if you've updated your driver, then it's probably an OpenGL issue.

How to check your GPU: https://www.quora.com/How-do-you-check-what-graphics-card-you-have-on-Windows-7


Sound works in Blender, but no sound in the final render

I assume that you are using Windows if you are using xvid, but correct me if I'm wrong. I use a Mac, but this should transfer over in a manner of speaking.

On Macs, I can select the QuickTime video format. Once selected, there is a video codec option and an audio codec option. I generally select AAC as my audio codec. I would imagine that there is some format on Windows in Blender that works like QuickTime on Mac.


You can put all objects you want to emit in one collection. In the Render settings of the Particle System you can choose Collection which will use all the objects in this collection.
By default, it's picking single objects to be emitted as particle. But you can check Whole Collection which means, each emitted particle will then consist off all objects in this collection in their relative positions like they are placed to each other.
For emitting single objects of the collection you can also check Pick Random, although it already looks random to me without this enabled.
Another setting you might want to use is Use Count, there you can specify if some of those picked should appear more often than others from the collection.


Run this code in the Text Editor:

import bpy

scene = bpy.context.scene
print("Number of markers: "+str(len(scene.timeline_markers)))

And in Menu > Window > Toggle System Console see the result.


How can I make color retain its properties behind glass?

Your node setup is not the ideal way to do glass in EEVEE (I assume that's what you're using). For proper glass, use this setup (note the highlighted Blend Modes)


Your window material is set to cast a shadow, change it.

Also change the frustum size of the sun.


How to use Python script to generate many lines in Blender and then animate line color and thickness?

You can do this easily with Animation Nodes.

For connections we need initial locations and final locations, So I'm using planes i.e vertices location but you can choose anything (Sphere/Cube mesh, number of objects etc). Now, to connect each vertices a plane (say A) to all vertices of a plane (say B), I have made two "Subprogram Loop" Nodes which basically make individual sets of vector lists. Then using using "Spline from points" node make the connections from those vector lists. In the "Curve Object Output" node, you can animate any parameter (Bevel depth, Bevel Start, Bevel End etc) of a curve.

Here is, examples with two, three planes and with a icosphere, but you can add any number planes (or other mesh object). To make more complex and control connections, you can also use other nodes like "KD Tree" and "BVH Tree" which are available in Animation Nodes.

:)

Here is Node Tree:-

Here, for two planes and subdividing them:

For three planes, so on:

For different type of objects:


How do I "Lock Camera to View" using Python?

This code checks the "Lock Camera to View" box:

for area in bpy.context.screen.areas:
   if area.type == 'VIEW_3D':
      for space in area.spaces:
         if space.type == 'VIEW_3D':
            space.lock_camera = True


This is only a brief description of how to track a path on a simple map/image. If you want to use GPX tracks/GPS/GIS data you need to dig deeper: blender-osm can import GPX-tracks and project them on the terrain.
Manual Tracking a Path On a Map

create a plane with a map image. A convenient way to do this is the use of the "Import-Export: Import Images as Planes" add-on that is shipped with Blender. Activate it in the preference settings.
position the camera vertically above the image
to animate the camera keyframe the Location
to zoom in and out keyframe the Scale of the image
create a Nurbs Path (add Object: Curve > Path)

in Edit mode, use menu Curve > Set Spline Type to Poly
create waypoints by extruding (E) the control points along streets, etc

create a marker (red dot, it's actually a sphere)

add a Follow Path object constraint
use the "Animate the Path" for quick animation, use the graph editor for more control, e.g. add stops, control speed, etc.

create a waypoint object. This will create the red line

add an Array modifier and a Curve modifier to make it follow along the path
move x position to a negative value, so the marker starts at the beginning of the curve/path. I've bent it down along the z-axis to hide the beginning. Not sure if this is the best way to do so
animate the x position with a driver to make it "mark" (move along) the path/curve.
formula for the driver of the x position looks like min(-2.50753 + (2.50753 * (frame-1) / 180), 0). This makes the marker follow the curve for 180 frames and then stop. The -2.5073 is the start value to set the marker at the beginning of the curve. It depends on the length of the curve/path. Just pull it along the x-axis by eye.

Zooming Effects

you can zoom in and out if you scale up/down the image in front of the camera
if you want to do a zoom effect that exceeds the details of the map image you can use multiple images with different levels of detail.
stack the images, increase the Scale of the image to match the level of details of the next image. Adjust the transparency (Alpha value) of the image for an overview and to match the scale.
keyframe the Scale of the image. At the frame where the level of details match, turn off the render visibility

Result


Object particle flicker and halted dynamics

I'll admit I'm not entirely sure why, but the issue seems to stem from the particles colliding with the plane at the bottom. If the object isn't closed so that all normals are facing outward, then the particles which get stuck in the collider cause flickering and the dynamics fail.

So, the solution to this problem is to add a solidify modifier to the plane collider at the bottom. To illustrate the difference before and after the adding the solidify modifier to the plane, I'll show you scaled down versions of frames 80 and 85.

As you can see above, the petals just seem to fall down with very minor rotation. If I were to render more frames, you'd see that some petals flicker in and out. This is definitely not desired.

And now you can see that the scene is completely changed now that there is no error. All the petals seem to rotate or translate to a different position.


Why does only the Horizon render, but not objects?

Nevermind, I found out myself, all  I had to was clear restricted renders.


The problem was my high poly mesh being in the same scene. Even though it was hidden it botched the baking. After moving the high poly  to a different scene the problem disappeared.


edges sharp though edge split modifier not added

I've figured it out by myself now: In Properties > Object Data > Normals > Auto Smooth.
It's kinda like Edge split but not as an Modifier but it works the same, maybe even better.


Is there a way of keyframing RGB curves?

All of the node data is available through python so a workaround could be to use a python script to adjust the curve at the right time.

To view the curve data you can use a script like -

import bpy

theCurveNode = bpy.data.materials['Material'].node_tree.nodes['RGB Curves']

print("R Curve points are:")
for point in theCurveNode.mapping.curves[0].points:
    print(point.location)

print("G Curve points are:")
for point in theCurveNode.mapping.curves[1].points:
    print(point.location)

print("B Curve points are:")
for point in theCurveNode.mapping.curves[2].points:
    print(point.location)

print("C Curve points are:")
for point in theCurveNode.mapping.curves[3].points:
    print(point.location)

So curves[] will always be 0-3 for RGBC and each curve can have any number of points. It would be tedious but you could use the script to generate a list of values that you then use as data for the script that imitates keyframes. Possibly calculating them or interpolating smoothly between frames.

theCurveNode.mapping.curves[1].points[2].location.x = myCurvePointLocX(1,2)
theCurveNode.mapping.curves[1].points[2].location.y = myCurvePointLocY(1,2)
theCurveNode.mapping.update()

Be sure to run mapping.update() after altering any curve points.

You could then setup a script that appends a function for bpy.app.handlers.frame_change_pre that alters the curves based on frame_current.

I can't say this is a recommended method but in theory it could work.


Modeling bespoke kitchen cabinets with varying frame, door & moulding sizes

You can make use of Bezier curves and Bevel Object for this.

Design the sections of the mouldings and frameworks as separate objects.  You can recycle them and even keep them as a reusable library, possibly in a separate file for easy linking.

Create a bezier curve representing their shapes as desired, but leave a gap keeping shapes open for plain panels, so Blender is able to cap the fronts of the panels with surfaces automatically, despite having a custom bevel profile.

Create cabinets out of panels made from separate bezier curve objects with rectangular shapes. Make sure they are set as 2D, and assign the correct Bevel Object for the desired framework.

Easily edit the bezier curve points for different dimensions and panel shapes, Blender will automatically take care to keep undistorted proportions for the frameworks.


Possibly, you've copied the object using altD (duplicate linked), you should use shiftD (duplicate object) instead so that the new object will have its own data.
"duplicate linked"

is called a deep link. This will create a new object with all of its
data linked to the original object.

See the documentation here.


After adding a layer. Hold D to draw on VSE preview window.
Holding D and drawing with right click will bring up the eraser.You can turn on Onion Skinning in the options panel as well.


Cutting a triangular pyramid at precise z coordinates

You can easily achieve this with a boolean modifier, using a plane.
Add a plane, set its height to be where you want to cut the pyramid,
then add a boolean modifier to your pyramid, set the plane as the object, and duplicate the pyramid.

One copy of the pyramid should have the boolean operation parameter set to difference (keep the top of the pyramid), while the other should be set to intersection (keep the bottom of the pyramid).

Apply the modifier on both copies to complete the process.


Copy transforms Constraint gives strange scaling and transforms?

It was the rig all along , The wrist bone was placed back at the elbow! , So i extruded a bone from the tip of the middle finger and used that , it had proper scaling and rotation.


You have the domain settings on what should be the emitter object.

The domain should be the cube around the cylinder, and the emitter object should be the cylinder inside it (see the wiki).

Note that the smoke simulator was updated a bit in blender 2.64, so to get an the same effect in 2.70a:

Enable the smoke domain for the cube object:

Adaptive domain is a setting which was added in 2.64, and it basically just skips calculating parts of the domain which don't have smoke in or near them. Enabling it should speed up the simulation without affecting the result.
Enable the smoke flow physics on the cylinder (in your file this was set to domain)

Make sure Initial velocity is enabled. You may also want to up the number subframe smaples, but note that this will slow down the simulation.


Make you you apply object transformation. If you resized the object, the modifiers will still be subject to warped dimensions.


a little tip to use already found solutions. you can easily use as many versions of blender as you need. it doesn't need any installation. just download earlier version in another folder and run it from there. this way you can use solutions for previous versions, save your file and then continue in your favorite one later.
it's not so weird as it sounds, at least for blender. it can do some things better in the very version only.


Transparency problem with tga material/texture

Tick Transparency under Display in the Object tab. This will have the object's material display any transparency it has in the viewport sans the gray placeholder.


How do I fix this irregular shading on my subsurf retopology attempt?

you have nGons which tends to cause problems for both sub-division modifiers, animations and texture baking.

For hard-surface/mechanical type models, you can use tris/nGons on flat areas so long as the transitions to curved areas are all bordered with quad based geometry.  Note this will still make some of the selection tools less effective.

The following chart shows many ways of redirecting polygon flow so you can keep an all-quads mesh that has clean lines that will still work well with various modeling tools.

Credits: The authors name can be seen at the bottom of the image.

I have found half a dozen charts like this so you might want to do some more digging using keywords such as "polygon flow" "quad modeling" as the basis for an image search.


Specific vertices shoot off in random directions when bevelling

This turned out to be an easy fix, somewhere along this line my 'surface normals' got all messed up, and Blender's vertices follow their respective surface normals when transforming like in the bevel tool.

To resolve this problem (unless you have custom surface normals and resetting isn't an option) is to simply select the area which is not behaving as expected (in this case the edge loops and recalculate normals. For Mac the shortcut for this is shift + N.

See more about it here


@Osian Sodenkamp's tip worked in my case. You have to disable screen-space ambient occlusion in the display options panel (hidden under N key). I'd never find it out if it weren't for Osian's comment!


How can i drop my mesh on floor with rigid body

Ok, I tried a few options and got a fairly stable simulation. Here is the result:

Steps:

Scale the ground and pen up by 100 (physics simulations work better with larger objects. Also, the floating came from the constant collision margin of 4 cm which means that objects will already collide when they are 2*4 centimeters apart. While this value can be changed, it is better to scale the objects up)
Apply the scale on the pen with Ctrl+A > Scale
Set the origin of the pen to Center of Mass (Volume) (a wrong origin can mess up simulations)
Use convex hull as collision shape (should be precise enough in this case. Mesh shape causes glitches)
Use box as collision shape for the ground (except if you want to use a different shape)
Finally, you might want to increase the Rigidbody simulation steps (Go to Scene Properties > Rigid Body World and increase Steps per Second and Solver Iterations, e.g. to 600 and 100)


How to remove/apply all modifiers of one object in python

Modifier removal

To remove a modifier from an object.

obj below is a reference to an object either obtained via

obj = bpy.context.active_object
obj = bpy.context.object
# or
obj = bpy.data.objects[name]

If you want to remove a modifier it is done by name, not by type. You could have multiple array modifiers, but only want to remove
a specific one.

modifier_to_remove = obj.modifiers.get("Bevel")
obj.modifiers.remove(modifier_to_remove)

# or as a one-liner
obj.modifiers.remove(obj.modifiers.get("Bevel"))

# or remove all modifiers from an object
obj.modifiers.clear()

Modifier Apply

Using an operator

As sambler pointed out

# operates on all selected objects (not just the scene's _active_object_)
bpy.ops.object.convert(target='MESH')

lower level

If you want to apply all modifiers it's covered here: How to get a new mesh with modifiers applied using Blender Python API? - This involves using obj.to_mesh and there are a few things to consider, it:

generates a new mesh from your current obj (leaves current obj.data intact)
does not remove the modifiers automatically from the object. (unlike the Apply button on the Modifiers panel, or Convert to Mesh).

This snippet will:

"""
- make a reference to the current obj.data ( i call it old_mesh)
- make a new Mesh ( new_mesh) using the effect of the combined modifiers on `obj`
- remove all modifiers from `obj`
- assign the new Mesh to obj.data
- remove old_mesh from the blend
"""

in code:

import bpy

context = bpy.context
scene = context.scene
obj = context.object

# get a reference to the current obj.data
old_mesh = obj.data

# settings for to_mesh
apply_modifiers = True
settings = 'PREVIEW'
new_mesh = obj.to_mesh(scene, apply_modifiers, settings)

# object will still have modifiers, remove them
obj.modifiers.clear()

# assign the new mesh to obj.data
obj.data = new_mesh

# remove the old mesh from the .blend
bpy.data.meshes.remove(old_mesh)


The Cell Fracture addon can create sometimes results with parts not cut out. One possible reason for that is non-manifold geometry; as long as mesh will be non-manifold it won't be broken well enough by the addon. You can test that with default monkey (as it's non-manifold because of the eyes):

The areas which have unfinished fractures are ones near the eyes and this is one way to determine where non-manifold geometry is present. Use Ctrl+Alt+Shift+M to make non-manifold parts selected, Mesh Lint addon and others. There are some certain techniques used for repairing such areas listed in the linked answers.


Typically you can animate any value in blender by hitting i. If there isn't an on/off switch, you can modify the collision object's geometry.

Go to the frame before the shattering. There hit i > Scale. Go to the next frame and sto scale the object up. Make it so big that it doesn't block the flow of the fluid. i > Scale again to save the size.

Now it should work.


How to control the thickness and darkness of lines when exporting UV Layout

I had a similar issue with the edge being 4px. There are a couple of options but none I can see to fix this. Preferences > theme > UV Image editor. You can change the vertex size but not the edge. Also on the overlays there are no specific size options in the Display As

Instead I exported the UV Map as .svg or .eps from here you can open in Adobe Illustrator which gives a sharp vector path. I would set the fill opacity to 0 to make sure there is no bleed from the black edge. You could open either of these formats in Ps but the same issue persists.

In Illustrator you can then adjust the stroke width from 1pt to 0.1pt and copy into Photoshop to give a single pixel width. Not perfect but the best I can see unless there is another option I am missing in Blender


Alternative way to Reset to Original Pose

With your bone selected go into the pose menu and clear the transform on rotation. See pictures below.


Exporting a rigged object to Unity (as FBX) produces massively distorted mesh, affecting normals

EDIT: The video posted by Aster17 includes a step correcting for object scale prior to export, along with many other steps, so refer to that for your exporting needs. I'm only accepting this answer rather than Aster17's because this answer explains what happened in this specific case in more detail.
I tracked down the cause: in the very first edit I had made when sculpting the model (after adding and subdividing a cylinder primitive) I had accidentally scaled the object rather than the vertices to make the shape longer and narrower.
This obliged Blender to similarly apply an asymmetric scale to the bones of the armature when parenting the rig to the mesh, in order to preserve its appearance. However, it seems that at some stage in the Blender->FBX->Unity workflow, the ability to cope with asymmetrically scaled normals is lost.
In short, Blender hadn't distorted the mesh at all - I had, right at the start. All Blender did was bake that distortion into the bones.
The upshot is that if you asymmetrically scale an object (as opposed to its vertices) in Blender, then Blender and Unity will come to different conclusions about the normals that should accompany that shape.


From the Blender Docs:
The Subdivision Surface Modifier is used to split the faces of a mesh into smaller faces giving a smooth appearance.....

For more info, visit the documentation:
https://docs.blender.org/manual/en/dev/modeling/modifiers/generate/subsurf.html


Why does the saturation get stronger in darker areas of a cycles render?

The answer for this issue is "albedo", a very important aspect to keep in mind when creating shaders.

Albedo is the reflectance of a material, which in layman terms means how much of the light received is bounced (it's a percentage) and therefore how much is absorbed.

Real world materials don't reflect all the light received nor absorb all the light received (materials you'd call "black" in real world always reflect a little light, while the brightest material you'd call "white" bounces less than a 90% of the light received).

That's the main reason why the default cube is 0.8 RGB gray and not 1.0: albedo is somewhat encoded in the RGB values you feed to shaders as base colour, so if you gave your material a 1,1,1 as base colour, it would bounce back 100% of the light received, which is physically incorrect.

So when you render your materials a part of the light is being absorbed, and the resulting pixel is the light hitting the surface scaled by that albedo (present in the base colour).

I suspect you're trying to reproduce what passes do (multiplying shading by base colour as we discussed in your other question), but it can't work that way because you're multiplying the base colour to the already rendered surface.
Your rendered gray cube has an albedo of 0.8, so it reflected an 80% of the light it received. When you render the brown cube, colour affects the albedo too, and the bounced light is different than 80%, and that's the reason why you get a difference when you multiply.

In other words, your rendered gray cube isn't exactly the same as a pure shading pass, so multiplying colour to produce the same result than rendering a colored cube won't work.


Why is Density not showing up as a source option for my Voxel Data?

The options for that setting were changed in 2.65, which was part of the addition of fire.

In older versions like in the tutorial, only smoke data was used to define the density of the volume, with the addition of fire, there are now two sources. Previous options of Density, Heat, Velocity were changed to Smoke, Flame, Heat, Velocity.

If you are only simulating smoke then use Smoke instead of Density. If you have fire and smoke, then you can create a texture for the fire data and another for the smoke data.


By analyzing the two provided scripts, as well as the free version of Pro Lighting: Skies I was able to understand how to create a previews menu.

Here is my script that I commented in if you want to study it.
If you run it in Blender's text editor, it will create a panel at the bottom of the Object properties area.

The key parts of what you want to do are:

Create a property collection

This happens in the register function so only one is created. Because you want the the images folder to be predefined, we hard-code the location inside of the script. You also set a globally defined preview_collections variable to hold the collection. Then you create an EnumProperty to hold the images. This has a function to generate the images from the folder.

pcoll = bpy.utils.previews.new()
pcoll.images_location = bpy.path.abspath('//images')
preview_collections["thumbnail_previews"] = pcoll
bpy.types.Scene.my_thumbnails = EnumProperty(
    items=generate_previews(),
    )

Generate Previews

In the generate_previews function, we create a pcoll object that references the one we created in the register function.

def generate_previews():
    pcoll = preview_collections["thumbnail_previews"]
    image_location = pcoll.images_location
    VALID_EXTENSIONS = ('.png', '.jpg', '.jpeg')

    enum_items = []

    # Generate the thumbnails
    for i, image in enumerate(os.listdir(image_location)):
        if image.endswith(VALID_EXTENSIONS):
            filepath = os.path.join(image_location, image)
            thumb = pcoll.load(filepath, filepath, 'IMAGE')
            enum_items.append((image, image, "", thumb.icon_id, i))

    return enum_items

Access the values

We can then access this preview collection in any Blender UI Panel with

row=layout.row()
row.template_icon_view(context.scene, "my_thumbnails")

Or however else you named it. Then you can use bpy.context.Scene.my_thumbnails to access the currently selected image name. From there you can create an append button to append from a file based on the image name.

Using in an Addon

To use this method in an addon, you need to change a line in the Previews.py file. Instead of getting the location of the images folder based on the current .blend file, you need to get it based on the location of the addon. So change

pcoll.images_location = bpy.path.abspath('//images')

to

pcoll.images_location = os.path.join(os.path.dirname(__file__), "images")

In the __init__.py file, the register and unregister functions need to call the Previews.py's register and unregister functions.

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

def unregister():
    bpy.utils.unregister_module(__name__)
    Previews.unregister()

And finally, because you use bpy.utils.register_module(__name__) you need to remove the register_class call in the Previews.py file to register the UI class, or it will be called twice.

# Delete this, as well as the one in the unregister function from Previews.py
bpy.utils.register_class(PreviewsExamplePanel)

I have updated the Gist on GitHub with the changes.


The unexpected shading could either be flipped normals, or a lack of lighting. You could try turning on "Ambient Occlusion" in the display settings tab to help you be able to see the tree in top-down mode. It's not showing because it's the same color as the groun.


How can I render different scenes at different frames?

Each scene has a start frame and an end frame in the Scene > Render > Dimensions.  If you set those both to the frame you want, then rendering the animation will render that single frame.

This setting is per-scene.


Fluid simulation pours into the cup in a box shape and won't spill

Setting your cup to obstacle (as mentioned in the comment above) should fix the problem of the cup bounds being square. The main thing you would want to fix, though, would be the size of your fluid domain. It will not affect the fluid, but will simulate the bounds of where the fluid will go. A smaller domain will give the waters smaller boundaries. Also, if you are using a rigid body for the cup, it will not simulate well with the fluid.


What are the denoising passes useful for in 2.79 experimental feature set?

There are no practical uses at the moment. It has been suggested that they will be used in compositor denoise setups, perhaps for denoising individual passes (as currently only the combined render is denoised.) However, whatever setup they are intended for has not been developed yet. It will probably happen when the denoiser is finished. So perhaps for 2.8, or perhaps not until later.

This info came from the blenderartist post. I asked about it here. I do not know if it discussed in more detail elsewhere in the thread, as the thread is huge!

https://blenderartists.org/forum/showthread.php?395313-Experimental-2-77-Cycles-Denoising-build&p=3208408&highlight=#post3208408


Can the UV map be updated without unwrapping the mesh?

First select the original UVs and pin using P shortcut and enable Live Unwrap

Then in the UV/Image Editor move one of the vertices of the new created faces and it should snap the faces in the right position.


Is there a way to utilize emissions in VFX?

A method to get believable light interaction with the environment, is to recreate the environment.

I have chosen this template image. The process will be the same for moving, tracked footage, but the tracking must be very accurate.
I chose this background image by Hans Weingartz - Self-photographed, CC BY-SA 2.0 de. Click to enlarge.

I have recreated the environment with very basic shapes. This result in the following layer setup.

Layer 1: Cg object, which is inserted.
Layer 2: Recreated environment with computer generated light. Try to match the reference as close as possible. I used some simple diffuse, glossy and emission shaders, but you can always try to extract color information from your footage. Especially with high contrast areas like checkboard patterns or dark ridges, you should take great care to achieve similiar color values through your artificial lighting of the recreated environment.
Layer 3: The environment object, but this time with the camera image mapped onto it for maximum accuracy. The background image is just applied as the emission color and this object will be used for the lighting and reflections of the cg object on layer 1.

Now, I create three Render Layers.

environment_clean This is just the recreated environment with virtual lighting on layer 2. Use the exclude layers to exclude the cg model from layer 1 and also the reflection object from layer 3.
environment_shaded This is the same environment as above (layer 2), but this time without excluding the cg model. Although the model is not visible (layer 1 is switched off), it is not excluded and will therefore influence the lighting/shading of the environment on layer 2. Exclude layer 3, since the duplicated environment is still not relevant.
cg model This is the render layer which will render the model on layer 1. The recreated environment with virtual lighting is excluded. The environment with the camera mapped footage on layer 3 will not show up (since it is not checked in the render layer), but will influence the lighting of the model, especially visible in reflections.

Illuminating the background footage
Since we have rendered a virtually lit environment with and without influence of the cg model, we can create the difference between the lighting. We will then apply this difference to the background footage.

Subtract the environment_shaded from the environment_clean render layer in compositing nodes. It is important the you uncheck clamp, since shadows are going to be values below 0.0 (which we don't want to cut off) and lights are going to be values above 0.0. The subtracted result is the difference in lighting between our environment and the environment influenced by the model. Add this to the background footage. The background image will now appear as if illuminated and shaded by the cg model.
Note, that in the areas, where there are dark colors in the original live action footage, but light color in our virtual environment, the added lighting looks very unnatural.

While shadowy areas would naturally receive light, objects with dark colors won't get equally lighter as object with brighter colors. A quick and easy fix is to only add the light/shadow to already bright areas. We can achieve this by using the original image (modified by a colorramp) as the Fac value for the addition.

Obviously a more convincing image is accomplished by modeling and shading the virtual environment more accurately. (Or combined both.)
Add the cg model (render layer) on top of this modified version of the background using a mix or alpha over node.

Here is the complete node tree.

Render Time vs Workload
The rendering process will obviously take much longer than a simple shadow catcher or other tricks, because it uses three different layers. The two environment layers will take a lot of render time because their noise will accumulate in the subtraction and they usually need a high sample count for the indirect lighting. The setup will however easily produce a realistic render result in little work time.


Best solution: get a buildbot build in a week or two that will have this patch added: https://developer.blender.org/D2313 This is the same shader that Substance itself uses, and should be a 1:1 translation. Until that's available in a more accessible build, I've ported over a blog post I wrote about this below:

To start, I've given everyone's favorite monkey an interesting paint job using the default color, height, roughness, and metallic channels.

First order of business is to export these for Blender. Hit File > Export, and just use the default "Document Channels + Normal" preset.

Now let's look at our shader in Cycles. We'll start by making the simplest, most standard physical shader, a diffuse/glossy mix with fresnel.

NOTE: Some people like to use the layer weight node instead of the fresnel node. If that's you, go right ahead. I'm just using the fresnel node here for simplicity.

Base Color

Our first channel to deal with is base color. There's not much to this one. We have a base color image, we'll just load it and plug it into the diffuse BSDF's color slot.

Roughness

Our next texture if the roughness map. As you might have guessed, we're connecting it to the roughness inputs on both the diffuse and glossy nodes. However, there's a couple things we need to set to make sure Cycles interprets the map correctly. The first is to change the node from "color" to "non-color data" (as that is what the roughness map is). Any channel that is not set as "sRGB" in substance painter should be loaded as non-color data. Here we see that base color is sRGB (and thus should be loaded as color), but the rest of our channels are luminance (marked with an "L"), so they should be loaded as non-color data.

The other thing we need to do is square the roughness value to match the range between SP and Cycles. To do that, add a math node, set it to "power", connect your roughness map to the top slot, and set the bottom slot to "2.0".

Normals

Substance Painter can generate a number of "converted" texture maps. One of which is the "Normal OpenGL" channel, which generates an OpenGL-style tangent-space normal map using the height channel and the object's normal map (if it has one). We can attached it with the normal map node, like usual.

In this case, our object didn't have a baked normal map in Substance Painter. But in case it did (such as baked sculpting detail) the normal map will contain that as well as your height painting, so you don't need to do anything else to connect the two.

Metallic

Ok, one more channel. This one gets a bit complicated. Up until now, our shader has been a simple dielectric shader. We now need to introduce an alternate shading path for metal, and use the metallic map to blend between them. To do this, you are going to add a mix node at the end of the chain, attach your metallic map to the mix factor, then put an extra glossy BSDF on the second input, and attach your base color, rough (from the power node) and normal (from the normal map node) to this glossy BSDF.

I've highlighted our newly added nodes in red. Areas that are dark in the metallic map will use our diffuse/glossy fresnel mix we created earlier. Areas that are bright in the metallic map will shift over to this glossy-only shader. Since metals have colored reflections, we attach the base color to the glossy-color input here, unlike our other glossy BSDF on the dielectric side. Since roughness and normals are shared, we use the squared-roughness and normals just like on our other BSDF nodes.

And here is our final monkey!

This shader setup is just the very basic elements required to translate the shader. There are numerous other effects you can add. For example, some people like the look of metal shaders that blend two glossy BSDFs at slightly different roughness. You can add that in to your shader (use an extra math node to scale your roughness map). Some people prefer to use the layer weight node instead of fresnel. It's all up to you, feel free to experiment!


Copying and Pasting Fcurve modifiers Through Python

I don't think it is possible to get/set the active fcurve / driver. So you can not override the context for bpy.ops.graph.fmodifier_copy

You might use from_existing and adjust the data_path attribute from the returned driver accordingly if you want to copy the driver or try out this script:

import bpy

sk = bpy.data.shape_keys['Key']

source = sk.animation_data.drivers[0]
target = sk.animation_data.drivers[1]

for mod in source.modifiers:
    copy = target.modifiers.new(mod.type)
    for prop in mod.bl_rna.properties:
        if not prop.is_readonly:
            setattr(copy, prop.identifier, getattr(mod, prop.identifier))


Some thing like this maybe.

import bpy

from bpy.types import(
        Panel,
        Operator,
        PropertyGroup
        )

from bpy.props import(
        StringProperty,
        PointerProperty,
        FloatProperty
        )

class HelloWorldPanel(Panel):
    """Creates a Panel in the Scene properties window"""
    bl_label = "Hello World Panel"
    bl_idname = "OBJECT_PT_hello"
    bl_space_type = 'PROPERTIES'
    bl_region_type = 'WINDOW'
    bl_context = "scene"

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

        # you need to get your stored properties to draw them
        scene = context.scene.your_properties

        col = layout.column()
        col.prop(scene, "string")
        col = layout.column()
        col.prop(scene, "size")
        col = layout.column()
        col.operator("some.thing")

class Add_some_thing(Operator):

    bl_idname = "some.thing"
    bl_label = "Add object"
    bl_description = "some description"

    def execute(self, context):

        # you need to get your stored properties
        scene = context.scene.your_properties
        # you get some of your properties to use them
        string = scene.string
        size = scene.size

        # you do some thing to use your property with
        bpy.ops.mesh.primitive_cube_add()
        # you can change some of the added object props as the defined in the ui property
        context.active_object.name = string
        context.active_object.scale = [size, size, size]
        return {'FINISHED'}

# your properties here
class addon_Properties(PropertyGroup):

    string = StringProperty(
        name = "the name",
        description="name of the object to add",
        default = ""
        )
    size = FloatProperty(
        name = "size",
        description = "size of the object to add",
        default = 1.0,
        )

classes = (
    HelloWorldPanel,
    addon_Properties,
    Add_some_thing
    )

def register():

    for cls in classes:
        bpy.utils.register_class(cls)
    # you store your properties in the scene
    bpy.types.Scene.your_properties = PointerProperty(type=addon_Properties)

def unregister():
    for cls in classes:
        bpy.utils.unregister_class(cls)
    # you delete your properties
    del bpy.types.Scene.your_properties

if __name__ == "__main__":
    register()


finding a link or material pointing to a missing file or path

In the outliner choose the Orphan Data display mode

To fix the path for broken links or missing items use the Data Api mode

Data API
Lists every data-block along with any properties that they might have.
Orphan Data
Lists data-blocks which are unused and/or will be lost when the file is reloaded. It includes data-blocks which have only a fake user. You can add/remove Fake User by clicking on cross/tick icon in the right side of the Outliner editor.

(from the blender manual)


How to render invisible objects casting their z-depth alongside other visible objects

Using render layers might help you.
I have created these two planes, and put them in seperate layers. The light grey in layer 1, and the blue in layer 2. In the render layer tab settings there is a "mask layer" where I chose layer 2 as a mask layer.

Please note that the shadows of layer 1 still render, you can remove these by unchecking the "shadow" box in the "cycles settings" under the object tab

finished result, a masked grey plane in all its glory

If the blue plane on top is moved below the grey plane. It will not mask the plane.


Fixing non-manifold edge for 3d printing

While removing  doubles with a high merge distance of 0.1 or more will remove some of the problem, fixing the non-manifold issue manually will take a very long time as you need to fix each and every errant vertex.

However, if you don't need to maintain the exact same mesh and can live with a very very close reconstruction of it, you can fix the non-manifold issue automatically by using the remesh modifier, and then the decimate modifier to reduce the polycount back to sanity.

Here's the setup:

After adding the modifiers with the parameter values specified above, you can either directly export to STL (File --> Export --> Stl) or apply the modifiers and then export.


How to set object's rotation from python?

Here's how to set Euler rotation.
First: from mathutils import Euler
Then: obj.rotation_euler = Euler((0.3, 0.3, 0.4), 'XYZ')
If all the other track_to options are overkill. For more attribute references see the Object documentation


Blender doesn't use system resources optimally

Blender most likely is fully using your system resources. In the task manager, change one of the charts to display CUDA and you'll see that its being fully utilized.

I just started a render on my computer, and you can clearly see when it fully using the GPU resources for CUDA even though it says usage is just 12% in total.

Edit

Windows may throttle your performance based on your power settings. Open up the start menu and search up Edit Power Plan.

Then go to Change Advanced Power Settings, and under Processor Power Management, check that the Maximum Processor State is set to 100%.


Go into editmode and select everything.
Go in the Properties Panel to Object Data (The Triangle Symbol) and go to Vertex Groups.
Select the Vertex Group that is named exactly like your bone.
Set Weight to 0.
Click Assign.

That should do it


How do I toggle the view between perspective/orthographic with out a numpad in 2.8?

There are 2 addons bundled with Blender called UI Pie Menu Official or alternatively 3D Viewport Pie Menus (for both 2.79 and 2.8). When enabled they provide list of menus you can call through pie menu, View Numpad Pie as one of them. Both of them have Persp/Ortho switch, though in second-level menu (first you need to hover over View Menu and click it, then click to execute perspective switch).

Depending on the addon perspective switch will be either under another level of pie menu or submenu of the currently chosen pie menu item.
Only nuance is that in 2.8 position of items in pie menus changed, so that in 2.79 View Menu is on the left, in 2.8 - on the right. If you use both versions you might need to adapt to that.


How can I create a mirror material for the game engine?

It is possible by using bge.texture.ImageMirror.
Basically the mirror objects texture is frame by frame replaced with a video-texture which is captured by another camera.

A tutorial and an example .blend file which works with Blender 2.68.


bad camera angle (or trackers?) with aerial footage

Solve mode should not be tripod. Tripod solving is for when the camera is not moving, just rotating from a fixed position. Tripod solve will not result in 3D reconstruction, it will only solve the camera movement, but the trackers will not contain any depth information, they will be projected as in a sphere around the camera.
When the camera moves (as in advances forward of back, or is being displaced sideways or up or down), then use the Default Camera Solve.
As for how to proceed, most of it has been answered here.
Read the following link: get better results for camera tracking
Most problems with solving 3d information come from poor (inaccurate) tracking.  You need at least 8 trackers, but more can help you in this case. Track objects on the field around the buildings as well. Prioritize objects that move fast (in the foreground) and then track a few objects that are very far away.


Using python to create a curve and attach its endpoints with hooks to two spheres

Based on the answer linked by Seppo Silaste I have come up with the following example code which you can modify to fit your application:

import bpy

def hookCurve(o1, o2, scn):
    curve = bpy.data.curves.new("link", 'CURVE')
    spline = curve.splines.new('BEZIER')

    spline.bezier_points.add(1)
    p0 = spline.bezier_points[0]
    p1 = spline.bezier_points[1]
    p0.co = o1.location
    p0.handle_right_type = 'VECTOR'
    p1.co = o2.location
    p1.handle_left_type = 'VECTOR'

    obj = bpy.data.objects.new("link", curve)

    m0 = obj.modifiers.new("alpha", 'HOOK')
    m0.object = o1
    m1 = obj.modifiers.new("beta", 'HOOK')
    m1.object = o2

    scn.objects.link(obj)
    scn.objects.active = obj

    # using anything in bpy.ops is a giant pain in the butt
    bpy.ops.object.mode_set(mode='EDIT')

    # the mode_set() invalidated the pointers, so get fresh ones
    p0 = curve.splines[0].bezier_points[0]
    p1 = curve.splines[0].bezier_points[1]

    p0.select_control_point=True
    bpy.ops.object.hook_assign(modifier="alpha")

    p0.select_control_point = False
    p1.select_control_point = True
    bpy.ops.object.hook_assign(modifier="beta")

    return obj

o1 = bpy.data.objects['atom 1']
o2 = bpy.data.objects['atom 2']

obj = hookCurve(o1,o2, bpy.context.scene)


How to make all objects rotate in the same way

Looks like your pivot point is set to "Individual Origins". Switch it to "Median Point" if you want your objects to rotate around the selection center (as by default). Or you may also use any other pivot, like 3D cursor, etc.


Glass - How to make visible light source behind (eevee)

Light source behind a glass (Eevee)

To see through a glass enable

Properties editor > Render Properties tab > Screen Space Reflections > Refractions
and under Material Properties > Settings > Screen Space Refraction

To see a light source like a Point

add a Cube (in location of light) with Principle Volume shader
decrease Density to 0.1 or lower and Anisotropy increase to 0.9


How to combine nodes-editor transparency with uv-mapped textures in Blender Render?

You clipped your first screenshot right where it mattered , seeing your complete node setup would help solve the issue.

Are there any more nodes in your material? Is there anything connected to the Vector socket of your image texture?

If not that is where your problem is. When using node materials and textures you must specify which type of texture coordinates to use in your texture within the node setup, to correctly display it.

Before your image texture node add a new Input > Geometry node, choose one set of UV Coordinates from the pull-down menu and connect the UV socket to the vector input of the image node.


you got double faces.

in edit mode select all verts.
alt + M > By distance > if the double faces are not gone hit f9 in 3d view and make the distance more.


How to separate two meshes in one object

Go into edit mode and selecting the entire one torus by moving your mouse over the one and pressing L. Then press P which brings up a menu called separate, then just click on selection and it should separate them into two objects.


The way how fire looks in viewport isn't much related to what would be rendered. It shows 3 basic things:
- the simulation was cached and is available for rendering;
- the direction of the smoke and / or fire propagating (up / down / etc);
- rough forms of the final simulated effects.
All other details aren't really shown in the viewport, like thickness, scale, color, density etc. of the smoke / fire.
Generally, preview in viewport is accessible just after running simulation; no materials needed. To render that simulation you will need to add a volume material which will tell render engine how light behaves inside of that volume domain, how much light scatters, how much light can pass through, how much light is emitted and so on.

In Blender Internal this is done with materials set to "Volume" type (run Objects > Quick Effects > Quick Smoke to test how basic setup looks like). As fire renders in your case, it has volume material; it's just that it behaves a bit not as expected. As desired result is to get fire of shiny colors, all that is left is to change some settings of the material.

Depending on your needs, in your domain's material settings decrease Emission to something around 1 and Scattering to around 0,1 - 0,9; that should give you the effect you're aiming to:

Note: smoke and fire textures of Voxel Data type were used in this example. This is not discussed here as it's whole another topic, albeit related; Quick Smoke was used to get their setup quickly.

Emission will control how much light is emitted by the volume because of some processes happening there (note - sources of outside light are not taken into consideration). Fire is one of them and it should use that option because it produces light (along with energy) while burning. From manual:

  Some volumes can emit light where there was none before, via chemical or thermal processes, such as fire. This light is generated from the volume itself and is independent of light coming from external sources.

However if emission is set too high (like 2 or more) with Scattering set high too it will produce effect of dark volcanic smoke and not fire. This seems to happen mostly because the options work independently - scattering effect doesn't know what's going there with emission and amount of emitted light doesn't care how much of outside light could travel through; hence strange (and / or unexpected) effects that could be produced.

Scattering controls how light travels through the volume (i.e. fire in this case) and make adjacent amount of the former not to reach distant parts of a volume. From manual:

  The amount of light that is scattered out of the volume. The more light that is scattered out of the volume, the less it will penetrate through the rest of the volume. Raising this parameter can have the effect of making the volume seem denser, as the light is scattered out quickly at the ‘surface’ of the volume, leaving the areas internal to the volume darker, as the light does not reach it.

By playing with these options you can create different effects; e.g. if setting emission to some high value like 150 and Scatter to 0.2, kind of fire of low burning temperatures will be achieved:


Volumetrics with an alpha background, can it be done in cycles?

You can try using a larger cube or a sphere and lessening the density so that it fades off more slowly.  But the reason it's rendering so slowly is that volumetrics are hard to compute.  What might be better for you is to render it without the volumetrics and instead use the "Glare" node in the compositor (Note, you need to use the "Mix -> Screen" node to get "Glare" to work with transparent backgrounds.  See the example below).


Nevermind, figured it out. Turns out I was rendering with the RGB preset instead of RGBA.

EDIT: Expanding upon my explanation: I was getting a brown background whenever I didn't check "use alpha" on my output node. So I checked that and it solved that problem. I was getting a black background on my render images because of my answer stated above. On your render options in the properties tab, right next to the type of file output you have 3 options: BW, RGB, RGBA. I was rendering my images with the RGB preset, which stands for Red Green Blue, instead of RGBA which stands for Red Green Blue Alpha. So it makes sense that it previously wasn't rendering my alpha background.


How do I add physics to cartoon styled hair?

You have to create a flat hair mesh and apply the physics on it. Then you need to add a Surface Deform Modifier on your hair model to take the transformation information from the flat hair mesh. This method works especially well on long hair. The setup would look like this:

When working with Surface Deform keep in mind to cover your  entire hair model with that flat hair mesh. And also do me a favor and make a better flat hair mesh that I did here. It was just a really quick prove of concept.


How to find the UV vertex count? is there a script to do so?

This is a little rushed, and I still need to test it a little bit more, but it seems to return the correct number of UV vertices for simple meshes. UV unwrap your mesh and run this script in object mode:

import bpy
from collections import defaultdict

mesh=bpy.context.active_object.data

uv_layer = mesh.uv_layers[0].data
verts=defaultdict(list)
loc=defaultdict(list)
count=0

for p in mesh.polygons:
    for l in p.loop_indices:
        index = mesh.loops[l].vertex_index
        uv = uv_layer[l].uv
        co = mesh.vertices[index].co
        if (len(verts[index]) == 0):

            verts[index].append(round(uv.x,2))
            verts[index].append(round(uv.y,2))

            loc[index].append(round(co.x,2))
            loc[index].append(round(co.y,2))
            loc[index].append(round(co.z,2))

            count+=1
        else:
            uvs=verts[index]
            if(uv.x!=uvs[0] or uv.y!=uvs[1]):
                nIndex=len(verts.keys())

                while(len(verts[nIndex])>0):
                    nIndex+=1

                verts[nIndex].append(round(uv.x,2))
                verts[nIndex].append(round(uv.y,2))

                loc[nIndex].append(round(co.x,2))
                loc[nIndex].append(round(co.y,2))
                loc[nIndex].append(round(co.z,2))
                count+=1

uvco=[]

for f, b in zip(verts.items(), loc.items()):
    uvs1 = f[1]
    locs1 = b[1]

    for j, k in zip(verts.items(), loc.items()):
        uvs2 = j[1]
        locs2 = k[1]

        if (uvs1[0] == uvs2[0] and uvs1[1] == uvs2[1] and locs1[0] == locs2[0] and locs1[1] == locs2[1] and locs1[2] == locs2[2]):
            uvco.append((uvs1[0],uvs1[1],locs1[0],locs1[1],locs1[2]))

duplicatesStripped = set(tuple(i) for i in uvco)

print("Unique UV/Vertex coordinates: %s\n" %  duplicatesStripped)

print("There are %d UV vertices" % len(duplicatesStripped))

It's a little bit very messy, but I have to go to lunch now, I'll continue testing it when I get back


cegaton is correct.  Thanks.

Now I have to figure out how to get access to the alpha channel in Cycles.  Looks much harder.

-doby


How to control light spread in a volume?

You'll be better off with a Spot or Sun lamp.
Sharper shadows can be achieved by decreasing Volumetrics density.

Spot lamp

for straight rays decrease the spot shape Angle value
for harder shadows increase power and Blend value

Sun lamp

keeps rays perfectly straight
for harder shadows increase strength and decrease angle

Example of a Spot light with a narrow cone (8°).

Example of a sun lamp with perfectly parallel rays.


You can Batch Rename objects in the Outliner (since 2.81)
Shortcut: Ctrl + F2


How do I model a transfusion blood bag in Blender?

Here are some tips for modeling a very simple blood bag.

1) Use Subdivision modifier to get that smooth shape.
2) Use Mirror modifier for perfect symmetry.
3) Keep quads everywhere, so you can use loop cuts

1) Inner and outer shape
- start with a simple plane and create the inner shape
- add loopcuts, move vertices.
- use Subdivision modifier to get the smooth shape.
- Use Mirror modifier for perfect symmetry and to save time.

use the same approach to create the outer shape
make sure it connects nicely to the inner shape and there are no n-gons

position some loopcuts for the tube openings.

2) Add some thickness
We need some thickness to create tube openings.
You can add some loopcuts inside the edge to better support the geometry.

3) Create tube openings  (you can apply the Mirror modifier before that)
- add a circle and prepare an empty the loop on your bodybag (by removing the faces inside)
- connect through Edge > Bridge Edge loops.
- make sure that the number of vertices is the same. (8 in my case)
- If you want more vertices in your circle, just add more loopcuts.

Add some loopcuts for sharper edges.

Here is the file:

And the reference image I used:


Power of 2 style grid and grid scale subdivision hotkeys

You can set up your hotkey with wm:context_scale_float and set the scale to 2.0 and 0.5 respectively, for 2.8 the Context Attribute is now space_data.overlay.grid_scale.


Adding bevel altering the geometry and I can't create loopcuts

That geometry won't be beveled as expected because you're trying to do that on non-planar Ngon consisting of 8 vertices:

Instead dissolve unneeded vertices, and join those on the left to make solid corner:

The selection on the screenshot is an added loopcut which is better to create to avoid Ngon in the middle (however one from the right side is left which is also best to avoid).

Then there won't be any spikes because the corner will be bevelled equally in all directions.

See also related posts - Bevel tool creating intersecting faces, Can't bevel an NGon


Access texture that has been altered through texture nodes

Working with Node Editor, you are actually creating a new texture.

Check whether the texture name in the ToolShelf corresponds to the texture block.


I found out what exactly went wrong here. The view was locked to the object. So I somehow pressed a key combination that made the current object be the target for locked view.

If this occures to anyone else, press N whilst your mouse cursor is in 3D view window. Scroll through the opened panel, until you find the "view" one.

Now delete the target by clicking on the "x" as shown in the picture. This solved my problem.


Why does the rotation of the material on my Earth model shift in the viewport Material view? This one uses cycles and nodes

This was a bug, which is fixed in the version 2.78.


Weird connecting lines with no edges/vertices

This is because you have a non-planar ngon, i.e. a non-flat face with more than four sides. This is particularly problematic with an ngon as blender has no indication of what the topology should be inside the face, resulting in ambiguous geometry. For display purposes there must be something there, so it takes a guess.

You should try to avoid such faces, as they will not behave well with subsurf or deformations (to name a few issues).

To fix this, you can either

Delete the face and fill in the hole with planar quads. Grid fill might be of help here.
Triangulate the face (⎈ CtrlT), splitting the large ngon into multiple planar triangles:

You could also try Mesh > Cleanup > Split non-planar faces.

Note that this still won't subdivide or deform nicely.


Why can't I save my rendered animation as video?

Make sure you have saved the file in a folder you can remember. You must do this before rendering the animation using the folder icon in the output settings or it will be saved in your tmp folder.


Part of my model won't show in cycles Render

Set duplication in object panel to none, you have set it to group. When the duplication is active the parent doesn't render


Cut both top & bottom of the mesh with knife tool

as you see in manual , you only press z in order to Cut through


Is it possible to create Radial scrolling UV motion without scaling?

It's hard to say in detail without knowing exactly what you need, but some variation on this might serve your purpose:

Here, the nodes are being used to control simple color bands, keying the offset on Length, but they could be used to control the UV look-up of a suitably mapped texture, for hand-drawn, or other effects


Model little cracks on the surface of an object

Well, to alter the physical appearance of a mesh without manually doing it (i.e using a non-destructive workflow), you would want to add certain textures that control the depth of some parts of your mesh, which is what cracks do.

There are 2 main ways to do this:

1) Using a displace modifier, which I and most other artists don't recommend unless you want to overlay it with some sort of particle-system, and

2) Giving some bump in the nodes.

The method we are going to explore is doing this via nodes. I'm not going to explain what they are; although you can read up about them here.

So, to start off with, what are normal and bump maps? Well, they are both used to create a fake perception of depth. This is imperative. They do not displace any actual geometry, but make it seem as if they had in render mode. For the purpose of this answer, I'm going to use bump maps, which convert grayscale values to depth, simply because they're easier to create procedurally.

Bump maps take textures like this:

and then convert them into depth. Generally, brighter values mean more coming-outwards and vice-versa, although it can be inverted. Let's get started then!

In the node editor, in the normal area of the default Principled BSDF material of the material applied to your object, add-in and plug-in a Bump node. Then, add a Voronoi Texture. This is what will control our bump values.

Change the 3D to 4D, and then choose Distance To Edge. Turn the scale down to something you like, then connect the Voronoi Texture to the height input of the Bump node. Check invert on the Bump node. Great! You have cracks now! Although they don't look like how you expected, so add in a ColorRamp node between the Voronoi texture and Bump node. Enable the Node Wrangler addon, and then Ctrl Shift Click the ColorRamp node to view it. Move the sliders around to your liking (the closer white is to the left, the less bump in the area between the cracks, and the more right the black slider is, the more outlined the cracks are).

This is where we are right now:

Here, you can end. You have achieved making cracks. However, you could still do new things, such as add colour to the cracks and stuff!

Or you could add image textures instead of flat boring colours! Go crazy.

(Documentation?) links where you can learn more about these techniques:

Bump Node

Normal Mapping Node

Introduction to Nodes...

There's a lot. I suggest you start with those however. Hope this answer helped you!


How to create explicit (parametric) functions in animation node?

Parametric surfaces are very easy to create. A parametric surface is defined by two parameters—usually denoted by $u$ and $v$—that have a certain range and a parametric equation that maps those parameters to a 3D vector. To discretize the surface, we let $u$ and $v$ range in their defined range with a certain uniform step size and apply the parametric equations to get the locations. An implementation of your second example is as follows:

To construct a surface from that, just use the polygons of a grid, because the structure of the output points is inherently similar to that of the grid:

The first example is a subset of what we just created, where it is simply defined to have the X equation to be $u$ and the Y equation to be $v$. Or more simply, it can be treated as a multi-variable function of the x and y locations of a grid points. In fact, the second example can also be described as a multi-variable function of the x and y locations of a circle mesh of a high inner loop count. You can implement this yourself as a practice.


You need to mark all the vertices as root.  So..

Select NurbsPath.005
Get into Edit Mode.
Hit a twice.
Goto the Skin Modifier Panel and hit Mark Root.
While they're still selected, you can hit Ctrl + A to tweak the thickness of the web.


How can I place multiple objects on the mesh?

You can also use Face snapping for this.

Enable Face snapping > Median (to snap with origin point)
Check ✓ Allow Rotation to Target (to match face orientation)
Position the rivets


Is there any relation between Movie Clip Editor and Video Sequence Editor?

In the Movie Clip Editor you can define the duration of the clip by setting start and frame offset and using the Footage settings tab.

The events on the Video sequence editor are not connected with the Movie Clip Editor in any way. The VSE has its own viewer, unrelated to the MCE . You can only load Strips and edit on the VSE. The 3D scene can be loaded into the VSE as a strip, but the events on the VSE are not available in the 3D environment. There is an addon to send VSE strips to the compositor and back (link to blenderartist's thread), but it's not a fully implemented solution yet.


Baking problem (selected to active- cycles)

I already figured it out. I left Mask modifier on my high poly mesh. I had to delete it in order to continue baking all highpoly meshes onto the lwopoly.


Smoke Domain and Smoke Flow Objects have to be different objects. An object cannot be Domain and Flow.

To change the settings for Flow, select the flow object and then modify the flow settings.

From the Blender Manual:

  At least a Domain object and one Flow object are required to create a smoke simulation.

  A basic workflow looks like this:

  Create a Domain object that defines the bounds of the simulation volume.

  Define a Flow object or objects which will emit smoke and fire.

  Set Collision objects to make the smoke interact with objects in the scene.

  Assign a Volumetric material to the domain object.

  Save the blend-file.

  Bake the simulation.


How to implement an automated render farm with remote access?

If they are connected to the internet, try Sheepit. If you run their client on each computer they will render for the farm and if you upload a project it will first be rendered on your own hardware so easy to setup, everybody wins. Unless 500MB file size limit is too little for your scenes and you want to use exr output with passes and render layers instead of only png that Sheepit supports. But it has the advantage of being very easy to set up.
If I am not mistaken, some of their software used for the farm is open source as well, so it's worth exploring if it may be possible to use it to setup your own farm as well.


How to call a function on change in Enum dropdown list?

Use the update argument of the EnumProperty.

import bpy

def maskIt(self, context):
    print('called and changed to,', context.scene.MyEnum)

class LayoutDemoPanel(bpy.types.Panel):
    """Creates a Panel in the scene context of the properties editor"""
    bl_label = "Layout Demo"
    bl_idname = "SCENE_PT_layout"
    bl_space_type = 'PROPERTIES'
    bl_region_type = 'WINDOW'
    bl_context = "scene"

    def draw(self, context):
        layout = self.layout
        scene = context.scene
        layout.prop(scene, "MyEnum")

def register():
    bpy.types.Scene.MyEnum = bpy.props.EnumProperty(
        items = [('Group 1', 'Group 1', 'Group 1',1),
                 ('Group 2', 'Group 2', 'Group 2',2),
                 ('Group 3', 'Group 3', 'Group 3',3)],
        name = "Mask the MESH",
        default = 'Group 1',
        update = maskIt)

    bpy.utils.register_class(LayoutDemoPanel)

def unregister():
    bpy.utils.unregister_class(LayoutDemoPanel)
    del bpy.types.Scene.MyEnum

if __name__ == "__main__":
    register()


From a material's name, automatically "fill it in", and have it point to a same-named image texture

Under the assumption, that you have one 'Image Texture' node in your material setup and all the image filenames are unique, it should be something like :

for material in bpy.data.materials:
    #loops through all the materials
    mname = material.name
    #get the name of the material
    img_fname = "{}.png".format(mname)
    #get mname.png
    img_full_path = "path/to/image/files/{}".format(img_fname)
    #get path to image, including the image
    bpy.data.images.load(img_full_path, check_existing=True)
    #load the image to the internal database
    material.node_tree.nodes['Image Texture'].image =bpy.data.images[img_fname]
    #assign image by filename to material image texture input

You need to work out the path to the image files. Best to open the python console and try to load one image manually, using the

bpy.data.images.load()

command, then insert the base path that worked.

Edit: img_fname was in quotation marks in bpy.data.images. That would not have worked.


How to render separately multiple objects on the same scene, without using multiple render layers?

As far as I understand, you need to, under one scene, render more than 20 object separately, here's one solution :

under the object tab, in the properties panel, assign each of your object a single Pass index, "1" for the first object, "2" for the second, etc...

Once this done, go to Node Editor, select the compositing node tree and choose use node

Under layers tab, activate de the object index pass

connect the IndexOb pass to an Id Mask node. Make sure the pass index in the Id Mask node correspond each time to your pass index's object. Connect the Id Mask node to the fac of a Mix node, & connect the image from the render layer node to the second input image of the mix node, as shown in the image below. Repeat this process for every object you want to render separately (and don't forget to change the ID mas node number to your corresponding object)

You can repeat this process as long as you want, with all you objects, and then assign a different output location to each ones, with the file output node :

EDIT : Actually, this solution isn't perfect, because if other objects are in front of the rendered object, the overlapping part will mask the second...
Another solution, a lot simpler, is simply to uncheck the render button in the Outliner panel, but you'll need to check and uncheck for the corresponding object every time you want to render a single object, and change the folder each time too.


Changing the distance between vanishing points

Set the Focal Length to a smaller value to adjust the perspective.

The Focal Length can be set separately for any Camera as well as for the Viewport. To adjust the Viewport, simply open the Properties panel of the 3D Viewport (press N) and scroll down to View as shown and change the 'Lens' setting.

For the Camera, select the Camera and open the Camera properties panel and change the Focal Length as desired.


Help with achieving the "Opposition Effect" in cycles

You can create dense geometry only where needed with Adaptive Subdivision and displacement in Blender. It's still an experimental feature, but seems to work quite well.


Blender denoise node producing black image

I'm experiencing similar issues on Blender 2.83 on Arch. I believe it to be related to a bug in OpenImageDenoise (oidn) or in the way Blender is trying to link it. I was able to fix the issue on my system by downgrading to openimagedenoise 1.1.0-1.

I'm currently investigating as to whether this issue is documented in the appropriate project, and will update this answer once I have a bug number for it.


Are there any disadvantages to starting blender with the --enable-new-depsgraph argument?

You can watch and track any Dependency graph bugs here:

developer.blender.org > Dependency graph

All of the tickets look resolved now. There are no disadvantages that I know of.

However you never know if somewhere is a bug or not before you test it. If you work in a production environment you probably already test everything before you use it. If your tests are fine I would use --enable-new-depsgraph with ease in mind.


How to render a shadow without the object in the scene

If your computer is unable to render an image (insufficient RAM?) with the train included then it will most likely have the same issue if you try to use it to render the shadows. You may want to render the entire image on another computer that can cope with the entire scene in one go.

One thing that can work is to create a low poly mesh for the train, a simple outline of the shape that will cast a visually matching shadow. By rendering the background with the low poly train you can get the ground with shadows and then later composite the train over the top.

Using cycles you can have an object cast shadows and not be visible to the camera by setting the Ray Visibility options, found under object properties. By turning off camera the object will not be visible to the camera but it will still cast shadows and reflections on other objects. If you want to merge this into your materials you can add a Light Path node.

For blender internal the material settings have a similar option called cast only under shadow options.

Edit: In a cycles material you can use the light path node to control the mix amount to get an object that is transparent to the camera but still casts shadows.

The advantage of using a material is that you can alter the shadows. By using a translucent or glass node instead of diffuse you get softer shadows and the ability to add a colour tint. You may also want to use the original object material so that reflections also look correct.


How can I make a fluid (smoke) follow a particle system?

I found the issue is with the particle size. The default one is too big, if you reduce the size the smoke will be far better, I reduced the size to $0.01m$.

Change the particle size from: Particle Properties -> Particle Settings -> Viewport Display -> Size


Blender 2.8 - Can't get weight painting to work as expected

How I do it is.

go into edit mode
Select faces you want controlled
Select the shape key and assign the faces to it.

A quick video


How can I create an object that fits in the gap of another object?

This type of cutting actually doesn't require doing a boolean. You can use Knife Project instead.

First, using your T-shaped piece as a starting point, model a flat piece that is the same shape when viewed from the side. You can snap to verts while constraining the axes to do this.

Then, separate this into its own object. This object will cut into your circular one, so first select the cutter object and then Shift-select the circular one that will be cut (order of selection matters).

Tab into Edit Mode and Hide the parts of the mesh you won't be cutting (the T-shaped piece).

Select All, view from the side, and click Knife Project. Enable the Cut Through option in the Operator Panel.

You will end up with a nice clean cut in your mesh.

You can then delete these faces and fill them in however you like.


Hard to catch a vertex because of the gizmo

Credit for the following answer goes to Yegor Smirnov who tweeted about this.

The solution for this problem is to set the Activate Gizmo to Drag in Keymap > Preferences.

The tooltip explains what it does:

  Drag allows click events to pass through to the tool, adding a small
  delay.


When Rendered In Cycles Lamps Seem To Disappear

An area lamp in your scene is restricted from rendering.

Open an outliner.
Select the lamp with the Render icon turned off and enable rendering.


Difference boolean for overlapped objects or any possible alternative

Boolean have limitations, as described in blender wiki:

  Boolean operates best on water-tight meshes, where inside/outside is
  clearly defined.

  The following characteristics are known to give bad output.

  Open volumes.
  Overlapping geometry.
  Self-intersections.
  Zero-area faces.

  While they may not fail in all situations, they aren’t guaranteed to
  work properly.

When you join meshes you create Overlapping geometry and Self-intersections, that makes bad result.

So make 3 separate booleans to avoid self-intersections.

Or maybe try different ways to build geometry, for example Animation nodes or Svercok ?

Or instead of using booleans remove useless parts of mesh manually, in edit mode?


Blender game recording at the wrong time

If your issue is simply that all of your keyframes on the dominoes are starting too late, you can easily fix this by using the dope sheet. Select all of the keyframes in your scene by hitting A (or select just the ones you want by using box selection with B, or circle selection with C). Then simply move them closer to the beginning of your timeline. (shortcut would be G).


How to model a twisted cylinder like this

I would use the Screw modifier for both examples, assigned to simple profile meshes.

Because the longitudinal connections are staggered, this method avoids the creation of twisted, non-planar faces.


This is an anser to your second question.

Yes, you can have textures and materials at the same time. In fact, you can't have textures without materials.

In cycles, you add an image texture node (found in texture, image), and then you select the path to your image, and simply connect that into the color input of the shader you want to color (or node that you want to input a texture to)


How to change radius/weight of curve bezier?

First you need to apply the scale of your object because you must have scaled it in Object mode and it deforms it, so select it and ctrlA.
About the radius, you can either change the radius of the curve vertices or change the radius of the bevel.
For the curve vertices radius, go in Edit mode, select the vertices and altS, or in the N panel (on the right of the 3D View) > Item > Transform > Radius.
For the bevel radius, go in Edit mode, go in the Properties panel > Data > Geometry > and change the Depth.


Blender internal: How to get a plain rendering of an object by ignoring its materials?

To add to the redundancy of answers in the comments:

You don't need to remove the materials for the objects in the scene or alter them in any way. Just select a material you want for the render and use it on the material section for the render layer. All of the other materials assigned for the object will be ignored.

From the Blender manual:

Material Override

  Overrides all material settings to use the Material chosen here.

  Examples of where this might be used:

  To check lighting by using a plain diffuse material on all objects.
  Render a wireframe of the scene.
  Create a custom render pass such as an anti-aliased matte or global coordinates.

EDIT:

Newer versions of blender don't use layers, but "collections" so the override function is in the scene>View Layer section.

Additional info:

Where is the Layers panel in Blender 2.8?

2.8 - Is it possible to assign (override) a material to a whole collection?


There are several ways you can do it; a couple of them:

set a copy rotation constraint on the bone.002, targeting Bone and a copy rotation on the upper bone (local space, if something reotates in a weird direction check axis view in the armature propreties and set the appropriate bone roll to every bone in edit mode).

extrude a new bone from the upper bone and set it as target of an IK constraint of bone.002, lenght 1; set the upper bone to copy the rotation of "bone" as the previous example.


In summary - you can't.

Since Blender 2.5 we've moved on to Python 3.x This means it is not possible to use Python 2.x for scripting in Blender.

Now it's impossible to build against Python 2.x, and even if you did manage by editing the source-code, you'd probably run into problems running Blender, since Blender's own scripts are coded in Python 3.

Setting PYTHONPATH to a non Python 3.3 installation like Python 2.7 will cause Blender to crash and die horribly. (So always make sure you don't have PYTHONPATH set to a non-compatible Python version. But you can use it to point to an external Python 3.3 installation that has extra modules installed that don't come bundled with Blender).

Note: with current Blender pointing to Python 3.1 or Python 3.2 will also fail. So make always sure you point your PYTHONPATH to same version as used in Blender, should you need the external one.

In the long run you'll be better off getting used to Python 3. Also here is the proposal for the switch.


Why is the mirror making secondary lines?

You need to provided a better image of your mesh that covers more detail. But my guess at this point is that your mesh is off center and the current transformation has not been applied.


How to create a detailed moon surface texture for close up shots?

awnsere credits @Nxdhin2005 - Yes close up shots of a wide area of the surface of the moon might work. Ensure that u have a displacement map along with it or you won't get the required craters and detailes...You will get some extremely close textures of the surface of moon. U can use them but the problem is it will cause repeating textures since you will be forced to scale the UV map because of the size of the texture. You can get rid of that by the Uber mapping node from Blender Guru. By this method you can preserve the resolution of the texture.


How to rotate textures? Or how to set texture coordinates?

You can use "Mapping" node: with this node you can edit scale, location and rotation of your texture. Just add it to the node tree of your shader and connect the "Vector" output to the "Vector" socket of your image nodes (try only mask first, and if it doesn't work try with both mask and color/rgh/nrm maps). "Mapping" node needs the "Texture coordinate" node (Shift+A > Input > Texture coordinate).

But I would suggest to properly UV unwrap your plane, so the direction is set in the UV editor once:


The thing, what you want to build will cast loop in parents (circular dependency), it doesn't allow. When Blender calculates bones coordinates, it moves from child through parents to root bone. And if you have loop in parents, blender can't find root bone

To avoid circular dependency you can bild rig like this:

This type of rig you can find in BlenRig, in lips rigging


Digits of precision of vertices coordinates

vertices are stored as 32bit floats (as with all other geometry storage in Blender).

There are no really good ways to see exact floating point values of a vertex in the user interface, Your best option is to print the value in Python.

This behavior is intentional, lots of common values like 0.1 will end up displaying as 0.100000000002,see: https://stackoverflow.com/questions/13345334/strange-behaviour-with-floats-and-string-conversion

For typical usage this isn't helpful.

As a workaround you could scale the object up 100.0x and then set 'Global' in the transform panel, so there is more floating point precision shown though this is not an ideal solution, it may be handy in a few cases.

See also: Video explaining floating point precision - gives some insights as to why this isn't as trivial as you might want/expect.


How to check if two meshes intersect in python with BVH Tree?

yes, overlap in mathutils.bvhtree does show pairs of polygons that are intersecting if any.

You will have to create 2 bvh trees, for each mesh, using one of the methods given in the api (from Object, from Bmesh, from Polygons), then use those as pairs = bvhA.overlap(bvhB)

So a basic check would just see if that list is [] or something. Or may further use the pairs of poly to do something.

Note that there are some limitations

it does not account for other info, if one obj is inside another, normals etc, only if they touch
it does not work for coplanar poly well, for example 2 blender default plane objects, one slightly shifted x (not reliable on this)


You can change the rest pose in Pose Mode Editor and using the menu Pose > Apply [Ctrl+A] > Apply Pose as Rest Pose.

HOWEVER, you will destroy your animation: this "rest" pose is the base for the animation data, all transformations are made using this bone orientation.

EDIT:

As @batFINGER wrote above (about a similar thread: https://blender.stackexchange.com/a/53981/15543), I got the procedure working (with Blender 2.78a) in the following way:

Pose your model to the new rest pose (without keyframing);
Run the "script 1" (retarget_pose.py) to generate UI buttons (under Properties Editor > Object Data Tab);
Click "New Rest Pose to Rig" (it will duplicate the bones - inside the same armature - with the new rest pose);
Click "BVH action to new restpose rig" (it will correct every keyframe of the animation);
Manually delete the original bones (as I could not make the "script 2" - the one posted in the thread - work);


How to merge intersection of an object with itself?

Per the comments, a watertight mesh can be generated using Boolean operations as long as each of the tori in the model are watertight.

Steps:

1) Start with the mesh with all of the tori. This example was formed by adding a single torus, then using array modifier and applying the modifiers. If you look closely, all of the tori are in a single mesh, but not connected.

2) Add a cube that encloses the tori mesh.

3) Apply a Boolean modifier to the tori mesh. Change the solver to 'carve'. Click apply.

The resulting mesh is watertight and has clean meshes.

Blend file prior to applying the Boolean operation -

To make the tori a pattern on a solid backing, a union Boolean operation can be used to join these tori to the solid backing.


How do I increase line width in 3D Viewport?

Unfortunately there is (still) no setting for the thickness of the lines in the 3D view.

This is for 2.79 and up

One of the things you can do is change the Line Width to Thick.
Now that will make the viewport nice and visible, but also increase the thickness of every line in blender's ui.

The Scale changes the size of the ui elements. The interesting thin is with Line Width on auto, if the increase the Scale above 1.78 it will make the lines in the 3D view thicker, yet not as thick as the Line Width option make it.
This however also has some serious downsides, now blender is at a size that is just too big. You can decrease the size of each panel, but the headers will remain too big.

Line Width, and Scale is found in the Interface tab of the user preferences.


How to Return Camera View Back to the Origin?

View > Align view > Center Cursor and View All Shift+C

OR

Select an object from Outliner and:
View > Align view > View Selected Numpad .