you can use this setup (which is essentially just a copy of what Easy HDRI just does for you automatically):

the good news: you made the node setup right.
the bad news: you have to change some parameters so that you can really see your background through your camera.
So first change to camera view and then zoom out. If you are zooming out far enough you will see the background image.
If you then "play" with the values (yours can differ) you can "push" your background image to the right place behind your camera.
my settings to "see" it were:

result: (after i changed your composite nodes to this:)

UPDATE ----
you can do it like this:
BUT...the more you glare (with fac) the less you will see the background.


Splitting / matching faces on cone to get the faces to match when wrapped around

The 2 vertical edges are ripped:

If I select a vertex, here is what it gives (so you can't join the 2 opposite vertices):

So you need to delete these 4 faces + one horizontal edge that is under the faces (as pointed out by Batfinger, probably the result of a fill (F):

Then select the top and bottom row of vertices and press CtrlF > Grid Fill:


If you want to keep the scale the same across multiple Blender projects set the scale to the same units and also keep the unit scale the same in all of your projects.

It can be done in the Properties Editor, Scene tab under Units section:


How to convert rotation_axis_angle to euler or quaternion via Python?

Via mathutils.Matrix.Rotation constructor.
Given an axis angle rotation provides just that, can make a matrix from the components.
Matrix.Rotation(angle, size, axis)
>>> q
Quaternion((0.44383183121681213, -0.3263395428657532, 0.8345092535018921, 0.010497181676328182))
>>> axis, angle = q.to_axis_angle()
>>> R = Matrix.Rotation(angle, 4, axis) # or size 3
>>> R.to_quaternion()
Quaternion((0.44383174180984497, -0.3263395428657532, 0.8345093727111816, 0.010497150011360645))


The denoiser is only suited to certain situations - in some cases it can actually cause unwanted artifacts and noise; it is generally best suited to well lit, less noisy renders to tidy up a small amount of noise or bright spots caused by caustics. In your case your raw render simply contains too much noise for the denoiser to produce consistent results between different frames of the animation.

To demonstrate, I created a noisy test scene with a banded material similar to your 'skin' and rendered three times : without the denoiser, with the denoiser, with more samples.

Here's the 'raw' noisy render (32 samples) :

The denoiser can help considerably for individual frames but when animated the denoising slips between frames causing artifacts (click the image to see it full size) :

Note how the darker benoised areas seem to wash around and move in subsequent frames of the animation.

An alternative to the denoiser is to simply render with more samples (256 samples) :

This takes more time to render but produces much more consistent images between consecutive frames.

It's difficult to see from the above images so here is a comparison on a zoomed section of the denoised and more sample animations :

Denoised :

More samples :

Note the fuzziness caused by the denoiser throughout. The 'more samples' result is generally much more stable (except where the banding is inteferring with the pixel width - causing the rippling at the start/end).

So, in summary, in your particular case, the details of the 'skin' and the low light and shadows are a case where the denoiser causes considerable artifacts. It would be acceptable for still frames but not for animation. Your only solution is to disabled the denoiser and render with more samples (but this will considerably increase render times).


How can I create one uv map for multiple objects?

In Blender 2.8 and beyond you can enter edit mode with multiple objects selected.

Before Blender 2.8

Simple answer: "you can't"

Because a UV map pertains to each individual object, and only shows in the UV/Image editor while in edit mode, you cannot combine UV maps, or see multiple maps at the same time. (You can only enter edit mode for one object at a time.)

Longer answer: "you don't have to"

Most likely, your best solution is to select all the meshes (not cameras or lights) and press ctrl+j to join them into one mesh. Now you can unwrap them all as if they were one mesh, because they are.

Tip: You may want to reset the origin after doing this. (ctrl+shift+alt+c) -> "Origin to Geometry"

There are also some add-ons that help with generating UV maps that fit with others in the scene, for creating one large texture for all objects, instead of many different textures for each object. Try pressing ctrl+alt+u and typing "UV: Texture Atlas" in the add-on search box. This might help you.


Here's what your file looks like rendered with the Sun lamp strength set to 4 (it was set to 1):

The key to having a good "fluff" is a wide dynamic range. Dynamic range is the distance between the brightest and darkest parts of an image. See Render with a wider dynamic range in cycles to produce photorealistic looking images for a good introduction to a whole rabbit hole of lighting, grading, and generally managing the dynamic range of your scene and image.

The simple answer

For the simple answer, suffice it to say that the sun is bright. By making the sun lamp significantly brighter than other light sources, you'll start to get an increased dynamic range and clouds will take on more of a "fluffy" look (bright highlight falling off to shadow) when seen from the side.

By using a bright sun lamp and messing with camera settings (exposure, contrast etc.) to get the final image to have the overall brightness you want, you can get a decent physically-based-ish result without too much fuss.

The proper answer

We know that the sun lamp energy in Blender is measured in terms of irradiance, or the amount of energy (light) from the source hitting another object at a given point in time (the exact units are Watts / meters²).

The Sun's irradiance measured on Earth varies over a whole host of things, not least of which is how much atmosphere the sunlight must go through. Assuming we are simulating light scattered by the atmosphere separately (e.g. with an emissive sky texture), we'll want to make the sun strength something like 1050 W/m². If instead we are sparing no expense and simulating the atmosphere with a large volumetrically scattering object, we'll want to include atmospherically scattered light in the sun lamp and make it more like 1361 W/m² (taking values from Wikipedia).

If this seems insanely bright, that's because it is (have I mentioned the Sun is bright?). By using Sun lamp values around the default of 1, we're putting our Blender scenes over 4,300,000,000 km farther away from the Sun than the Earth (somewhere beyond Neptune)!

Here's an example with a 1050 W/m² Sun lamp, a 300 W/m² sky, and a camera exposure of -7 (with filmic):


Yes, it is possible. It turned out that I had to change the hotkeys to use the walk camera in the sculpt mode.


How to avoid vertex sorting after using Offset Polygons in Animation Nodes?

The Offset Polygons node doesn't just transform the vertices/polygons of the mesh, it also splits polygons if they are connected. So it is impossible to retain the order of vertices in most of the cases, and in cases where it is possible, it is not worth it to consider it as a special case.

So if you want to retain the order of vertices, manually loop over the polygon indices, transform the vertices and write them to their respective locations in the vertices list. Let me know if you want more details on how to do that.


If you are looking for it in with other modifiers as subdivision and displace, i dont think you can find it there.
Select the object you want it to be applied and in the editor type (where you go to switch between 3d view and shader editor and all) you will find it there just in between shader and texture node editor options.
And its only available in 2.92 and above. I think . Not sure if 2.91 has it.


smoke&Fire CPU & GPU now getting black box

Don't plug volume shaders into the surface of the smoke domain.

They should be connected to the volume socket.


Blender object and armature jumps up from surface

Found Ctrl + A  on pose resets the position.


How to clear all keys of all objects and bone?

Using scripts

Often for repetitive (& tedious) tasks it is handy to use a small script.

Remove all actions in file

Keyframed animation data is stored in an action. To completely remove all keyframed animation data, can remove all actions in the file.

import bpy
for a in bpy.data.actions:
    bpy.data.actions.remove(a)

Clear all animation data on scene and scene objects

To remove animation (actions, NLA, drivers) from scene objects and scene, but keep the actions in file.

import bpy
scene = bpy.context.scene
scene.animation_data_clear()
for o in scene.objects:
    o.animation_data_clear()


Unfortunately the movie clip editor doesn't seem to have a way to deal with non-square pixels. So your mask is getting created using a frame that is 1440x1080 pixels.

When you bring that into the VSE editor it is stretching that frame to fill a 1920x1080 canvas (as determined by your render settings)

So there are three choices:

1. (The one I would use because I dislike the VSE so much) Use the compositor.

Setup your mask at a fixed size of 1440x1080 and composite using the Alpha Over node.

2. If you must use the VSE. Change your render settings to 1440x1080 with a pixel aspect ratio of X:1.33 Y:1

or

3. Keep your settings the way they are now and deform the mask strip on the VSE:
In VSE you select your mask strip and add a Effect Strip->Transform strip. Then change the settings to use 0.75 on the Y scale to have the mask match the aspect ratio of the original footage.


Does gpu rendering support on gt 730 ddr3 or gt730v2 ddr5?

According to this page in the blender reference manual they claim that

  We support graphics cards starting from GTX 4xx (computing capability 2.0).

I also found both the cards you mentioned in the list of CUDA-enabled GeForce products on this NVIDIA page with computing capabilities listed as 2.1 and 3.5 so I would claim that yes, GPU-rendering does supports those cards, especially the ddr5-model.


You can actually quite a bit with just a few drivers.

Result

I'm not going to explain the entire process, but I'll cover a lot of the more interesting points.

If you haven't already, learn how drivers work (here's a tutorial I made). They're an extremely powerful way to control different object attributes.

For the barrel recoil, I created a driver that makes the barrel follows the position of an empty (the one moving back and forth). The position of each section of the barrel is just controlled by a custom curve (offset for the back section so it follows slower). This is the curve of one section:

There are three bullets at the beginning of the animation hidden in the back of the barrel. I couldn't figure out how to dynamically add them while the animation was playing. There might be a hacky way to do it with a particle system, but I decided that hiding them was the simplest solution.

The first thing to note about the bullets is that they're dropping as they follow the empty. All I did was create a driver that calculates the trajectory of the projectile using the Y position of the empty for the current distance. Because it was long (and hard to type into the expr bar), I just put it in a Python script:

Then all you have to do in the expr box is put: calc_path(x, ang, height, velocity).

Finally, the bullets are set to be animated rigid bodies. That way they can interact with the other rigid bodies in the scene. When I wanted them to simulate and bounce around on the ground, I simply animated the animated attribute in the rigid body settings:

The result isn't completely elegant, but it certainly does cut down on the amount of animation you have to do.

If you're interested in dissecting the .blend yourself, you can download it.


blender 2.83.2 viewport Render image color completely different

https://developer.blender.org/T77909
It's a bug at blender 2.83 may fix it blender 2.9


Problem occured due to an extra object that made the lights not be rendered at that position. Solved here.

[Edit: It was a hidden object of the same scene being still allowed to render. The baking so accepted its shadowing for the texture and made this happen -- Rendering just had to be disabled.]


How to place objects on top of another object and join their geometry

I've been doing this quite a bit lately, but BEWARE, I'm very much a newbie myself, so hopefully you'll get better answers from others.
To join that dome to the cylinder here's what I would do.

I would fist make a duplicate of both of the two pieces (using shift-D) on each, and then I'd hide the original pieces. This is so that I can always just delete the copies, and start over with the original pieces if something gets fouled up. Don't bother renaming the copies yet.
One mistake you really don't want to make is to join two pieces like the one in your example that will have faces touching once you join them! Look at the bottom of the dome. That face on the bottom of the dome, once you join the two pieces, will occupy precisely the same 3 dimensional space as the top face of the cylinder. That will confuse the dickens out of blender. So...
With the copy of the dome, delete the faces that comprise the bottom surface of it. (Delete them, don't dissolve them). Then do the same thing with the faces on the top surface of the cylinder copy.
In the window on the lower right in your example you appear to be in the modifier tab. Switch to the scene tab (the one that looks like a cone with a tiny sphere next to it). If you working in metric, switch to millimeters, if you're working in feet, switch to inches. This will give you finer dimensions to work with.
(since you seem to be having trouble with snapping I'll try to minimize using it, but you'll have to learn how to use snapping sooner or later. Watch a bunch of YouTube videos on snapping, trust me snapping is simply too useful to continue to try to do without. That said I'll try to use snapping as little as possible.)
Engage the measure tool. That's the bottom icon in you're main window that looks like the letter L with tiny lines on it. Go into wire-frame mode, and make sure the x-ray function is off. Click and hold near where you want to begin the measurement, drag to near where you want to end the measurement (kind of like pulling out a tape measure).
Now here's where you'll have to use snapping.
In you're example you appear to be set to snap to faces, switch to snapping to vertex.
Look for a corner on the bottom of the dome that is directly above a corner on the cylinder. (any corner will have a vertex to snap to)
Click and hold on one end of the measuring tool you made. Drag it a short distance in any direction, and while still holding the mouse button down hold the control button on your keyboard down (this engages the snapping action). Still holding the mouse button and control key down, move the end of the measuring tool to the corner where you want the measurement to start and when it gets close to that corner's vertex it will snap to that vertex, and you can let go. You now have one end of the measurement tool anchored to the fist corner. Use exactly the same procedure to snap the other end of the measure tool to a corner directly below the first corner. Check using the front view, and then a side view to make certain that the measurement tool is vertical and not at some angle that will throw off you measurement.
Now you have a precise measurement of how far you have to move either the cylinder, or the dome in the Z direction to get them to meet. Write it down!
I assume you know how to move them once you know how far to move them.
Once you've completed the move you can now join the two.
Once you've joined them, go into edit mode, select all (I use the hotkey A to do that), then go into Mesh, Clean-up, Merge by Distance and set the distance to more than the default, but much less than the shortest distance between any vertices. (your diameter is 42mm, so set the distance in the merge to say 5mm. If lines start jumping all over the place it means your merge distance is too high. Keep decreasing the merge distance until things merging that you don't want to merge stop doing it.
Keep an eye on the little blue boxed note the pops up at the bottom of the screen, it will tell you how many vertices where merged. If you keep seeing 0 vertices merged, that's not good. Think about it. The bottom of the dome and the top of the cylinder form circles that are essentially identical. Which means when they are joined you're now going to have 2 vertices at each corner making up those circles.  That's going to give you bad geometry. So keep increasing the merge distance until the little blue pop-up window shows that you've merged at least a dozen or so vertices.

Decrease the merge distance whenever it deforms your geometry, Increase the merge distance whenever you get a value of 0 vertices merged.
Many times, like when you use booleans, you will sometimes get 0 vertices merged, and it's ok, because there weren't any vertices on top of each other that need to be merged. But it this particular case you know for a fact that there are going to be vertices on top of each other because you just finished joining the circles at the bottom of the dome to the circles making up the top of the cylinder. So there has to be some overlapping geometry there.
You can keep changing the merge distance until you click on something. If you do a merge that fouls things up, there's always Control-Z to undo it.
Once you've finished, and the two copies are now one piece, it's finally a good time to rename your new object.
Hope this helps, Mike.


Is there a way to tile only a part of a texture?

This is not possible the way you describe it. What you would usually do is either one of:

If the rest of the eye is only a single color, you can rescale the UVs for these parts and even overlap them. (In this example you could also cut off most of the white in the texture)

If the rest still needs more than a single color, but less details, and you want to use tiling, then you should use two different textures.


Can any one give me tips on how to make a certain material with nodes?

It seems you want to draw triangles going outside a point, lots of them. The basic setup is this:

By fiddling with those values you can get various shapes:

Then you can use a Voronoi texture to get random positions:

Instead of using Voronoi you might want to have a simple mathematical formula to calculate which cell you are in and where's that cell's center - then you can try some tricks like add a transparent color to the color ramp (where the black is currently), and use Alpha as a check if the pixel is "empty" - if so, draw a triangle from the nearest cell. Or you can just use that alpha to merge multiple such textures together:

You could make the stars less regular by e.g. multiplying the gradient texture by the number of triangles, and rounding it to get the triangle number, then e.g. do a modulo 2 to detect if the triangle is odd - if so, draw a black (transparent) pixel - or even better, calculate the distance to the center (the middle line) of the next triangle, so that you don't draw a black line near the center where the triangles overlap. You could also replace Voronoi with mathematically defined slopes ("Multiply Add" -> "Greater than") and allow some triangles to pass it, while some others to not pass it (and then those slopes could be other triangles). Possibilities are endless, though your node count will grow fast.


How to enable ambient occlusion in the Viewport with Python?

These types of properties are properties of the 3D view, and so that's what you need to access to access them.

This following code accesses the Ambient Occlusion property but this is dependent on how your screen is laid out:

bpy.data.screens['Default'].areas[4].spaces[0].fx_settings.use_ssao = True

'Default' relates to the current screen layout and 'areas' to the various views that might be open (we need the 3D view). The problem with this is if the screen layout changes then the 3D view might not be in areas[4] anymore (as the list of areas will have changed). To solve this we can instead use the following code which will loop through the areas until we find a 3D view:

for area in bpy.context.screen.areas:
    if area.type == "VIEW_3D":
        area.spaces[0].fx_settings.use_ssao = True


You can do this with the special text property only found in text objects.

In this case, I am using Always ➨ And ➨ Property

The property actuator copies another property from a different object.
I am using the cube from this question to change the properties so you can see it updating.

I have two text objects, neither one of them have been transformed into a mesh. they both retain there edibility as a text object.

In this example, the text is white. see this question to change the text color.


Why Isn't Mirror Tool Working Correctly?

I figured it out.

After you rotate and delete some vertices, you must apply the rotation.

Object>>Apply>>Rotation.
Ctrl + A, then R.


Donut glass cup render has too many grains and speckles + denoiser come out distorted, shadow is also too opaque. What settings may I try out?

I just loaded your file and did this: checked both denoising checkmarks

viewport result:

render result:

is this ok for you?


How do I paint (wrap) a texture around a mesh with even texture dimensions?

I would suggest with tiled patterns like this that you actually avoid manually painting until you have to deal with seams on your object. If you can use quads on your mesh, reset the UV unwrap for mapping all faces to a single tiled texture and you can then make use of Follow Active Quads to change up the mapping. Scale the UV up and down in the UV editor and you can manipulate the mapping with realtime feedback.


The following code will remove all screens from bpy.data.screens except the last one (because there must always be at least one screen):

import bpy

for screen in bpy.data.screens:
    bpy.ops.screen.delete({'screen': screen})

There is no RNA method to remove screens. In general, you shouldn't deal with screens a lot with Python scripts, because the API is incomplete and not fully working (joining is buggy and requires coordinates of the split/join widgets for instance).

Modal areas like the file selector a special, as well as other maximized areas, which create a additional, temporary screen.


Best way to UV unwrap a hole in the shape of a triangle?

I would cut out the whole "X section" and cut off two of the legs.


Render region and render with 1 keystroke?

I took p2or link and modified a little. After running the script, shortcut key is Shift + Q.
def register() part has type = "Q" and shift = True alt = False and ctrl = False.

bl_info = {
    "name": "Toggle Simplify",
    "description": "Toggle Simplify",
    "author": "poor",
    "version": (0, 0, 2),
    "blender": (2, 79, 6),
    "location": "3D View",
    "category": "3D View"
}

import bpy

# operator
class ToggleSimplify(bpy.types.Operator):
    """Tooltip"""
    bl_idname = "view3d.toggle_simplify"
    bl_label = "Toggle Simplify"
    bl_options = {'REGISTER'}

    border = bpy.props.BoolProperty(default=False)

    def execute(self, context):

        if bpy.context.area.spaces.active.use_render_border:
            bpy.context.area.spaces.active.use_render_border = False
            self.border = False
            bpy.ops.view3d.toggle_render()
        else:
            bpy.ops.view3d.render_border("INVOKE_DEFAULT")

        context.window_manager.modal_handler_add(self)
        return {'RUNNING_MODAL'}

    def modal(self, context, event):

        if not self.border and context.area.spaces.active.use_render_border:
            bpy.ops.view3d.toggle_render()
            self.border = True
            return {'FINISHED'}
        return {'PASS_THROUGH'}

addon_keymaps = []

# register
def register():
    bpy.utils.register_class(ToggleSimplify)

    # handle the keymap
    wm = bpy.context.window_manager
    kc = wm.keyconfigs.addon
    if kc:
        km = wm.keyconfigs.addon.keymaps.new(name='3D View', space_type='VIEW_3D')
        kmi = km.keymap_items.new(ToggleSimplify.bl_idname, type='Q', value='PRESS', shift=True, alt=False, ctrl=False)
        addon_keymaps.append((km, kmi))

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

    bpy.utils.unregister_class(ToggleSimplify)

if __name__ == "__main__":
    register()


Tracking moving points on a reconstructed plane

Information Download

When you have a point that you have tracked in the Movie Clip Editor, you generally use it to solve camera motion. Occasionally, like in a VFX scenario, one might deploy a style called Two-point Motion Tracking. This uses two tracked points, reconstructed as empties that will move on an X/Y Plane. In the linked video, the narrator goes on to show that if you have a dowel rod with sharpie at the top and bottom (points for tracking), and you track those points, you can stretch a glowing cylinder between them and make it look like the person is wielding a lightsaber.

Your Scenario

In your case, you will probably be looking at a type of One-point Motion Tracking, except with multiple one points for each scenario.

You will want to be happy with your camera track. After tracking the animals, re-solving the camera motion will be a pain to not possible.
Track an animal.
Go to Bottom toolbar > Reconstruction menu > Link Empty to Track. There should now be a Plain Axes Empty connected to the Camera by a dotted blue line.
In the 3D Viewport, switch to Local Transform Orientation.
Move the Empty as close or as far away from the camera as needed (probably along Local Z).
Parent your animal (I assume) to the Empty.

Hope this helps and happy Blending!


How can I copy weights to another mesh which has another rig?

You can copy vertex groups (and corresponding weights) from your first sphere to your second one :

Select second one first
Then select first one
Use "Copy Vertex Group to Selected"

If deformation bones have same names in both Armature, it will work.
Else, you need to rename your Vertex groups to fit deformation bone names.


Existing Frame Trimming Capabilities of Actions

I took the lack of responses to mean that there was no really clean way to do this, so no re-invention would be done.  So just did it.  Made as a simple class in a separate file for simplicity, but also means I can just cut & paste.

from mathutils import Quaternion, Vector, Euler
import bpy
#===============================================================================
class AnimationTrimming():

    def __init__(self, armature):
        self.armature = armature
        self.action = armature.animation_data.action
        self.first = int(self.action.frame_range[0])
        self.last  = int(self.action.frame_range[1])
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
#                         operation entry points
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    def deleteAndShift(self):
        # drop from the front up to, but not including, the current frame
        firstGoodFrame = bpy.context.scene.frame_current
        self.dropRange(self.first, firstGoodFrame)

        # shift remaining keys on a bone, property basis, to the left
        for bone in self.armature.pose.bones:
            rotProperty = 'rotation_quaternion' if bone.rotation_mode == 'QUATERNION' else 'rotation_euler'
            self.shiftLeft(bone, rotProperty, firstGoodFrame)
            if self.hasLocationKeys(bone):
                self.shiftLeft(bone, 'location', firstGoodFrame)

        # dope sheet not reflecting deletions immediately, so do "something"
        bpy.context.scene.frame_set(self.first)

    def dropToRight(self):
        # drop all frames for the bones after the current frame
        lastGoodFrame = bpy.context.scene.frame_current
        self.dropRange(lastGoodFrame + 1, self.last + 1)

        # dope sheet not reflecting deletions immediately, so do "something"
        bpy.context.scene.frame_set(bpy.context.scene.frame_current)
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
#                       below only called internally
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    def dropRange(self, first, lastNotIncluded):
        bpy.ops.object.mode_set(mode='POSE')
        for bone in self.armature.pose.bones:
            for frameNum in range(first, lastNotIncluded):
                # does not error when location property missing, so just do all possiblities
                rotProperty = 'rotation_quaternion' if bone.rotation_mode == 'QUATERNION' else 'rotation_euler'
                bone.keyframe_delete(rotProperty, -1, frameNum)
                bone.keyframe_delete('location' , -1, frameNum)

    def shiftLeft(self, bone, property, firstGoodFrame):
        bpy.ops.object.mode_set(mode='POSE')
        newFrameNum = self.first

        # for each kept frame shift it, then delete the old one
        for oldFrameNum in range(firstGoodFrame, self.last + 1):
            # find the value of property of the bone at a given frame & set the bone to it
            values = self.findKeyValues(bone, property, oldFrameNum)
            if len(values) == 0: continue

            if property == 'rotation_quaternion':
                bone.rotation_quaternion = Quaternion(values)
            elif property == 'rotation_euler':
                bone.rotation_euler = Euler(values)
            elif property == 'location':
                bone.location = Vector(values)

            # add a new keyframe
            bone.keyframe_insert(property, frame = newFrameNum, group = bone.name)
            newFrameNum += 1

            # delete the old key frame
            bone.keyframe_delete(property, -1, oldFrameNum)

    # a given key only contains a single float, so return all found for a given property / frame number
    def findKeyValues(self, bone, property, frameNum):
        ret = []
        dataPath = 'pose.bones["' + bone.name + '"].' + property
        for c in self.action.fcurves:
            if c.data_path == dataPath:
                ret.append(c.evaluate(frameNum))

        return ret

    def hasLocationKeys(self, bone):
        dataPath = 'pose.bones["' + bone.name + '"].location'

        for c in self.action.fcurves:
            if c.data_path == dataPath:
                return True

        return False


Should I convert my quad mesh to triangles? If so, can I do it in this script?

Is there a magic way to convert to triangles with a simple python method?

Yes, there is a method.

Based on @gandolf3's suggestion in chat I've tested bpy.ops.mesh.quads_convert_to_tris() and indeed it shows an improvement.

Subdivisioning the quad mesh first can be explored as well, either everywhere, or in some optimized way because the final topographic map is pretty big.

# from https://blender.stackexchange.com/a/35437/5334
bpy.ops.object.select_all(action='DESELECT')
ob.select = True
bpy.context.scene.objects.active = ob

bpy.ops.object.mode_set(mode='EDIT')
bpy.ops.mesh.quads_convert_to_tris(quad_method='BEAUTY', ngon_method='BEAUTY')  # Convert to Triangles
bpy.ops.object.mode_set(mode='OBJECT')

bpy.ops.object.shade_smooth()

Initial quads, final triangles


How do I make a Blender render look glitchy?

I looked around and found some answers to my problem. This method is for the Blender Internal renderer but it can be changed to work with Cycles very easily.

First, add the original movie/animation/image as a plane. In the plane's material settings set the shading to shadeless. Add a camera to the center of the world and clear its rotation. Move the camera up 5 Blender units. Align the plane in camera view so that it lines up with the camera borders. Add another plane 1 Blender unit above the plane that you are trying to distort. Scale it on the X and Y axis until it also fits the camera bounds (it's okay if it goes over a little bit.)

Visuals:

Go to a separate layer. Add a plane at the center of the world and while in camera view scale it down so that the plane is thin on the Y-axis and long on the X-axis (this depends on what you want but generally it's more believable this way.) Duplicate the plane several times. Every time you duplicate the plane, make sure that you change the size a little bit. Hit A on your keyboard until everything in that layer is selected and press Ctrl+G on your keyboard. After waiting a few seconds, (the more objects you have the longer this will take) everythings outlines should turn green or whatever the grouped color of your Blender theme is.

Visuals:

Next, create the material. Select one of the planes that you just created. In the properties panel go to the material tab. Click the "new" button. Under the shading option set it to shadeless and under transparency set it to raytrace. In the transparency settings set the alpha to 0 and the IOR to 4 (4 isn't necessary, it just gave me the best results.)

Visuals:

Next, go back to the layer with the camera and the video/image that you are trying to glitch. Select the second plane that is above the object that you are glitching and in the properties panel, go to the particle system tab. Create a new particle system. Set the start and end times to the length of the footage and do the same to the length of the animation. Depending on the length of the animation you will have to adjust the emission number value. Set the lifetime to 1 and the random value to .5. Under "physics" set it to "no." Under "render" set it to group and select your group that has the glitch particles. Move the animation 1 frame forward to see the objects. Set the size to a resonable value where the "glitchy" objects are covering a large portion of the image. Uncheck emitter. Check rotation and change the initial oriantation to something that makes your objects appear in the right orientation. For me it was object Y or even global Y. If there aren't enough particles covering your subject matter consider turning the emission number up some.

Visuals:

Now you should be able to configure the output and file format of your project and render it with F12 (for still images) or Ctrl+F12 (for an animation.)

My final result:

www.youtube.com/watch?v=dtl7UeVBkcI

For this render I also used Audacity to remix and distort the music. I did not go over this in my answer.

I hope that this worked for you too! I'll probably add a video tutorial to this later if/when I make it! ;)


How can font-ids of internal fonts be retrieved?

There is no API to query internal fonts, the documentation says that 0 as font-id can be used for the default font.


If you want, as it were, to change the crop of the existing perspective you can see, that's a (true) zoom, rather than a track/dolly of the camera, which is what the scroll-wheel gives you.

Select the camera by left-clicking its border in Object Mode, go to its Properties > Data tab, and change its Focal Length setting.


Exporting a GLB file to share it on Facebook

UPDATE: For Blender 2.80, see the Blender Manual 2.80 glTF/GLB documentation.

These instructions are for Blender 2.79x with the Khronos Blender Exporter:

https://github.com/KhronosGroup/glTF-Blender-Exporter

In addition to installing this plugin, you will also need a copy of the glTF2_Principled.blend file that ships with the plugin, for a custom node group it contains.  Future versions of this plugin (glTF-Blender-IO for Blender 2.8) will not depend on these custom nodes, and use the Principled BSDF node instead, but it will target the same channels in the glTF output file.

First, select Cycles as the rendering engine.  Then click File -> Append -> glTF2_Principled.blend -> NodeTree -> glTF Metallic Roughness.  This imports a custom node group into your blend project, that the exporter will look for when exporting materials.

Create a new Cycles material, and turn on "Use Nodes".  Then, select the newly appended node group, the "glTF Metallic Roughness" node, like this:

The inputs on this node correspond almost exactly to the various channels available inside the glTF 2.0 format, and the glTF exporter will specifically look to see what's attached to this node when creating the glTF file.

Note that some are named "Factor" or "Strength".  For example there is a "BaseColor" and also a "BaseColorFactor".  In Blender, these are just node inputs and you can attach anything.  But in glTF, the "BaseColor" is specifically a texturemap, that can be present or absent, and "BaseColorFactor" is a solid color (including alpha) that can either multiply against the BaseColor Texture, or be used in lieu of a BaseColor texture for cases where the base color is solid.

So keep that in mind when hooking up node inputs:  Connect only texture images to the primary inputs, and set solid colors on the "factor" inputs.

glTF can also pack Occlusion (Red), Roughness (Green), and Metallic (Blue) values into a single image.  Thus, a single image node can be connected to both the "MetallicRoughness" and "Occlusion" inputs, to allow that image to drive all three channels.

A tangent-space normal map can also be connected, and optionally an emissive map.  If you connect an emissive map, be sure to change the EmissiveFactor to white, as that gets multiplied by the map.  The default EmissiveFactor is black so that models don't emit light when the emissive map is missing.

A typical PBR wireup may look like this:

With these textures wired up, you're ready to export a full PBR model to glTF format.  If your target is Facebook, they currently have a size limit of 3 MB including textures, so keep it small!  Using JPG images may help get under that limit.  glTF supports both PNG and JPG image formats, but not arbitrary formats.

Use File -> Export -> GLTF.  There are two choices, one will save a text-based glTF file with binary mesh and separate texture image files, the other will save a combined ".glb" with mesh and textures all rolled into a single binary file.  Facebook wants the latter, the .glb file.  You can save a tiny bit more space by un-checking "Export Tangents" from the export options.  Facebook uses ThreeJS as its renderer, and the tangent vectors are easily recomputed on the client, so no need to clutter the export with them.

I hope this helps!


Context becomes a Nonetype object when called by a custom panel

I resolved my problem finally,
i'm just going to share the solution in case of someone has the same issue

the error was coming from the definition of the parent bone and the child one. Because I am in edit mode, I have to define them in the armature and not in the object.

So instead of

pbone = bpy.context.object.data.edit_bones['%s'%parent]

the correct code is

amt = bpy.data.armatures['PLATFORMAmt']
pbone = amt.edit_bones['%s'%parent]


How to do volumetric lighting for a forest scene?

The principles that apply for a forest scene are the same as for any other scene.

Think of volumetrics as shining a light in an environment that has suspended particles in the air, like haze or smoke.

All you need is to add a volume scatter node to the world's volume, and set it to a lower value than the default (in the following examples the value I chose is 0.01).

(To make the scene less compute-intensive you might want to use a cube that surrounds the scene and that has a volume scatter node, as explained in this link: Atmospheric lighting in cycles)

Then you need a light that is bright enough to cut through the volume scattering. You might need to set the strength at a very large value.

To get well defined shafts of light, try to keep the light size as small as possible. Point or Spot sources work the best for this effect (if you choose to use a sun lamp, then don't use volume scattering in the world, and use a mesh as volume scattering domain).

The effects of Volumetric lighting are more visible when bright light beams are in front of dark areas of a scene, and are less visible when the background is bright. Also, Volume scattering works best with back lighting (when the light is behind the objects in the scene) and side lighting, like the image posted on the question or any of these reference images.

Back light

(click on any of the images to enlarge)

Side light

Front light

If you have the main light source behind the camera, the problem is that the light is bounced back at the camera before it lights the scene, making everything brighter and flatter (the dark areas are not as dark any more). The same effect as driving through fog, where it is harder to see because the light is reflected back at the driver instead of lighting the road and the landscape.

An alternative way to deal with your scene is to set a bright volumetric light for the landscape (to be the sun or moon or whatever) and smaller less bright area lights to reveal the shapes of the house. Those lights can be invisible to the volume scatter by disabling Volume Scatter Ray Visibility in the Cycles Settings. That way, you can make lights that will not make the atmospheric haze or smoke any brighter.

Volumetric effects will create noisier images, so you might need to increase the number of samples for rendering.


You can absolutely customize your Rigify Meta Rig which would allow you to rig (almost) any character. The "secret" is in understand the Building Blocks or "rig types" that Rigify provides.

I made a tutorial series on exactly that. Here is the series page

https://cgdive.com/rigify

Or the youtube playlist

https://www.youtube.com/playlist?list=PLdcL5aF8ZcJv68SSdwxip33M7snakl6Dx

I hope this is a reasonable "self-promotion". There is very little info on this topic. I learned the basics from this video by Ivan Cappiello (one of past maintainers of Rigify)

https://www.youtube.com/watch?v=txJ-2zUQSTg

And of course, there is the Rigify manual which can be very useful. However it is has been lagging behind the actual development of the addon.
The 2.8 manual actually does not include images as of this writing.

https://docs.blender.org/manual/en/dev/addons/rigging/rigify/index.html?highlight=rigify

So it may be better to look at the old version of the manual
https://archive.blender.org/wiki/index.php/Extensions:2.6/Py/Scripts/Rigging/Rigify/#Advanced_Usage


I want this tagline.
@Pamela, no hard feelings, this is just too good.


Corner gets skewed by subdivision surface

This effect is a natural consequence of the Catmull-Clark algorithm, because the centers of adjacent faces,(and their sizes,) are used to calculate new edge-points.

If you're relying on Catmull-Clark to create your curve, and you want it to remain symmetrical about the corner, you will have not only to put in holding-loops for the corner itself, but at least one more loop to ensure the centers of the next faces along are also at an equal distance from the corner.


Your source file has inconsistent frame rates in the container and the video stream (see this explanation of tbc, tbn, and tbr), so that may throw Blender off. Try running your video file through ffmpeg without re-encoding the streams, and set the frame rate explicitly:

ffmpeg -i yourfile.mkv -c:v copy -c:a copy -r 30 newfile.mkv


I ran some tests with 100 samples each with this scene:

Defocus Node:

Time: 2:01 + roughly 7 seconds for compositing = 2:08
Cycles DoF:

Time: 2:02
Conclusions:
Based on the above results, rendered DoF seems more reliable and realistic, as well as a little bit faster in this case.
The main advantage of composited DoF is the ability to tweak the settings after the render.


I want to Integrate Animations with my friend

Once you have defined your rig, you can both save your animations as actions that can be re-used. You can the share the files back with each other and use the append option in the file menu to combine them into one scene if you need.

Actions are blender's way of storing animation sequences for re-use and combining with others, and if you intend to export this to another program like a game engine, are also very useful for managing this.

You may also find this related question helpful: Reusing Animations for another character?


Moving an object by its vertices to another objects vertices

as moonboots said, it can be easily done, but i am not sure whether his explanation is "enough" for beginners, so here the short story long:
Let's say you got a plane and a cone and you want to move one vertex of the plane to the top of the cone:

1.) select your plane

tab for edit mode

select your vertex

Shift - S -> Cursor to selected

Tab

Object -> Origin to cursor

select the cone

tab for edit mode

select your vertex

Shift S -> Cursor to selected

tab

select your plane

Shift - S -> Selection to cursor

result:


Executables on *nix-like Operating Systems in General
*nix-like operating systems usually don't use file extensions to determine if a file is executable or not. Instead they rely on file system flags and file headers (for example ELF headers for binaries and !# - aka Shebang - for shell scripts).
Without going too deep into technical details:
If you download Blender for Linux from blender.org and extract it on any GNU/Linux based operating system, all the necessary flags should be already set. You execute Blender by clicking (single/double depending on your UI settings) on the file called "blender".


How can i solve this error when importing materials?

You don't have an active node selected and the Node Wrangler add-on had a bug that didn't check if an active node existed. Select the Principled BSDF node and it should work properly.

The bug in Node Wrangler has been fixed.


Use nodes to generate a texture of an image cut out with a checkerboard

Blender internal
One way is by using a node texture on top of the video texture to influence the alpha:

Note that the color input on the checker node has an alpha of 0 and the material has Mask alpha enabled.
Example .blend
Cycles
In cycles this can be done with a material setup like this:


WIll Blender 2.8 run on Intel HD 4000 Graphics Card?

Short answer: yes. According to this article, the HD Graphics 4000 card supports OpenGL 4.0. Try updating your drivers. Otherwise, your issue is not with OpenGL.


How do you stop the sliding of rigid body objects?

You can use Enable Deactivation option and adjusting it's parameters:

It also helps to have the collision objects set as Passive.

What will also increase the simulation accuracy is number of simulation steps:

The more steps the less sliding in the end and the more accurate simulation (this is 5000 steps):

If you don't want to increase steps, you can also Bake the simulation to keyframes with Object > Animation > Bake Action and delete the keyframes in Dope Sheet Editor that you don't want.

You can also keyframe the animation tag on the rigid body to be checked in the start and in the end of simulation:

This will enable you to control the position and bypass simulation when the tag is on. Notice that during simulation the location (in N panel) of bricks doesn't change from starting position. You need to get the end location and rotation from word_matrix in the Console:

bpy.context.active_object.matrix_world.translation
bpy.context.active_object.matrix_world.to_euler()

And you keyframe the starting position and the end position.


Please make sure that :

Object Offset is checked
Under Object Offset, the Empty is selected (either via the object list, or via the picker)
Count isn't set to 1.


Having done this for 3D printing before, I can admit it's an annoying problem. Admittedly, I did so through booleans, and that was a complicated process. Here is a workflow adapted to the bisect tool:
Bisect Tool Method

Join the objects as one. This will be necessary in any method.
Bisect while in edit mode. Check the fill box to fill in the mesh where you are cutting it.
Separate the cut mesh.
(Optional) The other side of the mesh needs to have its faces filled too. Unfortunately, the bisect tool doesn't provide for that. Depending on the geometry, this may be easy to do by just selecting the edge to fill and pressing F (or using the menu). Another solution would be to duplicate the mesh after the bisect operation, and delete opposing sides of the mesh on each duplicate (so each duplicate will keep its fill where it was bisected).

Boolean Method
This involves slicing with a boolean cube that has been flattened.

The objects will need to be joined as before. Add in a cube, flatten it, and replicate it with the array modifier, spacing it out as large as your bed is.
Apply the boolean modifier.
After this, it will of course be possible to separate the mesh into different objects for the different layers as before. Use L to select linked parts of the mesh and P to separate those mesh areas into a new mesh object.

In this situation, the boolean operator does require geometry with volume, so the accuracy of this method depends on how thin your cube is.


Need help with manipulating center points!

Driver controls Delta Transformation Location X value

The red object location relative the to yellow object location controls the final locations of the blue planes via a driver.  The red object is useful for the Blender python script driver described below.

A red delta mesh object controls the Blender Object [Delta Transformation] Location X value of the two flanking light and dark blue planes relative to the yellow middle plane.  A Delta Transformation Location value is added to the regular Location value to see a final location on the screen.  Simple Addition.  A python script driver allows us to use the distance between the red cube and yellow plane to offset the blue flanking planes.  The red cube can be animated. Multiple locations for the the red cube and controlled movements of flanking planes are shown in the animated .gif file above.

Many of the images below are composed from multiple Blender screen captures to reduce time, produce single size images.  Keep that in mind when inspecting the images.  Click on images below for larger version and to read the text.

Flanking planes final placement is controlled by red object. Outliner windows shows objects involved. Composed image above emphasized by black divider.

Flanking Planes left and right.  The tool tip on the Delta Transform X Location show a simple python formula.  The purple coloring of the value and the tool tip indicate a python script driver is used.  Add Single Driver was selected  from value pop-up menu.

The driver windows show the driver values for the moving planes.  The arrows indicate the Graph Window and the Editing context. A Composed image to compare formulas .... emphasized with black areas.  Click image to see larger view.

You must select one plane and add a driver.  Then you must select the second place and add a driver.

The two simple names and text formulas you must type into the respective windows below and are visible in the screen capture as well.

(delta - middle) ... and ... -(delta-middle)

All other values come from the menus.

Simplified sequence of steps.  Inspect and Improve.

This proposed answer is not a tutorial for beginners.

Please search [Blender Driver Tutorials] and you will find many matches for free on the famous video website.  If you need a tutorial see a video tutorial, this is an efficient use of time.  Many videos will show you how to create a driver in general.

A recent video on Blender Driver Tutorials on a video website will provide a better visual tutorial.  The video will not have the simple formulas stated below. Video tutorials often work better than text tutorials for Blender.  Recommended for people who state they are beginners.   You can even search here at BSE with the keywords provided.  I am sure I and many others here at BSE learned about drivers by searching on the very famous video website. This is not intended as a tutorial on drivers in general.  This site has claimed not to be about tutorials.

The 4 objects placement is indicated above. Red cube is controller. 3 planes have initial separation.  Select a flanking blue plane.  Locate and Know the Delta Transformation values are listed below the regular Transformation values.  I am using the X location for this example.  Mouse over Delta Transformation X value, alternative mouse click brings up the menu indicated above.

Add Single Driver.  Purple indicator appears.

Create a new window or reuse window. Change to Graph Window.  Select [Drivers] editing context.  Make driver info appear by click the + sign faintly visible on the right side of window if necessary.  Add variables and create your variables to match the values in the screen captures above.  Note the object names I use may not be the same as your object names.  Thus use the object names in this proposed answer or translate with awareness.

The red cube need not be rendered.

Make sure  User Preferences allows scripts to be executed  ... if a related error message appears.


Why do I get a cube when I try the Fracture Modifier on a sphere?

Seems you already downloaded the Fracture Modifier Build. Here is a general introduction tutorial for it (its from 2014 but the basic principles work still in the same way.)

https://www.youtube.com/watch?v=9E0Nn_a6wCs

And the documentation site:

https://wiki.blender.org/index.php/User:Scorpion81/Fracture_Documentation

Or you could just try to run the cell-fracture script in object mode. You tried to run it in edit mode where it obviously is not supposed to run and errors out then. By the way, the cell fracture script is completely independent of the Fracture Modifier.

When you use the Fracture Modifier (FM), you get a faster version of cell fracture with a lot more customization options. The smashing spheres could be 2 Objects, with a FM each. Just hit execute Fracture on both and Alt-A and the simulation starts (the spheres will fall down). Then you can animate the spheres, set them to Animated and Triggered, and make each sphere a Trigger, too. Optionally you could also use constraints within the FM. Then, when the spheres collide, they will break apart as well.


How to create edges between two lists of vertices in Sverchok

List split

You can use one node with the List Split node. You'll avoid the repetition of the double Range Int node.

It's just a slightly different variation from your implementation. Apart from building a node that makes all at once, I can't think of a way to simplify it further.


How can I solidify without ruining spiked edges?

I would Solidify the outer side, and adjust the spike manually.

Use the Solidify Modifier.
Set Offset to 1 and adjust Thickness to your liking.

You can adjust Inner/Outer Crease, if you're also using the Subdivision modifier.
The Subdivision modifier should be AFTER the Solidify Modifier.

Hit the Apply button to apply the Solidify Modifier.

Go to Edit mode
Select the new vertices and scale it down to make it pointy using the Scale Tool.
Shortcut: S


What's The Library Blender Uses to Draw?

Blender's drawing code is all custom C code calling opengl functions. Even the ui widget toolkit is custom. There is no python library.

As suggested by batfinger, you can use bgl, blender's opengl wrapper for python if you need custom drawing.


What ui would work for choosing from a long, long list?

To let the user explicitly select an item from a large set, I discourage a template_list - although there's a search filter.

1. Instead, I recommend the search popup:

import bpy

def item_cb(self, context):
    return [(str(i), "Item %i" % i, "") for i in range(100)]

class SimpleOperator(bpy.types.Operator):
    """Tooltip"""
    bl_idname = "object.simple_operator"
    bl_label = "Simple Object Operator"
    bl_property = "my_enum"

    my_enum = bpy.props.EnumProperty(items=item_cb)

    def execute(self, context):
        self.report({'INFO'}, "Selected: %s" % self.my_enum)
        return {'FINISHED'}

    def invoke(self, context, event):
        wm = context.window_manager
        wm.invoke_search_popup(self)
        return {'FINISHED'}

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

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

if __name__ == "__main__":
    register()

    # test call
    bpy.ops.object.simple_operator('INVOKE_DEFAULT')

2. Or nested menus if there's some kind of hierarical structure in your data. The example uses dynamically-created menus:

import bpy

class SimpleOperator(bpy.types.Operator):
    """Tooltip"""
    bl_idname = "object.report"
    bl_label = "Report"

    text = bpy.props.StringProperty()

    def execute(self, context):
        self.report({'INFO'}, self.text)
        return {'FINISHED'}

class SimpleCustomMenu(bpy.types.Menu):
    bl_label = "Simple Custom Menu"
    bl_idname = "OBJECT_MT_simple_custom_menu"

    def draw(self, context):
        layout = self.layout
        for i in range(6):
            layout.menu("OBJECT_MT_dyn_%d" % i)

def register():
    bpy.utils.register_class(SimpleCustomMenu)
    bpy.utils.register_class(SimpleOperator)

def unregister():
    bpy.utils.unregister_class(SimpleCustomMenu)
    bpy.utils.unregister_class(SimpleOperator)

if __name__ == "__main__":
    register()

    for i in range(6):
        idname = "OBJECT_MT_dyn_%d" % i

        def func(self, context):
            self.layout.label("Parent: " + self.bl_label)
            for j in range(10):
                option_text = "Option %i" % j
                props = self.layout.operator(SimpleOperator.bl_idname, text=option_text)
                props.text = "%s > %s" % (self.bl_label, option_text)

        opclass = type("OBJECT_MT_dyn_%d" % i,
                       (bpy.types.Menu, ),
                       {"bl_idname": idname, "bl_label": "Test %i" % i, "draw": func},
                       )
        bpy.utils.register_class(opclass)

    # The menu can also be called from scripts
    bpy.ops.wm.call_menu(name=SimpleCustomMenu.bl_idname)

3. A template_list() can be used to show a single line:

layout.template_list(..., rows=1)

You can force the built-in filter options to always show in the UIList subclass:

def draw_item(self, context, layout, data, item, icon, active_data, active_propname):
    self.use_filter_show = True

4. Something hand-crafted: a StringProperty for a search phrase and as many buttons as there are matches. The number of matches should be limited (hard-limited in below code), you could implement pagination if necessary. You make make the layout adapt to the panel width if you want:

import bpy
import random

vowels = ["a", "e", "i", "o", "u"]

def fake_words():
    words = []
    for w in range(random.randint(1, 3)):
        for i, l in enumerate(range(random.randint(2, 7))):
            if i % 2 == 0:
                words.append(vowels[random.randrange(len(vowels))])
            else:
                words.append(chr(random.randint(97, 122)))
        words.append(" ")
    return "".join(words).title()

wordlist = [fake_words() for i in range(1000)]

class ReportSelected(bpy.types.Operator):
    bl_label = "Report"
    bl_idname = "wm.report_selected"

    text = bpy.props.StringProperty()

    def execute(self, context):
        self.report({'INFO'}, self.text)
        return {'FINISHED'}

class HelloWorldPanel(bpy.types.Panel):
    """Creates a Panel in the Object properties window"""
    bl_label = "Hello World Panel"
    bl_idname = "OBJECT_PT_hello"
    bl_space_type = 'PROPERTIES'
    bl_region_type = 'WINDOW'
    bl_context = "object"

    def draw(self, context):
        layout = self.layout
        wm = context.window_manager
        search_phrase = wm.custom_search
        cols = context.region.width // 100
        matches_per_col = 10
        matches_max = matches_per_col * cols

        layout.prop(context.window_manager, "custom_search", text="", icon="VIEWZOOM")

        matches = [w for w in wordlist if search_phrase.lower() in w.lower()]

        col = layout.column(True)

        for i, w in enumerate(matches):
            if i >= matches_max:
                break

            if i % cols == 0:
                row = col.row(True)

            row.operator("wm.report_selected", text=w).text = w

        matches_more = len(matches) - matches_max
        if matches_more > 0:
            layout.label("+ %i matches" % matches_more)

def register():
    bpy.types.WindowManager.custom_search = bpy.props.StringProperty()
    bpy.utils.register_class(HelloWorldPanel)
    bpy.utils.register_class(ReportSelected)

def unregister():
    bpy.utils.unregister_class(HelloWorldPanel)
    bpy.utils.unregister_class(ReportSelected)
    del bpy.types.WindowManager.custom_search

if __name__ == "__main__":
    register()

I can think of many more solutions, like a grid of buttons with a letter of the alphabet each as a first step, and in the second, show only strings that start with the chosen letter (probably as buttons).

Or multiple dropdown menus, select a letter or category first, and let the second update based on the first, to show only the relevant entries.


That happens a lot, especially if you've set units for your scene. Simply scroll down with your scroll wheel, and the ring will get smaller and smaller, until you see it in your viewport.

Check to see if the "proportional size" number is decreasing.


The thing hollow is kind of uncertain naming. Blender use surface based model for manipulate, which only surfaces are defined in your scene. So yes, every thing you see in your model can be a hollow thing by its model properties.

Maybe you are asking a closed surface behavior after manipulating? In that case, making a shell for the rocket will be a better idea. Using Solidify Modifier can make the object getting a thickness shell surface. So when you look inside the rocket through the tiny window, the surface will not be the wrong direction (backface).

But when the backface is not a consideration. You don't need to solidify it if the view is OK with backface as below:


My background reference image isn't showing within blender?

Select the image and look at the object data. You can see there are two checkboxes: Display Ortho and Display Persp. You can also set the transparency etc.

Also look in the scene collection and make sure the disable selection is not turned off (the white arrow). If you cant see this then click on the filter icon in the header.


If I got your question right you want to use the 3d view port preview rendering to data flow visualization. However it's purpose is completely different: check how your scene will be rendered by one of the NON REAL TIME rendering engines.

For this propose you should use a real time rendering engine. You have two choices:

Blender Game Engine for offline visualization, (programmable in python via BGE API)

blend4web for online visualization. (Programmable in JavaScript with blend4web sdk)

Both of them are capable to render complex scenes in realtime, morover they can be interactive.


Can't render with Displacement Modifier on - is it destroying the mesh?

I'll bet you have a duplicate of the loop from before the displacement modifier was applied rendering at the same time. Disabling the eye icon in the Collections panel doesn't stop rendering. Click on that funnel-looking-thing to enable more filtering options. You want the one for rendering, which looks like a camera. Disable that for the duplicate. You can also do that in the "Object" panel (orange square-shaped tab)

EDIT: Yep. Turn off that camera icon:


To expand the window hover your cursor over it and press Shift+Spacebar. Press it again to get back.
You may also use Ctrl+Up Arrow/Down Arrow to do it.

To expand the window even more press Alt+F11.


Knife tool just not working on simple object

Not sure why, but if you uncheck the 'Occlude Geometry' option it works correctly.

It may be because the top face of your model is not an ngon (has 5 vertices).


Animation of Dupliverts with Shape Keys with Python api

It is possible to keyframe each vertex. While by default Blender does not provide a GUI way to do this, it does include the AnimAll addon that provides a way to visually keyframe various components and values like vertices and edge creases. A python script can also easily keyframe the vertices.

import bpy
from random import random

obj = bpy.context.object
for f in range(bpy.context.scene.frame_end):
    for v in obj.data.vertices:
        m = random() * 0.1
        if f%2:
            v.co.z += m
        else:
            v.co.z -= m
        # index of 2 means only the z-axis
        # -1 (x,y, and z change), 0 x-axis, 1 y-axis
        # you will get weird behavior if the index and
        # axis changed do not match
        v.keyframe_insert('co', index=2, frame=f)

Once keyframed they show in the graph editor and dopesheet like any other animation, meaning modifiers can be added and interpolation types changed. You will find the fcurves in obj.data.animation_data.action.fcurves.


Create a Python program that creates a new Blender file and edits the scene

Background mode

Can run blender in background mode.

How can I run blender from command line or a python script without opening a GUI?

Run the command using language of choice. For example in python using  subprocess.Popen(...) or a 3rd party module like plumbum or something akin to https://stackoverflow.com/questions/17733849/launch-an-external-application-from-node-js via node.js

Very basic example script. My startup file has default cube with material "Material". The material's diffuse color in 2.79 is rgb, in 2.8 rgba.  Simply sets material to red, and saves the file as "output.blend"

test.py

import bpy

mat = bpy.data.materials.get("Material")
red = (1, 0, 0)
if len(mat.diffuse_color) == 4: # has alpha
    red += (1) # alpha

mat.diffuse_color = red
bpy.ops.wm.save_as_mainfile(filepath="output.blend")

Run from command line with

blender -b -P test.py

creates a blend file named output.blend with a red cube in the folder in which it was run from terminal.

Extend by passing arguments see

How to pass command line arguments to a Blender Python script?


Export geometry with multiple UV maps to PLY

This is a limitation in Blender's exporter, but also in the PLY format & its conventional use - which is to only have one UV layer.

You could of course modify the exporter to write shape-keys, weights or any arbitrary vertex data, but other applications won't read it unless special support is added.


You could use falloff for the force field which will specify the shape of the areas where it will make the effect.

In the force field options (in the Properties editor) find Faloff area and check Tube instead of Sphere, selected by default. This will make force field affect in the areas which fall in that shape while with Sphere it affects radially in all directions.
Then enable Maximum, just below the Tube option; this will ensure the force field doesn't affect all the particles in the given area.

If testing this now, force field will affect all the particles in the given direction up to the specified minimum:

Particles are red icospheres; blue line in the middle is the plane which shows maximum area of the force field effect; partially transparent blueish cylinder shows force field shape itself.

This is however not what is desired; the force field affects up to the certain area, but to all the particles, reaching its minimum distance. To make it affect only particles within its shape of effect enable Maximum in the Radial settings:

With that, force field will affect particles up to the certain area (shown as blue line) and within certain area of the tube (in this case) shape.


Is possible play video in reverse mode into Texture Image node?

In order to get more control about the playback of an Image Sequence or Movie Clip, you can set the Frame property of the Image Texture node to the 'first frame' which allows to set the the 'current frame' based on the Offset property.

If you'd like to reverse the playback of a Movie Clip or Image Sequence, you can add a driver expression to  the Offset property, eg. #3-frame -> last frame - current frame:

For the sake of completeness: You can also loop the playback by using the remainder a.k.a. modulo operator %, eg. #(3-frame) % 3 -> (last frame - current frame) % last frame:

Demo using an Image Sequence (left) and a Movie Clip (right) on the default cube
Note: You can even add a condition to eg. be on the safe side for the 0th frame when cyclic is disabled: #1 if frame==0 else (3-frame) % 3 -> (a if condition else b).


How to apply a glass shader on my imported geometry?

Assuming you are using the Eevee renderer.

Go to Properties Editor > Render Properties tab and check Screen Space Reflections as well as Refraction. It brings a glass look to your material.

With Glass object selected go to Shader Editor > Properties panel N switch to Options tab and check Screen Space Refraction.
This enables other objects visible behind glass.


Blender currently cannot handle simulations when they are that small.
Rigid body needs all object to be at least 1 m at smallest in dimensions.
Same with fluid and most other solvers within blender.

As of now I would suggest increasing it to 10x the size.


It looks like they're just the wrong weights- you would need it to be the same weight as the corresponding area of the neck for it to follow the bones the same way.

What I would recommend is either using the automatic weighting system for the spines if that's how you did the neck, or if the neck's weighting has been manually edited then most likely you would need to use trial and error to manually weight paint the spines on. Anybody else, correct me if I'm wrong, but I don't think there's any way to successfully transfer exact weights to something with such a different shape than the original mesh.


I had the exact same behavior and it came out of nowhere.

Pixelated diagonals over faces
Faces flickering from gray to orange when selected
Strange see-through

I already worked in the same version of Blender (2.83.0) before on the same computer without this problem.
Solved it by uninstalling Blender and reinstalling version 2.83.2


Using collisions to control movements of objects in an animation

Yes - this is precisely what Rigid Body Physics is for.
Your objects will need to be 3-dimensional (your example image looks to only be 2D) and set up with Rigid Body on each. The green one you have have set as 'Passive' and 'Animated' in its settings (so that you can animate its position) and the violet one as 'Active'. You would need to setup a ground plane (also as 'Passive') for them to rest upon (or they will just fall under the influence of gravity) or add a Rigid Body Constraint to restrict its movement.
Running the simulation and moving the green object should result in the violet one responding and being pushed out of the way.


Textures on models randomly disappeared in cycles render

Never mind. I figured out what was wrong. Apparently my textures were still downloading on my computer. They didn’t finish downloading. Now it’s working. Sorry.


How to pick target texture image for baking?

For Blender internal renderer, the important thing (as I just learned) is to understand Blender assigns textures in the Image Editor on a per face basis. So it's not enough to just load the texture in your UV/Image Editor; you have to load the texture while having the relevant UVs selected also. This way you match the image with the UVs and the image becomes the target for baking.


Use a light path node and color mix node.

On the so called "portal" object use a transparent shader.

Then on the world, set the two different HDRs and use the transparent depth to control the RGB mix of the environments.

Don't use shader mix nodes to mix RGB color information. Pay attention to the color of the sockets! Green sockets should connect with green, yellow with yellow, gay with gray and so on.

Also: nodes that are not connected to the final output have no effect on the result.

Read:
What is the meaning of the color of the node sockets in the node editor?

and

Cycles - (Shader) Nodes - inputs outputs - What are the exact data types?

How this all works is

Transparent rays will use one image, all other rays (like diffuse or glossy, etc) will use the other. The limit of this solution is that glass objects (or other transparent or semitransparent objects) will need to be composited.


Rotating/translating the motion path itself

Perhaps you can accomplish this by giving the camera a parent (usually an Empty) and then just change the location/orientation of the parent over time (probably using constant interpolation for the keyframes of the parent's animation) and repeat the camera motion.

If you want to get super-fancy you can use NLAs to recycle the camera animation.


There are 2 methods i found how to implement Bend modifier:

First Method(Circle and Spiral). You can tweak parameters of ofset_axys ans offset_rotation:

import bpy
import math
import mathutils
import random
from bpy.props import *
from mathutils import *

point_id = StringProperty(default="")

context = bpy.context
obj = context.scene.objects[0]
f_dist = 1.0
vv = Vector((0.0, 0.0, 1.0))

x_min = obj.data.vertices[0].co.x
x_max = obj.data.vertices[0].co.x
y_min = obj.data.vertices[0].co.y
y_max = obj.data.vertices[0].co.y
z_min = obj.data.vertices[0].co.z
z_max = obj.data.vertices[0].co.z

offset_rotation = 0.2
offset_axis = 5.0
bend_scale = 0.7

for vert in obj.data.vertices:
    if vert.co.x > x_max:
        x_max = vert.co.x
    if vert.co.x < x_min:
        x_min = vert.co.x
    if vert.co.y > y_max:
        y_max = vert.co.y
    if vert.co.y < y_min:
        y_min = vert.co.y
    if vert.co.z > z_max:
        z_max = vert.co.z
    if vert.co.z < z_min:
        z_min = vert.co.z

x_orig = ((x_max-x_min) / 2.0) + x_min
y_orig = ((y_max-y_min) / 2.0) + y_min
z_orig = z_min
rot_origin = Vector((x_orig, y_orig, z_orig))

visual_max = z_max-z_min

for vert in obj.data.vertices:
    vec = vert.co.copy()
    visual_z = vec.z - z_min

    if z_max != 0:
        beta = math.radians(720 * (visual_z/visual_max) )
        if beta != 0:
            final_offset = visual_z * offset_rotation
            if beta < 0:
                final_offset = -final_offset

            vert.co.x -= ((visual_z / beta) + final_offset) * bend_scale
            vert.co.z = rot_origin.z
            #vert.co.z *= 0.5

            rot_mat = Matrix.Rotation(beta, 3, 'Y')
            vert.co = rot_mat * (vert.co - rot_origin) + rot_origin

            #eul = mathutils.Euler((0.0, beta, 0.0), 'XYZ')
            #vert.co.rotate(eul)

            vert.co.x += (visual_z / (beta))*bend_scale

            # offset axys
            vert.co.y += offset_axis * (visual_z/visual_max)

Second Method(Spiral only):

import bpy
import math
import mathutils
import random
from bpy.props import *
from mathutils import *

context = bpy.context
obj = context.scene.objects[0]

z_max = 0
for vert in obj.data.vertices:
    if vert.co.z > z_max:
        z_max = vert.co.z

for vert in obj.data.vertices:
    #print(vert.co.z)
    vec = vert.co.copy()

    beta = math.radians(360 * (vec.z/z_max) )
    if beta > 0:
        # vec2
        vert.co.x = 0
        #vert.co.x -= vec.z / (beta)
        #vert.co.z *= 0.5

        eul = mathutils.Euler((0.0, beta, 0.0), 'XYZ')
        vert.co.rotate(eul)

        #vert.co.x += vec.z / (beta)

        vec2 = vert.co.copy()

        # vec3
        vert.co = vec.copy()
        #vert.co.x -= vec.z / (beta)
        #vert.co.z *= 0.5

        eul = mathutils.Euler((0.0, beta, 0.0), 'XYZ')
        vert.co.rotate(eul)

        #vert.co.x += vec.z / (beta)
        vec3 = vert.co.copy()

        # vec4-5
        vec4 = (vec3 - vec2)
        vec4_len = vec4.length
        vec4 = vec4.normalized()
        vec5 = (Vector((0.0, 0.0, 0.0)) - vec2).normalized()
        angle_fix = vec5.angle(vec4)
        angle_fix *= min(z_max,vec.z*beta/math.radians(60)) / z_max  # 5.0 is for better faloff of rotation_fix
        eul = mathutils.Euler((0.0, angle_fix, 0.0), 'XYZ')
        vec4.rotate(eul)
        vert.co =  vec2 + (vec4.normalized() * vec4_len)


I started rendering a new animation after completely rendering one before. How do I retrieve that older render?

If you wrote over other files there isn't much you can do other than doing some kind of forensics and trying to recover your files with Data Recovery software (and that is way beyond the scope of this site).

On the other hand there are a couple of things you should do to prevent this from happening again:

-. Uncheck the Overwrite box on the output tab.

-. Don't use an animation (AVI, Qucktime, h264, Xvid, MPEG) format as output.

-. Render your animation as a series of images (PNG, Tiff, DPX, OpenEXR) and compile as video once you have rendered all your frames. This way, if the computer crashes you'll only loose the current frame but will keep all of the frames that have been rendered already.

-. Save different image sequence/animation renders to different folders under the Output file-path. This will let you save newly rendered sequences while preserving older ones for later analysis.


Trying to upload project with Mantaflow to RebusFarm getting error

They're answer is cut and paste.  Of course it should be baked before uploading, and it sounds like thats what you did.  I would double check if there are other Mantaflow settings that need baking as well.  I know for gas sims there is the initial bake and the "noise" bake is separate.

Also try in the cache section to name your cache and point it to a custom directory instead of just /tmp/

I also use Rebus and I found that in addition to "pack all files" I need to also check "make all paths absolute" (under the same File>External Data drop down)

I'm currently testing a Fire + Smoke sim made in 2.82 on their farm at the moment. I'll see if it renders.


1: Select cube in edit mode with A and press Smart UV Project (Cycles blender mode).

2: In UV Image Editor press New Image and create your texture (P.S. don't forget save your texture with F3 save as a image).

3: In Node Editor press check box for use nodes (red box) and with Shift+A from texture menu select: Image Texture and your image.

4: Select Texture Paint and start painting.


How to export and import a 3d model into Babylon

I'm assuming you are referring to babylon.js.

In general, all but the most simple materials are not directly transferable between different rendering engines, so many complex custom cycles materials will never be able to be directly exported to another program.

Based on it's documentation, it supports obj,stl and gltf import formats. Of these, gltf is the most sophisticated and so is probably your best bet.

There is a gltf plugin available for blender here:
https://github.com/KhronosGroup/glTF-Blender-Exporter
This plugin seems to support exporting materials if you use specially provided node groups to create those materials.


How to create road intersections with curves?

One way could be,perhaps,using subdivision surfaces, creasing straight edges... sort of


I can't get my rig to attach to my model

You need to apply the scale to the armature (metarig) and the mesh before you parent them. Select them, then press Ctrl+A, apply scale.


Understanding 3D transforms and rotations

The transformations are applied in this order: scale, rotation then translation.
Note that you would need to multiply the matrices in the reverse order to get a single transformation matrix.

For a rotation around one axis you would only need a $2\times 2$ matrix, e.g. a rotation around the z-axis wouldn't change the z-values of the vertices. For $(x,y,z)$ vertices a $3\times 3$ matrix is more convenient since it can hold all rotations. The conversion from $3\times 3$ (orange) to $4\times 4$ is done by adding (green) a $1$ to the bottom right cell and fill the remaining with $0$.

$$
\begin{aligned}
&\begin{bmatrix}
\color{orange}1 & \color{orange}0 & \color{orange}0 & \color{green}0\\
\color{orange}0 & \color{orange}{\cos{\theta}} & \color{orange}{-\sin{\theta}} & \color{green}0 \\
\color{orange}0 & \color{orange}{\sin{\theta}} & \color{orange}{\cos{\theta}} & \color{green}0 \\
\color{green}0 & \color{green}0 & \color{green}0 & \color{green}1\\
\end{bmatrix}\\
R_x = &\begin{bmatrix}
1 & 0 & 0 & 0 \\
0 & \cos{\theta} & -\sin{\theta} & 0\\
0 & \sin{\theta} & \cos{\theta} & 0\\
0 & 0 & 0 & 1
\end{bmatrix}\\
R_y = &\begin{bmatrix}
\cos{\theta} & 0 & \sin{\theta} & 0\\
0 & 1 & 0 & 0 \\
-\sin{\theta} & 0 & \cos{\theta} & 0\\
0 & 0 & 0 & 1
\end{bmatrix}\\
R_z = &\begin{bmatrix}
\cos{\theta} & 0 & -\sin{\theta} & 0\\
\sin{\theta} & 1 & \cos{\theta} & 0\\
0 & 0 & 1 & 0\\
0 & 0 & 0 & 1
\end{bmatrix}
\end{aligned}
$$

A translation vector doesn't fit into this matrix, therefore it is expanded to a 4x4 matrix. This is in order to make translation compatible to the other transformations (This is called Homogeneous coordinates.)

$$
\begin{aligned}
T(d_x, d_y, d_y) &= \begin{bmatrix}
1 & 0 & 0 & d_x\\
0 & 1 & 0 & d_y\\
0 & 0 & 1 & d_z\\
0 & 0 & 0 & 1\\
\end{bmatrix}\\
S(s_x, s_y, s_y) &= \begin{bmatrix}
s_x & 0 & 0 & 0\\
0 & s_y & 0 & 0\\
0 & 0 & s_z & 0\\
0 & 0 & 0 & 1\\
\end{bmatrix}
\end{aligned}
$$

Quaternions are a more complex way to describe rotations which avoids a Gimbal Lock, a situation where you would loose one degree of freedom.

Related questions:

What is the order of transformations when exporting to Collada?
Could someone please explain gimbal lock?
Apply rotation to camera?


Why do some bones in an animation lose their position when applying scale to their armature?

Generally if an armature already has animation data, it's not safe to scale it and apply the transformation. It has something to do with changing the armature object's transformation matrix, because each keyframes in an action for a bone is recorded and evaluated against it.

To illustrate, here I have a keyframed armature, and I just add a free-floating bone parented to torso:

If I halve the armature's size in object mode, each bone's matrix stays the same:

But after I apply the scale transformation, it's a different matrix for each bones:

Whatever matrix operation is applied against the keyframe data, no longer turns out the correct transformation. In my experience, only free-floating bones are prone to this problem (the feet doesn't stray like this when animated in FK).


How can I send someone a .blend file with cache folder included?

Set blender to use relative paths.

Copy the folder with the cache on the same folder as the blend file.

Pack all the images used as textures.

Zip the folder with all those files into a single compressed file.

Send the zip file.


The line p_bone=pose.bones[b.name] is giving the error key "" not found. The two quotes after key indicate that b.name is an empty string which is not a key in the pose.bones dictionary.

That might indicate that one of the bones does not have a name, it could also indicate that a bone has an unusual or non-text character that is causing an error when reading it into a string.

Another possibility is a zero sized bone, blender doesn't retain bones that have zero length, this means as the bone was initially created blender deleted it and then when it was referenced again later you get an error.


Adding brushes for sculpting in 2.83, missing config folder

The brushes worked fine as soon as I moved them to the Blender 2.83 Folder you see above.
I think it has to do with administrative authority required to move them there.


This isn't hard to do with the setup you already had, with all of your goals and limits, and what you have shouldn't be difficult to adjust-- maybe you'll understand better how to adjust things after reading this and working with it a bit.

From left to right: unposed; posed; posed with physics:

The hose is an arrayed object, curve deformed by a 3-handle bezier curve (although a NURBS should work if you'd prefer), parented to the outlet.  The curve has stretch and bounds clamp enabled, and is parented to the same outlet.  (This is important because for curve modifiers to work well, the first handle needs to be in the same location as the curve origin, so we don't want our first handle sliding about.)

The second and third handles are hooked (no falloff) to empties.  For the third handle, this empty hook is then parented to our other outlet (inlet?)  The empty in this case is optional, you could hook directly to the mesh object.

This gives you a structure where the hose follows both of its connection points, and gives an additional center point for you to animate yourself.

What about physics?  Curves actually have a very good softbody implementation that allows for guidable physics.  Start by setting the weight of both end controls of your curve to 1.0.  (You can do this in the item tab of the sidebar while in edit mode with one or more controls selected.)  Then, give the curve a softbody modifier.  Finally, set your curve's physics settings appropriately-- you'll definitely want a goal default of 1.0, and you will probably want a goal Min of something larger than 0.  Hit your timeline's play button and try it out-- and try move the central hook empty while playing.

Note that while this gives you physics on the curve, it doesn't give you collision-- your actual curve is just a line.  You can disable rendering on the curve object and give it a bevel to create an actual surface to the curve for it to collide.

You could also skip the softbody physics and use rigid body physics, parenting your central empty to a rigid body (itself appropriately constrained to passive/animated rigid bodies).

With physics, you may see some inappropriate deformation of the tube.  Dealing with that is somewhat out of scope for this question, and dealt with elsewhere on Stack Exchange, but one way to handle it would be create a spline IK armature or a skin-modifier created armature for your curve and use that instead of a curve modifier to deform your tube.  This isn't as adjustable, though, as armatures don't have the same tools for non-destructive editing as curves do.

Edit: you can't give it a bevel to give it collision.  It will only ever collide with the verts on the curve.  To give it depth, you will instead have to scale up any collision meshes that might collide with it.


How to change the display_channel with python?

Make sure you have the correct context.

The context area needs to be a video sequencer. Quick console code, find the VSE and set the property from py console.

>>> for i, a in enumerate(C.screen.areas):
...     i, a.type
...
(0, 'INFO')
(1, 'PROPERTIES')
(2, 'CONSOLE')
(3, 'VIEW_3D')
(4, 'SEQUENCE_EDITOR')

>>> C.screen.areas[4].spaces.active.display_channel
0

If your script is invoked via a button or menu in the VSE area use

space = context.space_data

or

space = context.area.spaces.active

If it is not a VSE area / space then you will get an error (unless another space has a display_channel property.

Each area can have at least one up to  a space for each of the editor types. (SEQUENCER, CONSOLE, etc)  The one you are seeing is the active one. area.spaces.active Others you have had active at some stage are stored in area.spaces.

EDIT:

Find all preview VSE's in screen, and set display channel.

previews = [a.spaces.active for a in context.screen.areas
        if a.type == 'SEQUENCE_EDITOR'
        and a.spaces.active.view_type == 'PREVIEW']

for s in previews:
    s.display_channel = 3

As for bpy.types.SpaceSequenceEditor(display_channel = 5) what is the expectation here?. Instancing from bpy.types classes is very rare, and is mostly done via a new or add method.


In the upcoming 2.71 release there is a better way to achieve this.

Select edge ring (Ctrl+Alt+RMB)
Checker De-deselect, See note below!
Select -> Edge Loops
Mesh -> Delete -> Edge Loops

Note:

In 2.71 support has been added to deselect alternate edge-ring, See: https://developer.blender.org/T40324
This is detected automatically.

Previous answer, obsoleted by the method above

This is possible but a little cumbersome

In vertex mode select a loop running along the length
Select -> Checker De-seelct
Hide
Set edge mode
Unhide
Deselect the vertical loop
Select -> Edge Loop
Mesh -> Delete -> Edge Loop

Footnote, it may be worth adding a skip option to edge-ring select, which would make this only 2 steps.


This is expected behavior for Cycles and in line with the way a physically based render engine is supposed to work.

By assigning a purely emission shader to a surface you are telling the render engine that that surface has no other light path component interaction, and is only emitting photons, no light is absorbed, no light is reflected, no light is refracted.

If you expect more light path behaviors from said surface you have to add the corresponding shaders for those.

What this means is practically you have to use a Mix shader to mix the emission with other materials cabale of reflecting light from other sources, in this case a simple Diffuse or Glossy shader will do.

For clarity sake the "strong light" is red colored and the weaker one is blue in my scene.

Also as mentioned by Cegaton, you don't specifically need those boxes, if your only intent is to stop light. You can either use actual Lamp objects set to Area which will by default only emit light in one direction, or use a node setup similar to the one below to limit a certain shader to the front facing geometry only.


Rotating a single image texture for multiple instances

No, it's currently not possible. To "rotate" a texture, you actually rotate it's mapping, so it must be done before hand.


Good AMD GC but only find "SCRAPPER" where there should be a compute drop down menu

The answer is simple. Scrapper is the code name for the GPU Device used on my card. The reason Blender crashes when it begins to load the Kernels, is because my graphics card only has 512MB Memory. So when the loading starts, It uses up the entire 512MB of memory, then crashes when it realizes it needs more and can't get it (so-to-speak). My card is supported, I just need to get  one with more memory. :D


How to let softbody assume default shape again

Alright figured it out myself, you need to tweak the goal damping value. Not too low and not too high.

Used a value of 1 for this one and it now looks exactly like the original. You can see that the original is also still there, since there's a small shading intersection where the green shines through on the right.

Small update: I only made a few tests but it seems that the scale of your softbody also influences if and how fast it can assume the default shape again: The bigger the better.


How to create a "heat distortion" effect with a cycles procedural node set up without compositing

While it's not possible to vary the refraction throughout an object using volumetrics we can mimic the effect by varying the refraction at points on a surface and view the scene through that surface.

The Refraction shader affects the ray at the point of hitting the surface. If the ray hits the front of the surface then it is treated as a transition from air (IOR = 1.0) into the material, while if it hits the back of a surface then it is calculated as exiting the material back into air. Normally the ray would travel through the mesh, entering through one surface (bending one way) and exiting through another (bending the other way), resulting in the material acting like a prism. However, if we use a plane rather than a manifold mesh then only one side of the refraction effect takes place and we can use this to redirect the ray - as if it had passed through a lower density patch of air.

Refraction is dependent on the angle the ray hits the surface - with zero refraction if it's incident along the Normal and increasing refraction as the angle with the normal increases. We can use the 'Incident' Light Path property to determine the angle of the incoming ray and use this to manipulate the Normal of the surface to get the desired bending of the ray.

To achieve the effect, create a plane and add a new material to it. Open the node editor, remove the default Diffuse shader and replace it with a Refraction shader. Add a Geometry node and link the Incoming node with the Refraction shader Normal. This will mean that the Normal at any point in the shader will always be the same angle as the incident ray and will result in the surface behaving simply as if it were a Transparent shader (as all rays will hit it along the Normal and so no refraction will take place).

Add a Bump node between the Geometry node and the Refraction Shader to affect the distortion and feed this with your heat map as a series of images. Placing the plane between the camera and your scene will now distort the view to simulate heat haze distortion.

Note the addition of a Transparent shader mixed in for Shadow rays to prevent the distortion plane from casting a shadow. Also, ensure the Refraction shader colour is set to pure white.

For the heat map you can either use a Blender smoke simulation saved to a sequence of images or generate simulated smoke using a procedural texture. I used the following crudely generated heat map. This was generated using a Musgrave texture (and some noise), warped so as to taper towards the top, and masked off at the sides. It was animated by simply keyframing the Z-coordinate for the vector of the texture nodes.

This produced the following result :

See the attached blend files for details.

Heat Haze

Heat Map


You have some name problems, like "Leg Control.R.", you must delete the final dot ("."), otherwise it won't copy paste "Leg Control.L". Same thing for "Lower Arm IK.R.", "Leg Pole Target.R.001" and maybe some other ones...


It depends on what you mean when you say 'fade'. If you're looking to blend adjacent cells together then I think the only option would be as in the linked answer from Duarte's comment (How to blur a texture node in cycles material?). However, if you're looking to fade out one cell before fading in anther cell and you're using Blender version 2.8, then the new 'Crackle' option (which effetively gives you the distance to the 'edge') can effectively be used as follows :

The 'Crackle' mode of the Intensity  Voronoi produces an output that is 0.0 at the 'edge' of the cells and increases (towards 1.0) with distance from the edge. By subtracting it from 1.0 we reverse the direction and increasing the Power node gives a 'sharper' falloff.

An alternative is to exclude the Subtract and flip the inputs of the Mix node - and lower powers will now produce a sharper falloff.

For more detailed control you could simply use a Color Ramp :

EDIT: At Blender 2.80 the Voronoi node also gives you the Intensity and Cell color of the nearest 4 cells to that point in the texture. By combining the distances to the nearest 4 cells we can generate mix factors to allow us to mix between the difference colors of those cells and this allows a proper 'edge fade between colored cells'.

Here's the overall material :

Note the 8 Voronoi Texture nodes - all set to the same Scale, with one set generating the Colors of the 4 cells (closest, 2nd closest, 3rd closest, 4th closest) and the other set of 4 generating the Intensities.

The intensities are passed into a node group to calculate the relative mix factors from those intensities - to mix the respective cell color - and the mixing is handled by the other node group.

For the mixing, the Colors are combined using the following maths :

# Mix 4 colors based on the values of 4 factors

_color1 = Color1
_color2 = Color2
_color3 = Color3
_color4 = Color4

_fac1 = Factor1
_fac2 = Factor2
_fac3 = Factor3
_fac4 = Factor4

_factorSum = _fac1 + _fac2 + _fac3 + _fac4

Output = vdiv(vadd(vmult(_color1, _fac1), vadd(vmult(_color2, _fac2), vadd(vmult(_color3, _fac3),vmult(_color4, _fac4)))), _factorSum)

Note that I've used an add-on (Node Expressions) to convert the textual expression into maths nodes within the group (but I've included the Blend file so you can see the generated nodes for your own use if you don't have that add-on). This works by using Vector Multiply (vmult) to multiply each of the Colors by the associated Factor and then dividing by the sum of the factors. At its core this produces the following nodes :

ie, Multiply each color/factor, Add them together, Divide by the sum.

The cell distances are converted into mix factors using the following maths :

# Convert 4 cell distances into mix factors

#Define the inputs to the group
_dist1 = Distance1
_dist2 = Distance2
_dist3 = Distance3
_dist4 = Distance4

# Sharpness will control how 'sharp' the edges are. Avoid low values to avoid artifacts due to dense arrangements of cells (eg, where 5th Closest would have a significant influence at that range)
_falloffPower = Sharpness{3} * 10

#Factor of the 'current' cell will be constant
Factor1 = 1

#For the other cells, factor in based on how close it is compared to the 'current' cell - so that it is '1' at the boundary of the cell (so we get a smooth transition between cells)
Factor2 = (_dist1 / (_dist1 + _dist2)*2)**_falloffPower
Factor3 = (_dist1 / (_dist1 + _dist3)*2)**_falloffPower
Factor4 = (_dist1 / (_dist1 + _dist4)*2)**_falloffPower

Here the contribution of the 'current' cell is 1.0 and the adjacent cells are mixed in based on the distance to the 'edge' of the cell (using a similar calculation to that used to generate the standard 'crackle' output). The calculation is chosen such that at the edge of cells the contribution is always '1.0' - ie, the same as the 'current' cell. This ensures that when transitioning between cells (so the 'current' cells becomes '2nd Closest', for example) the contribution is the same, avoiding any 'hard' cutoffs in the blending between cells. The higher the 'falloff power', the quicker the contribution of the adjacent cells drops down to zero - resulting in a sharper edge.

Providing the Sharpness is high enough (so that the '5th closest', '6th closest' cells, etc. don't offer a significant contibution to the 'blend)) then this will produce a smooth transition between adjacent cells. This can produce the following result :

Note that one advantage using this method rather than using a Noise texture and multiple samples, is that since it's produced mathematically direct from the cells, it can be used for Bump mapping and Displacement. This means you can directly use it for 'tiles' or 'paving' or surface displacement to produce something like the following :

Blend file included


How to get the texture and color of a peeled and cross section of banana? Something like in the photo

This is a slice made to be slightly larger than the tube, two different materials.

tube has UV maps for smart unwrap for the sides and end and project from view for the straight end projection

Scaled up the slice on the y axis to prepare to use as booltool cutter

Set a booltool difference and then an error shows, to fix I swapped UV maps in the main tube image material