You cannot visualize vortex with fluid simulation voxel data, because there is nothing moving inside the fluid mesh, it all happens on the fluid's surface.

You would have to use 2 interacting domains and form the vortex with their interface by mixing them. This cannot be done in Blender since multiple domains cannot interact. You can simulate only 1 domain in scene, although you can playback multiple domains from baked files in single scene.

There are Trace particles for visualizing the movement of voxel liquid. Add some dummy mesh object (plane) into scene, enable fluid and set type to Particle and check Tracer. Under Domain > Fluid Particles set their count. But these particles are not always behaving nice (they stick to walls, play dead).

So you might want to use SPH Fluid Particle simulation instead and get a very nice vortex. If you mesh these particles with the CubeSurface addon you could also color the opposing streams differently so the render will be nice.


Graphics Card Not Avalible in Blender Internal

GPU Rendering is not available for Blender Internal

Blender Internal engine was designed to use CPU long before GPU rendering was available. To make the use of GPU in Blender Internal it will be necessary to rewrite the code of this rendering engine in order to adapt to different computation technology, currently it is not in the priority of the developers, but hopefully in the future.


Paste bones from one armature into another?

Shift D to duplicate the bones, P to separate them into a new armature and Ctrl J to join to the target armature is the way, so you have to understand what is breaking and why.
The target final armature has to be last selected, so it will retain its name, loc, rot, scale, and so on.
Both armature should start with everything applied (loc, rot and scale, Ctrl A).
All bones should have their own unique name before joining.
If theese conditions are respected, nothing breaks with joining.


Adding several textures to subdivided/leveled plane

It has been a while, but in case other people are looking for a solution:

To see UV mapped textures in the viewport set to GLSL shading and textured view.
You will also need to have some lighting in your scene or in the material setting enable 'shadeless'.

I had no light source in my blend project, which explains why everything went black. This is where enabling 'shadeless' for the material comes in handy.

credits: "Richard Marklew - blenderartists.org"


Extracting parallax data from only two photos to help reconstruct a 3D scene

Or you could try point cloud reconstruction software which are free to download using Visual SFM and Meshlab. There are a few tutorials on the subject on youtube. As the question you are asking will require substantial write up, it's best to point you to some tutorials.

I learn this in 3 hours last night. However you may need more than 2 images.

https://www.youtube.com/watch?v=D6eqW6yk50k


Why is 'Shader to RGB' possible in EEVEE, but not in Cycles?

It's technically possible, but not that practical.
You turn Shader to RGB through rendering. Because in Eevee one object doesn't depend on the whole scene and because it does rasterization it's way faster, which makes it practical.
In cycles you want to render your scene into render layers, that way you get the Shader to RGB data, and then you can do postprocessing on it, which is the same like using that RGB output from shader in Eevee. Or you can bake the material (render into texture) if you don't need anything dynamic.


Game Engine - Steering Behaviour Understanding

Possible result:

What you're searching for is called a "Navmesh" and it is done without any python-code.

Therefore you need the Steering-Actuator.

The Seek-Mode makes your object to allways face into the direction of the target and move towards it, until the set distance is reached.

The Flee-Mode is quite the opposite, it makes your object move away from the target, until the set distance is reached.

What you need for avoiding obstacles is the Path following-Mode. This mode uses a mesh that tells your object, where it can move and calculates the fastest way to the target.

1. Create a Navmesh - select every collision objects in your scene, including the floor. Then click on Build Navigation Mesh, which creates you a plane with holes, where your obstacles are. Play around with the Agent-Values if your scene has ramps or different hights...

2. Use the Navmesh by choosing your Navmesh as "Navigation Mesh" in your Steering-Actuator.


So as your demand has changed, here is a proposition for your plane wing, tell me if it's ok:


How do you model an object (car) without all the orthographic views?

Without any references to get accurate dimensions, you can take Artistic License on it.
Basically just decide upon what you believe the accurate dimensions to be and go off of them and GL.


Shift + S
Cursor to Center (alternative to 1+2: Shift + C)
. to change to Pivot Cursor
Scale your thing


Bone heat weighting problem, texture paint problem, blending model

This model is very messy. Firstly append it to a new file to fix some viewport messed up settings and make it an appropriate size.

Secondly, automatic weights freak out because of the inverted normal, recalculate them.

Thirdly, clean up weights and pose and reapply parenting.

The model is still a mess

It is better to take the original and optimize it. https://free3d.com/3d-model/leprechaun-v1--543940.html

Make him T-pose for better results.

Optimize geometry. Better to remesh it. But I won't .

You can also unwrap and bake normals.

The automatic weights are not very suited for this. It might be better to use something more advanced, which is actually intended as an auto rigger. For example https://www.mixamo.com/

Choose T-pose to export

Or paid addon for Blender: https://blendermarket.com/products/auto-rig-pro But be prepared to still fix something manually.

And finally: do not let the frustration beat you

and have fun

 Animations from Mixamo


How can I copy vertex groups from one mesh to another in Python?

Writing to vertex groups is fairly straightforward.  The API is documented at https://docs.blender.org/api/2.79/bpy.types.VertexGroup.html#bpy.types.VertexGroup

vg.remove( vertex_index_list )

removes vertices from the group (which is different than having a zero weight).  To set a weight for a vertex:

vg.add( vertex_index_list, weight, operation )

Usually you're using operation = 'REPLACE'.

Getting values from a vertex group is a little stickier.  The vg.weight(idx) call will throw an exception if idx is not in the group.  Checking if a vertex belongs to a vertex group in python has a couple of techniques for working around that (wrap it in a try block, or access the vertex group through the v.groups field on the vertex).

What remains is how you decide what weight to assign to each vertex on the destination and the relationship between the vertices in the two meshes.

One technique that might be useful is choosing the closest vertex.  The brute force way would be to calculate ( src.data.vertices[i].co - dst_vert.co).length for all the source vertices and use the one with the minimum value (which should give you the closest vertex to the dst_vert).


Problem with Boolean-difference modifier – or – How to model a cuboid with two cylindric holes

Because an intersection between two cylinders at 90 degrees is a 45 degree miter, this isn't too hard to model. Z up, Y along the lenght, X across

K with C to constrain and Z to cut through, make 2 45 degree cuts into  a half-cylinder as shown
E (right-click to cancel transform) followed by SX extrude the long edges outwards
Select all the faces, E extrude them downwards, followed by SZ0 about their median point to flatten them.
Select the central hole-faces on both sides, and CtrlE > Bridge Edge Loops
Header select menu > Select Sharp Edges, and add some by hand to complete the circumference of the top hole. Set the Bevel Weight of all the selected edges to 1.00

Assign a Bevel modifier by Weight, Segments 2, Profile 1.00. I usually switch off the clamps, and reduce the width until everything looks correct. Assign a Subdivision Surface modifier.


Cycles not rendering image or movie clip used as background in the viewport

Images (of movie clips) used as background in the 3D viewport are primarily meant to be used as reference and will not render.
Here are a couple of alternatives:

Using the compositor

Add an Input>Movie Clip node, and use an alpha over node to compose the render layers over it.

For single images use an Input>Image node.

If you are using cycles make sure that you enable Film Transparent, so that the rendered layers render with a transparent background:
ver 2.8X and newer

(for ver 2.79 and earlier)

Without the compositor

Without using additional geometry or compositing, you can use the image as background for the world. Set the Texture coordinates to Window.

In this case disable Film>Transparent


Re-UV with SmartUV after scaling UV island

Perhaps you could:

Select everything except the interior, then U Smart UV Project.
Select the interior and again U Smart UV Project.
Scale down and move this second unwrap where you want, or even, if you don't want to manage 2 UVs overlaying, give it a second material (with the same Image Texture).
Note that you could use Vertex Groups to facilitate the selections.
Also, in the UV/Image Editor, enable Keep UV And Edit Mode Mesh Selection In Synch so that you can see both the 2 UVs.


What you want is Project from View (Bounds). That will take what you see in the view and put it over top of the image, stretching it to fit.

Note that since the image you're mapping it to is square, this will likely make it too tall for your figure; you'll then have to scale your UV map down in the UV/Image Editor to make the squares actually be square. (Of course, you can just crop your image in an external program like GIMP to  have the right number of squares.)


How to convert grease pencil thick controur into 2d-mesh?

My solution has been to create a path with Krita then drag the png into Blender and "trace image to grease pencil". Then when you convert to polygon curve you get the result you are after.
It is possible to do it entirely within Blender by having Blender create the png from a grease pencil though it seems a little complicated.  Draw your shape with the grease pencil. Then give it a texture which defaults to black. Then change the world colour to white with no alpha in the shader editor.  Then add an opacity modifier to your grease pencil stroke and  in the modifer options set uniform opacity and select your material in the material dropdown.  You might need to add your layer in the layer dropdown as well.  Then, render your grease pencil as an image and save it as a jpeg.  You don't need your grease pencil stroke anymore.  Now, create an image empty and load your jpeg from the tab for empties in the properties section (You should be able to just drag the image into the viewport instead but I found this didn't always work).  This will give you your shape with a nice white background.  Now "trace image to grease pencil". Turn off visibility for your empty and then convert the grease pencil to polygon curve.  Remember to turn visibility off for your grease pencil at this point.


It looks to me in that tiny picture that your object is triangulated, and if so then you will definitely get artifacts when bending and stretching. If you can test your lattice and curve setup on a similar form made of entirely quadrilaterals, see if that doesn't fix the issue with the stretching.


If you just select the whole mesh and press F, Blender won't be able to know what's supposed to be holes and what's not, and it will fill everything. So create some additional vertices and fill the faces one by one with some F, except what's supposed to be holes:


As an expansion of gandalf3's answer, I'll give a quick workflow on how to make tiling easier...

Start with a mirror modifier on your object along both the X and Y axes.

Model the edges of the mesh. Since you have the mirror modifier, it will tile evenly along both the X and Y objects.

Apply the mirror modifier.

Hide the edges of the mesh (Select the edges you want to hide, then press H. To hide in sculpt mode press H (this will bring up box select) and select the very edges of the mesh), and model (or sculpt) the middle part of the rock.
Since you hid the outer edges, they will not be effected when modeling the rest of the rock.

Unhide the hidden edges (Alt+H)

Tile using the Array modifier.


How make glow in Compositing if emission is behind glass?

As an alternative to blur, use a glare node. It will give you finer control since the effect is based on a threshold, to effect the picture based on the brightness of the pixels.

Read:
Any way to control light halos in the compositor based on emission level?
Also, the default glass shader will not work correctly for a light that is behind glass.
Try something like this:

Read: How to illuminate the darkness inside glass objects in Cycles?

If you must use glow, you can use a pass index to determine what gets blurred.

For complete instructions on how to set this up read:
One part of the render layer glowing?


You can try moving the lights around a bit and increasing shadow resolution. You can also turn on screen space ambient occlusion to try to mask the error. Other than that, it's nothing you did wrong, just Eevee, as far as I know.


How Do You Have Objects Stay In Front Of The Camera While It's Moving?

You can Parent an object to the camera by first selecting the object, then the camera (so that the camera is highlighted in yellow), then pressing CtrlP> Object:

The object will now stay fixed relative to the camera:


2D draw mode can't get non-transparent line and paint color

Is your opacity on max? Check the Object Data Properties Tab (the one with the green squiggly line). If that's not it, can you post a pic with that Tab open?

Hmm, check all the layers for their opacity, other than that maybe the Masking causes it? (the dot next to the layer name)


Q:How can i Combine a fluid simulation with an ocean plane?

Here is a complete tutorial on how to combine ocean modifier and fluid sim to generate exactly what you are looking for: https://www.youtube.com/watch?v=qVwfEHtLiyI

And here is a simpler version just with the Ocean Modifier (for zoomed out shots for example): https://www.youtube.com/watch?v=smArCTzxGpE

Both techniques can be combined but tend to be resource-intensive when rendering. I would move between two scenes (close and wide) to optimize.


Numpad 7 to go to top view

Numpad 5 to go into orthographic

RMB on your camera

and Ctrl+Alt+Numpad 0

This will move your camera to your view

Now if you F12, you can render whatever your camera is looking at


Sculpting smooth model with jaggered vertex

I'm by no means an expert but when sculpting this can occur quite frequently, ideally you use dynamesh and smooth it to prevent the pinches from forming in the first place but if it can't be helped you could select the area from edit mode wireframe (mind the backside of the model), weld all the verts so it's a flat surface, dynamesh and continue. There are probably better solutions, but this is how I've figured to solve it.


Selected meshes vanish when in object mode

Most definitely a glitch, because the only other instance I know of something like  this happening is when a cube I added in POV-ray rendering disappeared in edit mode because a certain script wasn't installed. Try re-opening Blender, and if that doesn't work, then you may have to uninstall Blender then re-install it.


There are two nodes that can be used to generate a random number within your node group.

Object Info -> Random generates a random number between 0 and 1 for each individual object.
Geometry -> Random Per Island does the same for each disjointed piece of mesh within an object.  So this one can be used with Array modifier, for example.

You can use these random values for many purposes.  You can basically seed your textures by changing the position of the texture in coordinate space, or drive the W value of a 4d texture.  You can also use a color ramp to define a range of colors to choose from.

The Math -> Multiply node can be used to effectively modify the range of the output.  E.g. multiplying by 20 gives you a random number between 0 and 20.


How can make the state of a boolean property relative to the 3d view area?

Make it a screen collection property

The best fit would be bpy.types.Screen Then the issue is a screen can have many areas, and we cannot tack a rna property onto a bpy.types.Area

I have fudged around this by keeping a collection indexed the same as the area collection, and make a collection item property the boolean. Eg context.screen.my_collection[i].my_bool where i = context.screen.areas[:].index(context.area) Would need some way to keep consistent when areas are merged, created.

Here I've populated on register, adding an item for a potential 20 areas per screen.

import bpy
from bpy.props import StringProperty, BoolProperty
from bpy.types import PropertyGroup, Panel, Scene
from bpy.utils import register_class, unregister_class

class MyPropertyGroup(PropertyGroup):
    mybool : BoolProperty()

class PANEL_PT_panel(Panel):
    bl_label = "Boolean relative to 3d view area"
    bl_space_type = "VIEW_3D"
    bl_region_type = "UI"
    bl_category = "View"

    def draw(self, context):
        screen = context.screen # notice no bpy needed
        layout = self.layout

        row = layout.row(align=True)

        col = row.column()
        i = screen.areas[:].index(context.area)
        ap = screen.my_area_props[i]
        col.prop(ap, 'mybool', text="My Bool")

classes = (MyPropertyGroup, PANEL_PT_panel)

def register():
    for i in classes:
        register_class(i)

    bpy.types.Screen.my_area_props = bpy.props.CollectionProperty(type=MyPropertyGroup)

def unregister():
    for i in classes:
        unregister_class(i)

    del bpy.types.Screen.my_area_props

if __name__ == "__main__":
    register()
    # over populate it
    for screen in bpy.data.screens:
        screen.my_area_props.clear()
        for i in range(20):
            screen.my_area_props.add()


How do I make more complex LEGO simulations in Blender?

The final codes requirements are listed at the end of the post.
The tutorial by Ray Mairlot, which JBlock linked in the comments, is helpful for fluid simulations, or anything with a surface.
I will give insight into a method for volumetrics, specifically smoke, with different pieces. For professional use, you could include pyopenvdb (the install is complicated) functionality.
We can access the density_grid of the smoke with python. From [brickarchitect.com], we gather the dimensions of the smallest brick. (The smallest brick is a third of the heigt in the following image: 3.2mm.)

Click to enlarge
Distinguishing Slopes with Convolution
We will use convolution with the smoke simulations density_grid to decide, if we should use a sloped piece or not.
Im going to use the 2 (5) bricks. brick2 comes in 4 rotation variations, which all have their origin at the bottom left.

Click to enlarge
Understanding convolution is crucial, and I recommend Understanding Convolutions and then Intuitively Understanding Convolutions.
Consider two 2 dimensional 2x2 kernels (red and blue) and a 5x2 image (gray).
To do a single convolution step, overlay a kernel over the image, multiply the overlaying number, add them together, then place them on the image at the position of the top-left square of the kernel.

For the red kernel, the convolution of the first pixels, look as follows.

For each different shape [5 (rotated) bricks] we will create a kernel and convolve it with the image. Then, we will compare the kernels and choose the maximum value for each pixel. Looking at a single kernel, we compare if its convoluted image has the same value as the maximum image. If yes, we can choose the shape and place it at that pixel.
I noticed, that we will need higher resoluted kernels for the slopes and have chosen a 6x9x1 kernel for a sloped piece.
By changing the weights of each kernel, as well as the maximum image, you can easily adjust the ratio of each piece. In my first render, slopes were quite sparse.

Click on the gif for a higher resolution.

In practice, we can just construct the kernel as a np.array and divide it. The more we divide it, the less it will contribute.
brick_1.kernel = np.array([[[1, 1, 1]]]) / 8

Steps
Do a smoke simulation.
Import the usual helpful modules for python.
import bpy
import bmesh
import numpy as np
from mathutils import Vector
from math import floor, ceil
import scipy.ndimage

Get the smoke modifier settings off the domain object.
Get the density_grid and calculate the step size. I used a cube, with its bottom-left corner at the world's origin as the domain.
depsgraph = bpy.context.evaluated_depsgraph_get()
smoke_obj = bpy.data.objects['domain'].evaluated_get(depsgraph)
smoke_domain_mod = smoke_obj.modifiers[0]
settings = smoke_domain_mod.domain_settings

grid = settings.density_grid
thres = max(grid)/2
res = settings.resolution_max
max_dim = max(smoke_obj.dimensions)
x_step, y_step, z_step = 1/res, 1/res, 1/res
grid = np.array(grid).reshape((res, res, res))

If we construct a mesh from this data, and add vertices if the density_grids values are over a certain threshold, then we can visualize the data with vertices.
bm = bmesh.new()

for z in range(0, grid.shape[0]):
    for y in range(0, grid.shape[1]):
        for x in range(0, grid.shape[2]):
            if grid[z, y, x] > thres:
                bm.verts.new((x*x_step, y*y_step, z*y_step))

bm.to_mesh(bpy.data.objects['result'].data)
bm.free()

After this prototype, for real now. Create a class to sample an object once and instantiate later in another bmesh for the brick types.
In this class

store a brick bmesh
store a kernel
add a method to instantiate the bmesh in another bmesh, we can do this by looping of the vertices and faces in the original mesh and adding them to the new mesh
add a method to instantiate multiple copies. It takes a grid with True and False values as the input and operates in steps of X = 0.008 | Y = 0.008 | Z = 0.0096, the values we read from the original brick image.
as a bonus I pass along a "color_grid", which we can use to give certain faces a different material index. Currently, faces get assigned to two material slots, so make sure that the target object, which will hold the lego geometry has in fact two materials on slot 0 and 1.

class Brick(object):
    def __init__(self, name):
        self.bm = bmesh.new()
        self.bm.from_mesh(bpy.data.objects[name].data)
        self.bm.verts.ensure_lookup_table()
        self.bm.faces.ensure_lookup_table()

        self.kernel = None

    def instantiate(self, bm_target, at = Vector((0, 0, 0))):
        verts = [bm_target.verts.new(v.co + at) for v in self.bm.verts]
        faces = []
        for f in self.bm.faces:
            face_verts = [verts[v.index] for v in f.verts]
            faces.append(bm_target.faces.new(face_verts))
        return faces

    def place(self, bm_target, grid, color_grid):
        sx, sy, sz = 0.008, 0.008, 0.0096
        for z, y_ in enumerate(grid):
            for y, x_ in enumerate(y_):
                for x, value in enumerate(x_):
                    if value:
                        faces = self.instantiate(bm_target, Vector((sx*x, sy*y, sz*z)))
                        mat = 1 if color_grid[z, y, x] > 40 else 0
                        for f in faces:
                            f.material_index = mat

brick_1 = Brick('brick_1')
brick_1.instantiate(bm, Vector((0.2, 0.1, 0)))

Since the evenly spaced voxels are not the appropriate size for the bricks (which have different x, y, z dimensions), we have to resample the grid with scipys ndimage.zoom function. Note, that the original grid will have stored the values in z, y, x order, which we will work with.

Get the dimensions of the smoke_obj in the 3D space and reverse them.

Calculate the amount of sample which the smoke simulation has, by using the smoke_domains settings' resolution_max.

Calculate how many lego samples we require. I used the original bricks dimension and multiplied it with 3. Then we end up with a 6x9
dimensions = np.flip(np.array(smoke_obj.dimensions))
samples_smoke = dimensions / np.max(dimensions) * domain_settings.resolution_max
samples_smoke = np.floor(samples_smoke)
samples_lego = dimensions / np.array([0.0032, 0.008, 0.008])
samples_lego = np.floor(samples_lego)
zoom_factor = samples_lego / samples_smoke * 3
grid = np.array(grid).reshape(samples_smoke.astype(int))
grid = scipy.ndimage.zoom(grid, zoom_factor, order=1)

Example: If the z, y, x dimension of the domain cube are 0.51, 0.32, 0.32, and the resolution_max is 64, then the voxels are resoluted as 64, 40, 40. The amount of small (3.2mm x 8mm x 8mm) lego pieces in that area would be 159, 40, 40, which is stored in samples_lego. This results in a zoom_factor of 7.45, 3, 3 and a resampled grid the size of 477, 120, 120. We have to use ndimage.zoom with and order=1 interpolation, because with higher order interpolation, we could receive negative numbers.
I will construct the kernels for these bricks with numpy.

brick_1.kernel = np.array([[[1, 1, 1]]]) / 8
brick_1.kernel = np.repeat(np.repeat(brick_1.kernel, 9, axis = 0), 3, axis=1)
brick1_grid = scipy.ndimage.convolve(grid, brick_1.kernel)[::9,::3,::3]

brick2a.kernel = np.array([
                            [[-6, -6, -1, 0, 1, 1]],
                            [[-6, -5, 0, 1, 1, 1]],
                            [[-5, -3, 0, 1, 1, 1]],
                            [[-4, -1, 0, 1, 1, 1]],
                            [[-3, 1, 0, 1, 1, 1]],
                            [[-2, 0, 1, 1, 1, 1]],
                            [[-1, 0, 1, 1, 1, 1]],
                            [[1, 3, 1, 1, 1, 1]],
                            [[3, 3, 1, 1, 1, 1]]
                            ]) / 84
brick2a.kernel = np.repeat(brick2a.kernel, 3, axis=1)

The first kernel has dimensions of 9, 3, 3 and the second kernel has dimensions of 9, 3, 6, since it is a 2 slot brick.
Since we are using a grid, with a higher resolution than our brick size, we can adjust the step size through that grid to get to the discrete steps the size of our smallest brick.
brick2a_grid = scipy.ndimage.convolve(grid, brick2a.kernel)[::9,::3,::3]
brick2b_grid = scipy.ndimage.convolve(grid, brick2b.kernel)[::9,::3,::3]

To check which if the convolved grids, has the highest value, construct a max grid with a small initial value (0.065). Where there is no smoke, the other grids will have values of 0. When comparing them to our small number in each cell of the max_grid, the max grid will be larger. This results in no bricks filling those spots. No smoke -> no bricks.
For each brick, we check if it has larger values in its convoluted grid.
max_grid = np.ones(grid.shape, dtype=np.float)[::9,::3,::3] * 0.065

max_grid = np.maximum(max_grid, brick1_grid)
max_grid = np.maximum(max_grid, brick2a_grid)

If we compare a grid of a brick with the max_grid (brick1_grid == max_grid), then we get a binary array, which holds True for the positions, where we have to place the brick kind. For that, I use the place function which we wrote earlier.
bm = bmesh.new()
brick_1.place(bm, brick1_grid == max_grid, density_grid)
brick2a.place(bm, brick2a_grid == max_grid, density_grid)
...

For the rotated brick2's (brick2b, brick2c, brick2d), we can simply switch flip the kernel of brick2a and/or swap its axes.
Download the script here
The final code (github: smoke_to_lego.py) assumes

a baked smoke domain object named 'domain'
the brick objects brick_1, brick_2a, brick_2b, brick_2c, brick_2d
a target mesh object named result
an installed scipy module. You can install a module for your local python distribution, but I choose the unclean, easy way and simply did a pip install (python -m pip install scipy) in Blender 2.8 python executable directory.

After downloading the file, bake the smoke simulation. Then execute the script on a frame with smoke. The script takes approx 5-20s in the given resolution during which Blender is unresponsive.
To render all of the frames, simply call the wrapped operation while looping through all frames.
# call the method to generate the geometry for this current frame
if True:
    generate_lego_geometry()

# loop through all the frame to render all frames
# this will be slow and won't show visual feedback
if False:
    scn = bpy.context.scene
    for frame in range(scn.frame_start, scn.frame_end + 1):
        scn.frame_set(frame)
        generate_lego_geometry()
        scn.render.filepath = "//output/" + str(frame).zfill(4) + ".png"
        bpy.ops.render.render(animation=False, write_still=True)

I won't update the script in the .blend. The github link is up to date.


Texturing problem looks like broken image

You seem to have two identical shapes and polygons in exactly the same places. One set of polygons has the texture and the other doesn't. Double-check this by right-click selecting anything in that space. Then press M and 2 moving whatever was selected to Layer 2. Whatever geometry stays behind will tell you which object, textured or not, you selected.

X Delete what's not needed. If what you needed was moved to the second Layer, press 2 along the number row (not numpad) and Right-Click select it and press M and 1 to move it to the first layer.

Blender Render and Cycles do not play well with sheets of polygons in identical locations.


How do I know if Blender is making use of CUDA to render?

If you have properly set up CUDA and selected GPU Compute in the Render Properties panel then Blender should be using your GPU.  (Though I have seen instances where having two different Blender files open separately and both rendering switches the GPU one to CPU mid-render.)

Probably the easiest way to make sure that Blender is utilizing your GPU is to use some sort of monitoring program.

My Favorite is NZXT CAM, it's pretty sleek and works very well.  CAM monitors and gives graphs of CPU and GPU load, temperature, voltage draws, and fan speeds.  It also shows which programs are using the most load.

HW Monitor is another very popular choice, it doesn't have all the options that CAM has though.  It basically just shows you the current values, minimum, and maximum of each spec.


How to make displacement to effect all the surface?

You need to do several things:

Select your plank and in the Properties panel > Material tab > Settings > Surface > Displacement, enable Displacement Only, otherwise the Displacement node won't give anything.

Give your plank a Subdivision Surface modifier so that it has geometry to move.

Switch to Render mode to see the result, apply the scale of your object so that you have a 1/1/1 scaled object, you'll see that it will go crazy because of your settings.

So just adjust the settings (didn't try to understand all your nodes organization though).


Texture appears to stand still when the camera is animated

That texture that doesn't move is caused by having the same seed for noise on every frame, so the final render has a fixed noise pattern.

You need to animate the noise seed. Use the Clock-like icon on the sampling settings and render again,


How to separate an armature bone from an armature bone in an animation?

If you want to separate the bones:

• Select the armature;

• Enter Edit Mode;

• Select the bone you want to separate;

• Hit "p";

• Click Separate bones.


Removing weights does not work flawlessly

The falloff seems to be the important factor here:

Once I sat it to the bridge-like preset, it worked fine.


Cutting off a cone as if it is a light ray

I don't know if I got it but I'll try: the way you placed the "cone light" respect to the "box cage", makes me guess that the "box front face"  should be totally transparent, a sort of "window"...?

If so, the cone hits the sides of that "window", thus the exiting shape is limited by that (it will be straight), while the upper part of the cone is not hitting the box limit, so it will exit the box keeping its shape...

something like this? (the side part of the cone are straight)

here below I tried to use colors to explain better

the box is red
the cone part that exits the cube "untouched", without interfering with the window shape is blue
the cone part that exits the cube "cut", due to the window shape is yellow

I'll provide steps to reproduce if it is what you want (you'll need one boolean and scaling the "intersect" respect to the origin point)

Here are very detailed steps (it could seem somewhat too much, but since you're a beginner...)

we start with the two shapes (note the box has a "closed window", needed for the upcoming boolean modifier)

then we select the cone and insert a boolean modifer

with the cube as target and mode "intersect" (previously I wrote "difference", wrong)

as soon as you confirm, the cone shape is "cut" to the part that intersects the cube

now you'll need to "apply" this modifier (makes this "cut" permanent)

and you're left with this shape

seeing it within the cube wireframe confirms that it's been perfectly cut.

Note: I already palced the 3D cursor to this vertex (cone origin), and set pivot transform mode to "3D cursor". This will come handy later.

now we need to switch to face mode select and delete this face (only faces)

then you need to switch to vertex select mode and select this "ring" of vertices

now, a strange move: we need to start an "extrude" of these selected vertices, but nothing more, so press E, then immediately ESC or RMB) to stop the extrusion, leaving the extruded new vertices where they started from. WHy we need those new vertices to be exactly where the previous were, but independent, to be able to generate a new shape later...

then, you immediately start a scale operation with S: since you set the pivot transfor mode to 3D cursor, and the 3D cursor is at cone origin, the scale of those "extruded" vertices is made respect to the 3D cursor... which makes them follow the intended "projection" direction

and stop it, confirming, when you wish...

This leaves the part of the cone that is inside the box untouched, while the part exiting the cone "cut" by the box shape

You may finally want to remove the "window" face, and get the final result:

That's it: it's been a bit long, but hopefully easy to follow... ;)


Texture Painting and Uv: how to control Target image?

sharing some pictures and the .blend file could help a lot
(since i don't have enough rep to comment your question i said it here)

anyway i show you the steps hope it helps:

first you have to set up a few different uv maps:

one for the texture and a few more for sides, back, top, etc.

you can use ALT+B to cut the mesh so you only select the vertices that are visible from that angle

like this

then align the uv with pictures you want to copy from

after that go to texture paint mode and create a texture for the face

(explained in the picture)

hope it helps


Why isn't Rigify adding constraints to the bones it generates?

The grey bones you see is a predefined armature template riggify uses to generate the actual armature.

The template armature ( grey bones ) are there for you to line them up with your mesh so that when you generate the rig everything is in the right position and you can start weight painting or autoweighting directly.

If you want to see the complete setup you can enable the layers in the armature properties. The bones you start out with can be discarded, these are no longer used beyond the point of generating the actual armature.


It all depends on your game. although unreal is good at handling high poly assets if you do LOD.
The smoothing option is for smooth shading.

My recommendation would be to make range of tris budget count for assets (like up to 2k tris for none important and up to 12k tris for important, although if its a vr game you can go higher it's up to you and your target hardware and frame rate)


How to get rid of double faces on my mesh?

Consider

using Mesh/Cleanup/Limited Dissolve.  Mesh Menu in Edit Mode.
using a Mirror Modifier to keep both sides exactly the same.  This means you would delete one side, right or left and let the modifier keep the sides in correspondence.  The modifier can merge the middle vertices.
Delete the loop ring.  Then Bridge Edge loops on the two open loops which need to be closed. This is on the Edge menu.


Parenting the camera to the object will solve this problem. You can do this by selecting the camera first, and then selecting the object you want to parent it to. You can parent by pressing CtrlP, and then selecting object (keep transform). This should fix the problem.


Is there a way to make the active selection more noticeable?

Switch you view to user preferences. Select 3D View from the left.  You will find what you need
Consider Zooming.  Number Pad (.) period then you can zoom at center.
User preferences allows you increase the size of the outline and vertex dots


this is the standard way to create a hole inside a plane (you can do it manually or with few clicks with loopToops addon): as you can see, there are only quads and this will allow you to add subdivision modifier or shade smooth with not strange artifacts


Parameterize Mesh or object imported from blender file?

This is what Library Overrides are for :
Create your base object, add a custom property. Don't forget to check Is Library Overridable in the property settings. Use a driver to drive, for instance the scale of your object.

Save your blend file. Go into your work file, and link the cube object. (File > Link > Yourfile.blend > Object > Yourobject)
Select your object, then go to Object > Relations > Make Library Override > Accept the dialog.
This will create another instance of your base object, which is in fact an override. (Piercing arrow and chain icon)

Select the library override, and go to the object properties. Notice your custom prop is not greyed out anymore. You can tweak it as you wish. If you Duplicate your object, you will be able to specify different overrides for this property as well as others. An override property will by default be in a light blue color.

If you want to override the object's material, set the mode to to Object and then you can change it as you wish :


objects that needs to receive shadows (ground or other objects) can't be shadeless. They need a material with shadow/receive (and/or receive transparent) box checked.
Objects with baked shadows (monkey and icosphere) can have their cast, cast only, cast buffer shadows and cast approximative boxes unchecked. They won't cast shadows on the player (or anything) but it's not a real problem i guess.


As far as I know, only special custom data layers can be used in a render or the 3D view:

Loop UV
Loop colour (i.e. vertex colour)
Vertex defom (i.e. vertex groups) - but only indirectly, e.g. as deformation

If you want to see your data in a render, you need to transfer it to a UV layer or vertex loop colour layer first. To transfer to a colour layer, you can do something like this:

color_layer = mesh.loops.layers.color.new('Foo')
for vert in mesh.verts:
    val = vert[my_cdata]
    col = (val, val, val)
    for loop in vert.link_loops:
        loop[color_layer] = col

Then you can use the 'Foo' layer in a render.

Note that val will be automatically clipped to be between 0 and 1.

When transferring to vertex colours you will lose precision, because each channel is stored in a single byte (whereas float custom data is stored in 4 bytes). You can get better precision by using a UV layer, which stores floats - but only two channels (x and y). When using a UV layer, the values will not be color-managed; this can be useful or not, depending on your material. Storing in a UV layer is similar:

uv_layer = mesh.loops.layers.uv.new('Foo')
for vert in mesh.verts:
    val = vert[my_cdata]
    for loop in vert.link_loops:
        loop[uv_layer].uv.x = val


There are a lot of "fixes" to this problem. For me, this one do the trick Blender (2.83, UE 4.20):

As things stand right now, the importer for fbx is effectively patched (a nice word for hacked) to allow as exception for Blender made fbx files if the name of the root node is 'Armature'.

Source: https://forums.unrealengine.com/deve...blender-export


Remove individual instances in an array?

How about using the Array modifier for one side (8 of the spikes) and then a Mirror modifier to replicate that on the other side?


Converting from quads to triangulated mesh

Select your object. Enter edit mode (Tab) and press ctrlT to tirangulate.

The tools has a few options:

Beauty Split the quads in nice triangles, slower method.

Fixed Split the quads on the 1st and 3rd vertices.

Fixed Alternate Split the quads on the 2nd and 4th vertices.

Shortest Diagonal Split the quads based on the distance between the vertices.


You have some kind of snap turned on, click on this button to deactivate


One fast way is to use Box projection.

Set Image projection to Box
Change coordinates from UV to Object
In Texture Coordinate > Object field, target any object (I used an empty)


Setting an object to a random position in the BGE

The problem is that your script controller is on the Enemy Dropper object and attempts to reference mySensor which does not exist on that object. If you check the console, accessed by Window > Toggle System Console (only on windows systems), you will see an error.

  Traceback (most recent call last):
    File "Setting Position.py", line 9, in
  KeyError: 'value = gameOb[key]: KX_GameObject, key "mySensor" does not exist'
  Python script error - object 'Enemy Dropper', controller 'Python':

To make it operable, add the mySensor sensor to the Enemy Dropper object's logic bricks.


How do I evenly emit particles from a surface?

Increasing the subdivisions of the mesh should help, you will just need to make sure the subsurf modifier is above the particle system and then check 'Use Modifier Stack' in the particles panel.

Another option is to add some random velocity to the particles in the Velocity panel. It seems (based on brief testing) that adding random velocity will produce nicer results when emitting from volume as opposed to faces.


By creating a new image in the UV/Image editor and using a mixRGB node to mix it with the render layer you can get the same result as a photoshop layer. Each image created and mixed in using the compositor will correspond to one layer in PS. You will find each blend type of the mix node will correspond to a layer mode in PS. The alpha of the image or a separate image can be connected to the fac of the mix node for a layer mask. We can also create and animate a mask. While the render result or viewer node preview doesn't update as you paint, it does update after you complete each stroke.

So while we don't get the simplicity of the way layers are presented and edited in the same location, we can get the same end results, even with some extra flexibility in how they are combined by using blenders compositor node system. The other factor to differentiate PS and blender will be the amount of painting tools available.


How to Make Pose Position same as Rest Position

It looks like the only thing causing you issues is the IK constraints on the limbs. Go to each constraint and adjust the pole angle until it looks like the rest position. If you enable the display axes options you will have an easier time seeing which way you should adjust the angle as well.


Is there a way to tell my particle system what collection to use based on what color the color ramp is using?

I'd suggest to do it the other way around: Having diffrently colored objects in a collection and instancing them via the particle system.
In the render tab of the particle system choose reender as collection.

Option 1: pick random. (even distribution)
Option 2 if you want more controll how often the objects are instanced in relation to each other you can use the "count" feature.
(Option 3 for even more controll use the AddOn Animation Nodes)

Update 1:
This intent you have is a advanced procedural workflow. I think its fun to work like that but it needs a bit of trickery often. As far as I know Blender has no native functionality like that, because this is very specific also, and blender is not a fully procedural tool.
The AddOn Animation Nodes is a gamechanger in terms of making the python interface more acessible and easier to handle.

Here is a barebone example in AN (Animation Nodes) that changes instancing collections in the particle system. The boolean value (See A) would get your logic as input that does the color allocation or gets the color from the material and sets the corresponting partile collection.

Going this far with animation nodes, maby it is simple to use it also for color allocation. At the moment you do it with ObjectInfo.random wich gives you no controll. If you have multiple Color-Sets you could smoothen the workflow with Custom Object Propertys that AN interprets an does the rest.
Then the only thing you would have to do would be to duplicate the object and change its custom property.


Issue with oddly shaded faces in Blender 2.82

After going crazy with button-pressing, I finally solved it. Under the Object Data Properties tab, I selected "clear custom split normals data" and voila! No idea why the model imported with that...but at least this was one issue that was solved by pressing random buttons! Thanks to everyone that viewed/was willing to help.


Something like this?

Make your letter(s), then extrude them with the text controls.
When it's about where you want it to be, do Object > Convert to > Mesh.
Now you can use a boolean modifier to cut it to the final shape.
Here's some information on the Boolean Modifier, if you need it: https://www.blender.org/manual/modeling/modifiers/generate/booleans.html


Any way to copy texture coordinates like UVW Map in 3ds max?

You can use tri-planar mapping, which is even faster to setup and allows to control the scale in one place.

Create one material for all objects
Set the projection method of the Image Texture node to Box (Tri-planar option in Blender)
Adjust the Scale values of the Mapping node


Assuming you just want to toggle Wireframe View on the selected Object, you need a different context for the hotkey.

Since what you want to influence is a Checkbox that would be wm.context_toggle

In the Context Attributes Field that will appear when you set this, just paste the Data Path that you copied from the Checkbox, in our case object.show_wire

This should look something like that:


Blender 2.8: Best way to copy moves (rotations and translations) between 2 meshes

Is this the effect you're looking for?

The trick is to set "Mix" to "After Original" and the "Copy Transforms" constraint goes on the follower object.


Warning: 'CLASS_NAME' doesn't have upper case alpha-numeric prefix

The part before _PT_ must be uppercase alphanumeric to suppress the message (no special characters).  You can use whatever for the part after it though.
You could rename your classes to :
ABC_PT_Gltf and ABC_PT_Fbx. The _PT_ part means it is a panel class so there is no need to write it again afterwards in my opinion.


Make one button (mouse or keyboard) Do two different things

In Blender hotkeys are devided in areas, that you can see in the User Preferences.

While your mouse is hovering over a certain area (for example the 3D Viewport or the UV Editor), that area is the active one, and when you press a button it will use the command of that specific area.

For example, when you press Alt + P, if your mouse is in a 3D View window, it will bring up the Clear Parent menu, while if it is in the Text Editor it will execute the Run Script command.

To change an hotkey for a specific window (let's say the UV Editor) you need to go in the User Preferences>Keymap>Image>UV Editor and modify/add your hotkey.

In your question you mention the "modeling tab", so you are speaking of the Workspaces in Blender. These are just different ways to arrange the different windows/panels in the UI, they are not different sections of the software: a 3D Viewport is the same in all workspaces, therefore all hotkeys will remain the same across different workspaces


The strategy in this example is to generate the displaced position Q of the shading point P (in an originally planar Object space), and subtract P from Q to give the displacement vector.

The displacement is masked. If P is outside the input Radius (r2 in the tree) from object 0 , it is not displaced. A soft border has been put on the mask to prevent unsightly tearing of the surface.

Q's Z is a mapping of the mask-circle. The circumference of the circle is mapped to Z = 0, the center to Z = (Input) h. The circle is 'drawn upwards' from its center.

Q's X and Y are more easily calculated in polar coordinates. There are 2 groups in the tree, for converting  between polar and Cartesian coordinates, so the mapping need only be of r, the radius of P. (Pr -> Qr)

First, Pr, the radius of the shading point, is remapped from 0->r2 to -1->1, so it uses the full range of the Vector Curves node. The result of the curve in the node is then mapped to 0-1. The result, Qr, is recombined with the original theta to get Q's X and Y, and plugged into the 3D vector Q, the displaced position of the shading point. That is then subtracted from the original shading point. The Y and Z components in the Curve node have been set to map to 0.

A shader-generated pawn

I'll try to get this into Blender-compatible tangent space (unfortunately, that's not standard), so it can be, say, tiled onto deformable surfaces.

EDIT:

OK, some progress, this has been shuffled into Tangent Space:

.. which involves working in corner-to center displaced UV coordinates, and subtracting radii, rather than entire displacement, and adding the Y -> Normal coordinate in as an absolute component.

This answer is getting long, so I won't illustrate the tree again, it's in the Blend. But there's still a problem: this does not scale elegantly. The Normal displacement (which is absolute)  is not proportional to the face size (which is relative, from the UV mapping). Again, I'll try to fix this, unless you or someone else gets there first. I hope eventually we can get to a single switchable tree, which would be more generally useful, and strip this answer back.


How can I make a shiny edge material in cycles?

Here is Sonic's basic material setup.
The trick is Fresnel with a little help from AO.


the best way is sculpting at a low resolution with dyntopo or with multiresolution instead if you dont care pretty much of making a retopo after doing a dyntopo sculpt , because dyntopo is triangle based topology, but multiresoltion is quad based topology.
thats my two cents...if you need more info tell me...


draw text always face the viewer in 3D view

Thank you for all of you comments, and sorry for my rough question.

But I guess I have found the answer:

I've used wrong arguement for the bpy.types.SpaceView3D.draw_handler_add() function. 'POST_PIXEL' shold be used here as the 4th argument, but 'POST_VIEW' was used. I guess 'POST_PIXEL' is for 2D text, and 'POST_VIEW' is for 3D text.

Code and screenshoot as below:

import blf
import bgl
import bpy

RED = (1.0, 0.0, 0.0)
GREEN = (0.0, 1.0, 0.0)

position_1 = (50, 50, 0)
position_2 = (0, 0, 0)

def draw(position, color):
    blf.position(0, *position)
    blf.size(0, 20, 72)
    bgl.glColor3f(*color)
    blf.draw(0, "hello,world")

_handle = bpy.types.SpaceView3D.draw_handler_add(draw, (position_1, RED), 'WINDOW', 'POST_PIXEL')
_another_handle = bpy.types.SpaceView3D.draw_handler_add(draw, (position_2, GREEN), 'WINDOW', 'POST_VIEW')

update:

I've asked someone in our community, and I was given some tips about the 3rd argument, which maybe represent for region type and enumerate in 'WINDOW', 'HEADER', 'CHANNELS', 'TEMPORARY', 'UI', 'TOOLS', 'TOOL_PROPS', 'PREVIEW'.

Code and screenshoot as below for your reference:

import blf
import bgl
import bpy

RED = (1.0, 0.0, 0.0)
GREEN = (0.0, 1.0, 0.0)
BLUE = (0.0, 0.0, 1.0)

position_1 = (0, 0, 0)

def draw(position, color, text):
    blf.position(0, *position)
    blf.size(0, 20, 72)
    bgl.glColor3f(*color)
    blf.draw(0, text)

_handle_1 = bpy.types.SpaceView3D.draw_handler_add(draw, (position_1, RED, 'WINDOW'), 'WINDOW', 'POST_PIXEL')
_handle_2 = bpy.types.SpaceView3D.draw_handler_add(draw, (position_1, GREEN, 'HEADER'), 'HEADER', 'POST_PIXEL')
_handle_3 = bpy.types.SpaceView3D.draw_handler_add(draw, ((100, 0, 0), BLUE, 'CHANNELS'), 'CHANNELS', 'POST_PIXEL')
_handle_4 = bpy.types.SpaceView3D.draw_handler_add(draw, ((250, 0, 0), RED, 'TEMPORARY'), 'TEMPORARY', 'POST_PIXEL')
_handle_5 = bpy.types.SpaceView3D.draw_handler_add(draw, (position_1, GREEN, 'UI'), 'UI', 'POST_PIXEL')
_handle_6 = bpy.types.SpaceView3D.draw_handler_add(draw, (position_1, BLUE, 'TOOLS'), 'TOOLS', 'POST_PIXEL')
_handle_7 = bpy.types.SpaceView3D.draw_handler_add(draw, (position_1, RED, 'TOOL_PROPS'), 'TOOL_PROPS', 'POST_PIXEL')
_handle_8 = bpy.types.SpaceView3D.draw_handler_add(draw, ((400, 0, 0), GREEN, 'PREVIEW'), 'PREVIEW', 'POST_PIXEL')
_handle_1 = bpy.types.SpaceView3D.draw_handler_add(draw, (position_1, RED, 'WINDOW'), 'WINDOW', 'POST_VIEW')

But I‘m still confused about the draw_handler_add funciton. I've read the api documentation for this, but is shows "Undocumented".
Anyone can help me, or explain it for me?


Game properties break when pre-positioning pieces

You have accidentally hit this button:

Which has disabled the manipulator. Not sure if that is the problem you are describing? Note that even with it disabled you can use the shortcut keys 'G' 'R' 'S' for grab, rotate and scale.

I have never heard of moving a piece removing it's game properties though.


Attempting to move Vertices in 2.80 creates new ones instead

Had a sudden flash of inspiration... there were multiple vertices on the same spot!

After selecting them all and doing S, Z, 0 I then selected what looked to be the old unmoved ones as well, and did S, Z, 0 again. And then added the 'unmoved' ones to the selection again and did S, Z, 0 yet again.

At that point, it became clear that that was the issue.

A couple more rounds, and the 'bump' is finally gone!

Wish I'd thought of that before bothering you all, but hopefully this'll help someone else in the same boat!


View input vector values of Image Texture node?

To view the vector values, you can plug what goes to the texture node to Emission shader and render those vectors as colors.

You can check only values stored in input fields from python, the nodes are not processed when querying these values. Value outputs will just give 0.0. The shader node tree gets executed when rendering.


mark the start frame and the frame track end as is rendering in the Properties window


The warp modifier can also be used to wrap an object: the to object  controlles the direction to where the from object is wrapping the object (holding the modifier).


Alpha Over .png file pixelated after adding it to Video Sequence Editor

In the filter layout, try setting the "Convert to Float" value to True. Also try Enabling "Deinterlace". Put the Text image over your black color and make sure it's blend mode is set to "Alpha".

Your Example Blend files didn't have the text images in them, so I couldn't make sure my advice would help.

It could also be that your text image isn't high enough resolution.


Hex values are interpreted in the sRGB color space, while Blender uses a linear RGB color space internally.  The conversion functions can be found on the sRGB Wikipedia page.  The hex channel values themselves (0-255) should be divided by 255 before application of the formulas.  A pure Python implementation looks like this:

def srgb_to_linearrgb(c):
    if   c < 0:       return 0
    elif c < 0.04045: return c/12.92
    else:             return ((c+0.055)/1.055)**2.4

def hex_to_rgb(h,alpha=1):
    r = (h & 0xff0000) >> 16
    g = (h & 0x00ff00) >> 8
    b = (h & 0x0000ff)
    return tuple([srgb_to_linearrgb(c/0xff) for c in (r,g,b)] + [alpha])

and using it like so:

bpy.data.materials["Material"].node_tree.nodes["RGB"].outputs[0].default_value = \
    hex_to_rgb(0x123456)

seems to work correctly.


Why Does Quad Topology Not Always Result in Correct Shading?

The only thing comes to mind is the software tries to preserve data.
be it smoothing data. until you change it manually it tries to keep it that way.
So that's means more control to you and what you create.
Edit: here is an Image from https://github.com/fedackb/yavne

You could also say software does not know what you want and just does the default calculations.
depending on what you want I would say every artist would prefer one of them over the other.


Bezier curve not changing animation movement?

Suggestion.

Reduce the number of keyframes.  You have not shown your frames per second.

Consider having a IK target to have a [Follow Path Constraint].  Paths can be infinitely smooth ... only limited by your frames per second. Insert Keyframes beginning with 2 only. Search Follow Path Constraint here at BSE.

See the addon Simplify Curves.

Do one of 2 actions to archive your current keyframes.

Archive your file. Copy the file.
Create a scene which is a copy of the first scene.

Move your keyframes further down the timeline beginning at frame 50. You can also delete the current set of keyframes to live dangerously.

The result should be no keyframes between frame 1 and frame 40.

Next insert 2 keyframes only at frame 1 and frame 40 and judge whether or not it looks choppy.  Consider adding two more  keyframes and again judge whether it looks choppy.  Slowly increase your number of keyframes to see the tension between controlled movement and an excess of keyframes.  If you have both the new and improved keyframes and the old keyframes you can compare them in the playback.

Only you can judge whether or not something is smooth and fluid, at least with your Blender Animation.  We do not know whether the animation is intended to be karate or the Balshoi Ballet.

Know that IK Inverse Kinematics can sometimes produces a sudden rotation. Poles are meant to control this.


Sculpting effects not showing until I switch to edit mode?

I had this same issue and was caused by joining 2 objects together which had shape keys, after removing the shape keys sculpt mode returned to normal.


Manual Selection and Creation

Select mesh object, go into edit mode. Tab
Select vertex.
Snap cursor to vertex. Shift+S, Cursor to Selected
Go into object mode and select the armature object.
Go into edit mode and create a bone (at the cursor's position). Shift+A
Repeat for all vertices.

Use a python script
I created a script for you, which does what you intend.
import bpy
from mathutils import Vector

def AddBonesAtVertices(length, use_normals):
    objects = bpy.context.view_layer.objects
    obj = objects.active
    if not obj or obj.type != 'MESH':
        return

    points = []
    normals = []
    data = []
    for v in obj.data.vertices:
        p = obj.matrix_world @ v.co
        target = v.normal @ obj.matrix_world
        dir = target - p
        dir.normalize()
        dir = dir * length
        n = p + dir * (-1)
        points.append(p)
        if not use_normals:
            n = Vector((p[0], p[1], p[2] + length))
        normals.append(n)
        data.append([p, n])

    amt = bpy.data.armatures.new(obj.name + "_vBones")
    rig = bpy.data.objects.new(obj.name + '_vRig', amt)

    bpy.context.collection.objects.link(rig)
    objects.active = rig

    bpy.ops.object.editmode_toggle()
    for i, l in enumerate(zip(points, normals)):
        bone = amt.edit_bones.new(str(i))
        bone.head = l[0]
        bone.tail = l[1]
    bpy.ops.object.editmode_toggle()

bpy.ops.object.mode_set(mode='OBJECT')
AddBonesAtVertices(0.5, False)

Paste the script into the text editor, selected the mesh object and run the script.


What does this error mean and is it a Blender bug?

Not all Python operations are supported when running Blender in the background. The reasons for this is that operations are actions from user interface perspective. And some operations uses Graphical stuff like Window, Area or Region classes that do not exist when not having an UI.

The tag_redraw points me into that direction. You might try to fix the operation to make the wm.py not updating the UI at that point, but it not a bug.


Material Icon tab missing from the properties window?

This happens because you are in Pose Mode, you need to be in Object Mode as shown below:


After selecting a face , the bevel modifier works automatically , and can not quit it

Is there a possibility you might have changed a hotkey?

To be sure you have the factory settings, you can reset to factory preferences, to reset go to edit-> preferences-> click the 3 rows in the bottom left corner -> load factory preferences.


These are 2 different objects, you need first to join them (CtrlJ) otherwise you won't be able to bridge the 2 edge loops.


How to update root translation using python script in bge?

bpy is the Blender API. This means you change the object within the Blender scene not the running BGE scene. Do not use it!

The API for the BGE is bge. The armature gives you access to the (bge-) channels too.


How long should a 10mb .svg import file take to load in Blender?

It just finished after 90 min, it is a very complex file so I should have been more patient.

I also notice that although Blender will use most of my cores for other tasks, when doing this import it only used 1 core, any way to change this setting?


My Textured paint became plain color when I render in Cycles

the texture needs to be assigned to a material on this object to be visible on the render , and to start using the nodes editor :

select the object
in the material tab click New button to create new material
click use nodes

in the node editor press  Shift+A➝Texture➝Image texture
in the texture node select you image ( the one you painted )
connect the texture node to the shader node ( click and drag the dot to the other one )


Out of memory errors can always be traced to the same source:

  Your scene and render settings exceed the resources available in your computer.

You've set subdivision surface settings for Render to a high number, some have it set to 6!

Do you need that many polygons? There is a huge penalty for using such large values:

For every subdivision level the number of polygons increases exponentially.

At level six you are generating 4225 extra quads for every quad of the original object... Enough to choke most computers.

Use proper modeling and less subsurf to describe the shape of the objects. You should rarely need more than a subsurf level of 3. Straight shapes with flat faces might not need any subsurf at all.

Read: Blender render crash when using subsurf modifiers..

Also keep in mind that denoising will use a lot of memory, as it has to keep information from all the surrounding tiles.

Read: Why does Denoising take up so much memory?

Try reducing the tile size as well.


Model the glass, it is important that it is solid and has a thickness.
Simulated or modelled, the fluid has to intersect the glass. However, even with not-intersecting glass, the arrow will refract correctly.
Apply a Refraction BSDF to both objects (the glass and the fluid) in Cycles Material Nodes.

As you can see in the image, the fluid object intersects the glass. The fluid mesh is partially in between the inner and outer wall of the glass.


How do I select a bone in a downloaded Blender skeleton and edit it?

Right click on the armature to select it, and go into edit mode. Right click on the bone you want to divide into smaller bones and press W and choose subdivide. On the left panel (press T to show it if it's hidden) change the number of cuts from 1 to 6.


Currently in Blender 2.79 the only way to manage windows through Python API is by bpy.ops.screen.area_dupli() and bpy.ops.wm.window_duplicate() operators.

But they add new screens to bpy.data.screens, which are not easy to remove.

And there is no way to resize created windows.

UPDATE 1:

In my particular case I can use window created by userpref_show operator, it's size is very close to what I need and it creates 'temp' screen which is deleted after window is closed, so I do not need to cleanup bpy.data.screens afterwards:

import bpy

# Call user prefs window
bpy.ops.screen.userpref_show("INVOKE_DEFAULT")

# Change area type
area = bpy.context.window_manager.windows[-1].screen.areas[0]
area.type = "TEXT_EDITOR"

UPDATE 2:

With render.view_show operator it is possible to set the exact size of created window by modifying scene settings:

import bpy

# Modify scene settings
render = bpy.context.scene.render
render.resolution_x = 640
render.resolution_y = 480
render.resolution_percentage = 100
render.display_mode = "WINDOW"

# Call image editor window
bpy.ops.render.view_show("INVOKE_DEFAULT")

# Change area type
area = bpy.context.window_manager.windows[-1].screen.areas[0]
area.type = "TEXT_EDITOR"

# Restore scene settings
# render.resolution_x = original_value
# etc.


How to filter multiple file-extensions to limit which files display in an operator's file-selector?

In the operator's filter_glob property, (which you've already defined), you can define multiple extensions using the ; separator, eg:

filter_glob = StringProperty(
        default="*.png;*.jpg;*.jpeg;*.bmp;*.exr",
        options={'HIDDEN'},
        )

If you want to make a list of all extensions Blender supports you can use. bpy.path.extensions_image eg:

"*" + ";*".join(bpy.path.extensions_image)


Why a mesh is begin squishes connected on a path with the curve modifier?

As always with the curve modifier there is a lot that can go wrong lol, but I'd say you haven't applied the scale of your curve.


Proxy/Link –> Problem seeing colored Proxy rig over black Linked rig

I think I have the answer (sorry for English, it's not my main language). All you have to do is disable the rig in the viewport (hide too). Save the file. Then follow the steps you did before (link colecction and make proxy) and you are done.


Subdivision modifier renders with Viewport Subdivisions in Edit Mode

I am also new to Blender and noticed this recently. I believe it's due to the fact that you cannot apply modifiers (e.g. Subdivision Surface) while in Edit Mode. When you render, it still takes into account whether you're in Object or Edit Mode. So yes I believe you must be in Object mode for the modifier to be applied during the render.


How to append cycles render settings to another file

As far as I know there isn't a way to specifically save or append render settings. You can however append a scene from another file, that scene will bring in with it all render settings saved in it.

So you could create a file with an empty scene with all your sampling, bounce, performance settings etc. saved in it and append that scene to new files and use that scene directly.

With the appended scene as current you can also press the + button to add a new scene to your file and choose the option Copy settings, that should also create a new scene with exactly your current custom render settings copied over.

If you already have a scene setup and populated with your objects and want to apply those settings to it, your best bet is probably to create a new empty scene  from a template having your desired settings using the techniques above in the same file, then link all your objects to the new scene with the Ctrl + L Link > Objects to Scene.


Video on "Empty Image" doesnt show in Render?

No, empties as images will not render, just like images as background. They are used on the viewport as reference only.

To have renderable objects use images as planes instead.


Blender on remote Linux machine via X server

After quite a bit of trial and error, the latest version of Blender that can run through blender-softwaregl in the above mentioned configuration is 2.79.

There is nothing in the changelog of 2.79 or 2.80 to indicate any sort of reason for this.

Update:

The short answer seems to be that it is impossible to run Blender 2.80 over XDMCP in the described setup.

The longer answer is that Blender makes use of an X11 extension that is only effective when both the "client" and the "server" are running on the same machine.

In the client-server architecture, a process connects to another process and asks it to carry out tasks for it. This communication is governed by a strict "language" (the protocol). Usually, you don't think twice about who is the "client" and who is the "server". For example, internet browsers are clients to web servers and they exchange information over HTTP.

In the X Window System, the machine that should be considered as "the server", is the machine that shares its resources. As there can be only one mouse, keyboard, actual video output and so on, the server is the one process that "talks to them" and manages access of other processes.

This is where it might get a bit confusing. The typical way by which access is gained to a remote machine is through a Secure Shell connection.

This implies that the machine we are trying to connect to is running a Secure Shell Server and the connection is initiated by a Secure Shell client such as ssh in Linux or putty in Windows and others.

After authentication, we might try to start an application with a Graphical User Interface.

To do this, in this setup, the computer that executes the SSH client, needs to also be running an X11 server (the machine that provides the actual resources is not the one that is running the SSH server / Blender).

So, the complete round trip starts with the SSH Client (e.g. putty), connecting to the SSH Server, the user starts a piece of software (e.g. Blender) that uses the X Window Manager, it, in turn attempts to connect to a "display" server and initiates a connection back to the X Server that runs on the same machine that initiated the SSH connection (e.g. to something like XMing).

The end result of this is that the client process (Blender) does not run in the same memory space as the server process.

The MIT-SHM extension is an interprocess communication mechanism for the two communicating processes to share large amounts of memory.

When the extension is supported, the client might reserve a memory space through a "special" set of calls which ensures that another process (the X Server) has access to it too. This is to make the main connection less data heavy (and therefore faster). Instead of sending a huge amount of data over the connection, the processes might simply exchange the "handle" of the memory space which is just a number.

This makes sense for a heavy application such as Blender.

The XMing server does not support the MIT-SHM extension. This is the reason behind this specific error.

Even if the XMing did support the MIT-SHM, the client and server processes would run in different memory spaces and therefore this "handle" from one machine would not make sense to a different machine. This is why it is impossible to run Blender 2.80 under this setup.

Any attempt to force that feature off or circuimvent it would imply getting data from one machine to the other via the network (in one or another form), at which point, it would probably be equivalent to running Blender via VNC (if you can) where everything runs on the remote machine and the output is streamed back to the local machine.

Hope this helps.

Notes:

An X Server and an X Client are communicating via XDMCP
There are a few ways of trying to circumvent this MIT-SHM "limitation", but they basically imply running an X Server at the remote machine at which point, that remote machine would have to handle software rendering for Blender and streaming of the output. This is outside my use case and have not looked into it further but you are probably better trying to do this via a VNC type solution (if you can) rather than trying to "re-wire" X.

I don't know if there are ways to solve this via Distributed Shared Memory in Linux, but again even if it was possible (without starting a local X Server), the data that are supposed to be travelling between the two processes via the MIT-SHM would now have to travel over the network which, in the case of remote machines, is not going to happen faster than a VNC type connection.


Why my text extrude borders but not front?

Your Fill mode is set to "none". Setting it to "both" should fix your problem.


Since each of the small planes are the faces of the mesh, iterating through the polygons on the object mesh data provides access to the coordinates of the center of the face. Then using two consecutive coordinates, the distance between the centers can be calculated. This approach assumes the previous face is adjacent to the current face. Additionally, because accessing mesh data uses bpy, any changes will not occur while the game engine is running.

import bpy, mathutils

plane = bpy.data.objects["Plane"]

previous = None

for poly in plane.data.polygons:
    center = mathutils.Vector(poly.center)

    if previous:
        previous -= center
        #print length and center
        print(previous.length, center)

    previous = center


Problems with compositing and Shading settings

I fixed it by adjusting the settings of the screen and invert nodes.


Problem with particles, converted into mesh objects

In Object Mode select all your objects. Press U and unlink the object and the data to make single user objects.


How can I change the default render directory to a relative directory?

Starting with a new file, set the render output to //rendered_video/ and then select File->Save Startup File

For version 2.8

Blender will now use that output location every time you create a new blend.

You may also want to set Render Output in the File Preferences this setting will set the default render output path used when you create a new scene.


You can do this somewhat easily by using a logic setup similar to this.

It basically works by having your button that triggers the weapon change (in this case we are using X) assign a Boolean property Playing Animation?  to be true.
When this property is true, it adds to the frame property. This plays the animation. once this is working, it is fairly easy to make it so that it will Not fire when the animation is playing. To do this simply have a property sensor detect when the Boolean Playing Animation? is false. When it is false, you can press Spacebar (or any other key) and it will shoot your projectile.

This can be seen here. When the animation is playing it will not shoot the plasma blasts.
(it is a jump animation here, but it could be anything, that includes a weapon reloading)

If we shorten the delay between pulses for the keyboard sensor, the plasma coil will fire faster.


Solved.

A couple of the node settings were set way too high and applying the effect over too great an area making it appear as though there was a white material over the whole thing.

Thanks for the help.


Transformations of instances of collection - problem with "origin"

I don't think your coordinate space is at fault per se, I think you need to mess with your operating sets.  By description alone it sounds like you have your active Transform Pivot to be "Individual Origins", "Median Point" sounds like what you want.

You can mess with your working translation space by clicking the "global" directly to the left and choosing something else.

Something else you might want to do is parent all your pieces of your object to something, either the root mesh, an armature, or an Empty.  This will allow you to conveniently move and animate the whole set by moving the parent.

Lastly: if you mirror by duplicating and scaling by -1, you will also need to flip the normals depending on usage.  It is oftentimes better to use the Mirror modifier instead, it is more convenient and stable.


Ok, I believe I solved the issue. Although my material's diffuse reflection was set to [1, 1, 1], for physically correct rendering the actual diffuse reflection must be divided by $\pi$. In other words, an energy conserving diffuse BRDF is defined as $f(w_i, w_o) = \frac{k_d}{\pi}$, where $k_d$ is the diffuse reflectance (note that my specular reflectance was zero so we are not concerned about the specular part).

This means that if light fall off is disabled, the actual radiance that gets reflected off the face of the cube is $\frac{10}{4\pi^2}$ (with physically correct quadratic fall off this would be $\frac{10}{4\pi^2d^2}$ where $d$ is the distance).

So in my case, this value turns about to be $0.253$ and that is what I see as pixel value in the center of the cube's face if I save the rendered image in EXR format.

As for the PNG format, cycles appears to simply multiply this number with $255$, the maximum storable value in 8-bits. This corresponds to $64$. This happens because I had disabled gamma correction. Otherwise, cycles would have gamma corrected the value before multiplying it with $255$. This produces a value of $138$ and I confirmed that by experimentation.


3D Builder won't accept meshes made from Particle System in Cycles Render

Looking at the reference image I'd say it could be better to model that hair via simple mesh without any particle system. This way is often used for hair in some styles of 3d and 2d art, it allows to avoid possible slowdowns of particle system as well.

As to converted particles probably you used Path option as how particles are rendered in the Render layout of the particle system settings.

After applying Particle System modifier they become simple lines (edges with no thickness) which can't be printed because they are non-manifold geometry.

One way is to make that geometry manifold is to solidify it using Skin modifier on converted particles.

Select object with converted particles (note that you might want to leave particle system undeleted but hidden in case some changes are needed).
Add Skin modifier to it. By default modifier will solidify only one of converted particles because it marked a vertex as root for only one edge while it needs one root vertex for all the connected pieces of geometry. As per manual:

  Mark Root
      Marking a vertex as root causes that vertex to be used for calculating     rotations for connected limbs. [...]
      Each set of connected vertices should have one root node.

The easiest way to mark one vertex for multiple edges of the converted particles is to enter Edit mode, select all and press Mark Root button. It will find one vertex itself to mark so no need to deselect anything.
Once done all the particles will have thickness and become manifold, all-quads geometry. Make sure to apply modifier if exporting mesh.

Another simple and working a bit differently solution is to
set Object as how particles are rendered in Render rollout instead and give it some thin and long cube as object to be used as hair particle to make particles based on it. See underlined option on the 1-st screenshot, change it to Object and choose cube you created. No need to make follow it anything, it will be done automatically.

Make sure to rotate base mesh accordingly so it's oriented accordingly (e.g. outside of the mesh, typically you will need to rotate it along X axis).

This way is less flexible and gives slightly different result as it doesn't allow e.g. Brownian Motion setup to change particle orientation along its local X and Y axis, only along Z, and other options which allow to randomize  particles.


How to animate different parts of the same mesh object

Hee very nice idea!

There are a few options here.

First of all, you could rig the mesh with an armature. This might be a bit time consuming.

Also you could try and hook every eyelid with a hook modifier. But this will get messy very quickly. You'd have to parent all the hook empties back to a master that controls the rotation of the whole mesh.

Lastly, this is what I would do in your case. You say it's just a matter of scaling the eye lids, make shape keys for every seperate animation and build up a shape key library if you will. Every think you want to be able to control should be a unique shape key. The shape keys should 'add up' to each other.

Hope this is helpfull, if you have any questions you can contact me.

Ciao,

Mv.artz


Why does the light not illuminate inside the building?

For starters, the material on that structure is fairly rough, so indirect lighting will be scattered randomly.
Secondly, it doesn't seem like there's enough light coming in to create enough bounce lighting to fully illuminate the interior.

I would try making the mesh's material smoother, and maybe adding a spotlight or something to try and get more light coming inside.


How to make a light emitting material sensitive to external light

Using the light falling on the material is not something that is possible in cycles. It is, however, possible in blender internal.

The reason this is happening though is because normally in the real world when you turn the lights on, you are also reducing the exposure of the image, which causes the light emitted from the glowing material to be much dimmer. To replicate this effect in cycles you can increase the brightness of light significantly and then reduce the exposure from the colour management section of the scene tab.


Is there a way to get custom properties panel in a custom t panel?

Here is the answer from Custom properties on an action, any place for UI visibility?

Add a custom property panel to the Action Editor, much the same way as it is added to other parts of the UI.  Import the rna_prop_ui.PropertyPanel class and set the path from context to "object.animation_data.action" and the type to bpy.types.Action.

The default bl_label if not defined  is "Custom Properties".

import bpy

from bpy.types import Panel
from rna_prop_ui import PropertyPanel

class ACTION_PT_custom_props(PropertyPanel, Panel):
    bl_label = "Action Properties"
    bl_idname = "ACTION_PT_custom_props"
    bl_space_type = 'DOPESHEET_EDITOR'
    bl_region_type = 'UI'
    # required for PropertyPanel
    #COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_GAME'}
    _context_path = "object.animation_data.action"
    _property_type = bpy.types.Action

    @classmethod
    def poll(self, context):
        obj = getattr(context, "object", None)
        ad = getattr(obj, "animation_data", None)
        action = getattr(ad, "action", None)
        return action is not None

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

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

if __name__ == "__main__":  # only for live edit.
    register()

Note this example is for actions. For object

    _context_path = "object"
    _property_type = bpy.types.Object


How to get the filepath to an imported mesh?

I'm not an expert but the import addon gets the folder of the imported file (eg: "basedir = os.path.dirname(filepath)"), but its use is probably temporary to just read the file and other files (original textures?) in the same path, at import time. see 2.79's import_fbx.py "load" method, line 2273.

This original path, if I got it, could be saved in some imported object custom property, to allow later usage, like saving baked texture where the original file was when imported, but I guess it is not, now, so it is lost after the import operation.

So, unless you request (and get) this to be done by the importer maintainer, you could patch it yourself to read that path and save it into a custom property (unfortunately I can't help you with this, I'm not into this).

Another way could be to write a (custom) import log to a text file (maybe even inside blender text datablocks) so that you can later access it to know where/what you got when you imported the file...

Although, the original folder could (easily) not be "there" anymore, removed or renamed, or it could be readonly... so you can't take it for granted to be able to write there, unless you are following a well defined after-import workflow...

for sure you'll have to check if that (still) exist, is writable, and decide what to do if either things are false.


Where are the Blender program files in Ubuntu 14.04?

By default: see the doc about directory layout

# LOCAL
./2.74/

# USER
$HOME/.config/blender/2.74/

# SYSTEM
/usr/share/blender/2.74/


Trying to install Animation Nodes - How to make Blender forget?

Click the disclosure triangle for the addon, you can find the path to the addon file in the info there.


The Get Spline Samples node was replaced by the Evaluate Range option in the Evaluate Spline. This option can be enabled by pressing the button next to the parameter type menu.


Need some good organic modeling/topology tutorials for character creation

I would recommend using the add-on retopoflow. You can get the plugin as well as the tutorial on how to use it here.
                                                       Download  add-on:https://github.com/CGCookie/retopoflow

Tutorial: https://cgcookie.com/course/introduction-to-retopoflow/


Turn the action editor window into "dopesheet" and you will see all your animations.
Every object has his own action, 5 objects animation will consist of 5 actions, editable together through the dopesheet.


You have all the parts of your robot set as Static, thus your Dynamic rig is colliding with the parts of the robot, which does not work.
To fix that just set every part of your robot, except for the rig to be No collision.

A easy way to do it is to, is set one piece as No collision. Then select all of your robot (I used Border select B in wireframe mode so I would not miss any pices); make sure that piece you set to No collision is the active selection, meaning it is lighter orange (selected last) and press space and search for Copy Game Physics Properties to Selected.

Animation showing setting all pieces as no collision


In the 3d view, Texture Paint is not going to allow you to switch from screen space to relative space like you can in sculpt mode yet - but the work around is to use an Image Editor to paint in along side your 3d view so that you can use the consistent pixel size there.


Invoking the bpy.ops.mesh.dupli_extrude_cursor(rotate_source=True)
 operator leads to this error message in the console window:

wm_operator_invoke: invalid operator call 'MESH_OT_dupli_extrude_cursor'

Although is is exactly what is printed in info header when manually extruding a vertex.

I can't tell why this doesn't work but try this:

import bpy
import random

#generate random number
def RN():
    return int(random.random()*400)/20

verts = []
edges = []
faces = []
for i in range(1,100):
#set 3d cursor to random location
    verts.append(( RN(),RN(),RN()))
    edges.append((i-1,i))
edges.pop() # remove last edge
print( verts )
print ( edges )
mesh = bpy.data.meshes.new("rand_mesh")
mesh.from_pydata(verts, edges, faces)
rand_obj = bpy.data.objects.new("rand_object", mesh)
scene = bpy.context.scene
scene.objects.link(rand_obj)

I really don't know for what something like this could be useful:

See also

http://wiki.blender.org/index.php/Doc:2.6/Manual/Extensions/Python/Geometry


Select the vertex you extruded, and bring out the Properties panel (hit N or click View -> Properties). Under Transform, make sure Local is set, then manually set the X and Y coordinates to 0, but leave the Z coordinate as is. This will adjust the vertex's position to right above the object's origin, without moving it up or down.

Strictly speaking, the hole is still there after this, but it has a size of 0, but it may become visible again after subdividing, as this may also move some vertices. To remove it altogether, you need to click Apply in the screw modifier, then go into edit mode and remove double vertices. To do this, select everything by hitting A as many times as needed, then hit CtrlV followed by D or click Mesh -> Vertices -> Remove Doubles.


Is there any way to run blender 2.80 add-ons on Blender 2.79

No there isn't. The Python API has changed between the two versions and therefore add-ons for Blender 2.79 won't run in Blender 2.80 and the other way around.

You would have to modify the code of the add-on to let it run in Blender 2.79.


ok when there are parts of your mesh with more depth of detail this bug happens, because the detail size that you are using its more bigger than the detail size that containts in that area or part of the mesh, so to fix it change the detail size to the proper size that was used in that area. nevertheless with this "bug" (its not a bug actually) you can easily optimize your mesh if it gets too over loaded of polygons for example. also if you dont see anything happen, just add some geometry with the sculpt draw brush and then use the scrape brush in that area again.


Blender 2.8 How do i make objects with Render View disabled to not be visible on Viewport / OpenGL Rendering?

The options are still there, they are just hidden in the filter dropdown:

Make sure all the buttons are selected. I think they did this to keep the UI cleaner, but I'd probably have left on at least render visibility option by default. Hey, it's still a Beta though, so maybe they will "fix" that. :)


How to load and assign an image to a specific image node in the compositor?

Load your image using the path, add or get the image node in the compositor, and then simply assign your image data in memory to the image input of the node.

import bpy
from pathlib import Path

img_path = r"C:\MyDirectory\MyPicture.png"
if Path(img_path).is_file():
    img = bpy.data.images.load(img_path, check_existing=True)  # Load the image in data

    node_tree = bpy.context.scene.node_tree  # Get the current scene's compositor node tree

    img_comp_node = node_tree.nodes.new(type='CompositorNodeImage') #  Create a new image node
    # img_comp_node = node_tree.nodes.get('MyImageNodeName')  # Use this if your node already exists
    if img_comp_node:
        img_comp_node.image = img
else:
    print(f"The file at {img_path} doesn't exist")

Read: Controling compositor by python


Problem with planes intersecting in veiwport

This looks like an "alpha clipping"  issue.

Your planes look like they have an image texture applied to them. If this is correct and the image has an alpha channel (for transparency) then try setting the Material Properties > Viewport Display > Blend mode to Opaque.

Example Plane textured with an Image with an Alpha channel:

Or even better Open the image in Gimp or Photoshop and remove the Alpha Channel ( Gimp : Layer > Transparency > Remove Alpha Channel

Edit to add a couple more screenshots after Hienronymous's comment.

The Show Backface option is not available when Blend Mode is set to Opaque but there when Blend Mode is set to the default Alpha Blend
Which (probably) makes sense since the two seem to preform similar functions.

The Blend Mode  Opaque "Renders surface without transparency" and with Show Backface deselected "avoids transparency sorting problems".


Maybe haven't applied any texture to your model... Purple skin usually mean no texture, so you can't paint over it... but you can apply material on it... and for that to show you will need to go to the Dev or Render tab


use node-generated grayscale image as texture for particles

AFAIK it's not possible in 2.8 and greater version. For 2.79 and less there was texture node editor which generates textures. These textures maybe - i'm not sure - used for particle system.


What you are referring to is called Photogrammetry, another option could be a 3D scanner

At this stage there aren't any options available in blender and I don't know of any addons. What is currently available is standalone software that creates a 3d model from an image. Some of the available options listed in the above link might be used to get a 3d model that you could then import into blender.

Normally blender users use images as a reference when modeling or sculpting within blender. An image can be shown in the 3DView as a background image or attached to an empty.


python code for existing node chain blender

I have written a tool for that, but it has only features I needed for my nodetrees. The code is ugly, but might give some pointers for you in case you'd want to write something like that yourself. Maybe there are other - more complete - tools like that I'm not aware of.


Convert .3ds to .fbx without losing scale

Blender 3ds importer is weak or format is dead.

Try native FBX Converter. It's free, can explore, view and convert in batch 3ds, dae, dxf, fbx (old version for example) and obj to fbx up to 2013.


sambler's reponse spured me on the mess around with things something, and i've managed to 'fake' the transparency I guess.

Firstly I changed the blend mode to Multiply with Show Backface ticked.

With this though, the artwork shown on the backside of the cup was at max brightness (for lack of better words) which isn't what I want, nor realistic.

So I duplicated my material, and applied to the back half of the back, and shoved a colorramp node inbetween the image texture and diffuse node with a mid-ish grey which muted the colour to be how it would look on a final product.

Here is my complete node setup in the hopes it helps anyone, it's a bit fiddly but it's doing the job.


is there an easier way of doing corners like this?

Here's a pretty solid workflow if you don't desire to use multiple objects in the creation.

I'm posting the image sequence for now, so I don't mess that part up, then coming back to give the commentary per image.

Shift+A >> Mesh >> Plane.

Tab to enter edit mode.

I to inset the active face the desired amount.

Delete >> Only Faces.

Result of Deleting the face (giving you the major frame profile).

A to select all faces.

E to extrude the desired overall frame thickness.

Ctrl+R >> 2 >> LeftMouseButton >> RightMouseButton

Click on the Face Mode icon/button.

Z >> Select the inner ring of faces (as shown).

With your cursor just outside the outer edge of the frame E >> S >> Move your mouse toward the center of the frame the desired amount >> LeftMouseButton

Click on the Edge Mode icon/button.

Select the Edge Loops at both the Inner Top & Inner Bottom of the frame.

Ctrl+B >> Move your mouse outward the desired amount >> Either type the number of segments & hit Enter OR scroll up on the scroll wheel of your mouse the desired amount & LeftMouseButton.

Hit Tab & you are complete if you desire a 4-Sided frame.

If your desire is to have a 3-Sided frame >> Tab to enter edit mode. >> C >> Select the bottom most horizontal edges of the frame.

Delete >> Only Edges & Faces.

The result is two empty holes that we must repair/fill.

Loop Select the left most hole. >> F to fill.

Loop Select the right most hole. >> F to fill.

Select both Edge Loops again.

S >> Y >> Numpad 0.


With the curve selected, under the Curve tab of the properties area, activate Follow.

Go into Edit Mode and change the curve's Tilt so that the curve's arrows are perpendicular to the shoe geometry. With a control point selected use Curve > Control Points > Tilt or Ctrl+T to do that. I suggest enabling Proportional Editing to achieve a smooth transition. (The tilt can also be changed after the diamonds are aligned, which probably will make errors more obvious.)

Change the diamonds' Rotation so that the diamonds are aligned with the surface.
XYZ angles of 0°, -15° and -90° seem to work fine.

To make sure that the curve is running at the surface of the shoe, add a Shrinkwrap Modifier with the shoe as target, mode being Nearest Surface Point and enable Apply on Spline.

You might have to move some of the curve's control points outwards so that the shrinkwrap modifier doesn't snap the diamonds to the inside of the shoe.

Final blend file:


Why are the UV coordinates from dupli parent returning black?

Because you are duplicating from verts.

Seems that Blender currently (2.75a) can't inherit coordinates of duplicated objects from the parent only if they are not duplicated from faces.

It would not be tehorically impossible to obtain the behavoiour you need as object mapping should not be strictly related to the way is generated, but for the moment it is.

The same issue is present with particles:

Note: is not clear why it doesnt work with with grid option enabled...


How well does Blender handle multiple instalations side by side?

multiple blender versions on one system should be fine.
Personally, I don't update Blender builds more than 2 times a week, often less. Of course if some needed feature is broken and has been fixed in a recent build then i'll update asap. There's no right or wrong way here, it's more about how much effort you want to stick into being on the cutting edge.
Let's assume you are downloading from Builder bot
The simplest way to do avoid potential collisions is to take control of where your new blender files go. This means not using the installers, but instead unpacking the builds manually and putting them in separate folders.
You can make short-cuts to different Blenders and put them on your desktop, that way loading different instances of blender is easy. Remove the short-cuts of the Blender versions that you don't think you'll need for a while. Use unique icons to quickly identify the Blender (maybe using 3d glasses for the icon in the viewport branch)
Add-ons
Add-ons are an easy issue to get wrong, both locating them and installing.  But it doesn't have to be hard. Each version of Blender will look in several locations for /scripts/addon.
If you have a core of preferred addons, the way to only worry about those once is to make a custom add-ons folder, and tell Blender to also look there for addons. In:

User Preferences > File > Scripts

In this example I have a folder on that path called scripts, inside scripts i have:
scripts/addons
scripts/addons_contrib

This is where I stick the addons (manually) that I always want to have. And this manually setting of the scripts folder is one reason I don't update every day. It could be scripted of course.. :)


How can i activate the alpha on Blender Render?

You need to enable it in the Material settings:

Tick the Transparency checkbox and set the Alpha value to 0.

Also be sure to make that the texture Influence affects the Alpha value: