How do i preserve transparency in .fbx file?

What are you trying to do with the fbx export? You will need an alpha map texture to tell whatever is reading this what the alpha is. Chances are its going to just be a grayscale image at .3 , you could make an alpha map and then modify once its in the 3d package/ blender. https://en.wikipedia.org/wiki/Alpha_mapping


Tab key sometimes switches between Object/Edit mode, but sometimes between Weight Paint/Edit

That's how it works. If you go into a paint mode via a mouse click and then hit tab it will switch between edit and paint mode. Now if you go and click on the object mode and then hit tab it will switch between object and edit mode.

That is to say the last mode you select via a mouse click becomes the sticky mode that the "tab" key will switch to.

The beauty of this is so that when you need to do different sets of operations you could.

Vertex paint > edit
Object mode > edit
Sculpt mode > edit
etc ... you get the point I hope.


A little late, but maybe you need to highlight the FBX in Unity and change the rig to Generic or Humanoid. It might have exported from Blender as "None".


Ok, silly me somehow toggled "delay refresh", i didn't know about that feature it until Demon's Fate pointed it out.


Blender Add-on: Import-Export Three.JS doesn't activate

The warning on the UI

is only telling you this is an Exporter add-on only. "Importer not included". Everyone using that version of the add-on will see that warning. It's not an error, if you look at the files in the three.js  repository (blender/addons/io_three)  you'll see that there's only an Exporter.

As for the report in the Warning panel, that's different.


Never mind, just had to flip the normal's on some faces selectively


Josefin Sans Font not working and glitching in Blender 3D even 2.9

TTF fonts are a bit buggy in Blender. You have two options.

Use another font. OTF fonts work better in Blender. This is a good option if you have a lot of text
Or convert the text to mesh and merge misplaced vertices manually. This is good if you have only a little bit text. You can convert text to mesh in Object Mode from Object menu under Convert To and by selecting Mesh from Curve/Meta/Surf/Text.

You can merge vertices in Edit Mode by selecting the vertices you wish to merge and by pressing m. This will give you options of how you want to merge them. In this case Merge At Center seems like a good option.

After this you can select vertices and press f key to fill missing faces. 4 vertices at once should be fine.


How to make particles appear where I draw weight using dynamic paint?

There is an interesting workaround, found by Blenderartists member suboptimal - http://blenderartists.org/forum/show...inally-working

First you need to uv unwrap your Canvas and add two dynamic paint
canvassesses (Whats the plural?)
The first one is gonna generate the Time Map, the other one the
Density Map. Make sure you turn of dry and slow because otherwise the
particles later will behave a bit weird.
The dissolve time for the Time map canvas must be as long as the
particles are going to be emitted.

Then setup your brush with a white color. You have to use Mesh Volume
or Particle system with 0 smooth raduis as the paint source (nothing
with a blurred edge)

Then bake your dyn paint image sequences, the frame range must be the
same as your particle emission frame range.
Take the last frame of each one of your sequences and fill its
transparent background with black.
Add a particle system, it should have a pretty big amount of
particles. Next step is using them as particle textures, go to the
texture tab select particle textures ( I think they aren't in cycles
yet, only in BI). Load the Time Map, mapping to uv etc. and check
Time in the influence tab.
Repeat it for the density Map but use Density influence this time.


Add a transparent image on top of a material

Don't think in terms of transparency but in terms of masks

Most of the confusion comes from the idea that, if there is "transparency" in the image, there has to be a node for transparency involved, and somehow the alpha information has to be connected to it.

Please read further.

The basic workflow:

1. Determine what part of the object will use the texture.

In Edit Mode select the faces where you want the image to be mapped.

UV coordinates are used to map the image texture precisely on the object.

Press U to Unwrap them (depending on the shape you might need different a projection, in this example I used "sphere projection" but for your mesh it might be different, this is not a post on UV mapping).

2. Create the material(s) and use the image to control the mix of different parameters.

Create a new material and assign it to your object.

To edit the material, open the Node Editor window in shader and object mode.

For blender 2.8 use the shader editor.

Before you do anything else: let's go back the key concept:
There is nothing "transparent" in an image.

An image with an alpha channel, is composed of two different elements. The RGB (Red, Green and Blue channels, or color information), and a black and white channel called "Alpha" channel. White parts determine what is opaque, and black areas what most people call "transparent".

All of this is easier to understand if you don't think at all in terms of transparency and think in terms of Masks, and use those masks to control how elements mix.

The alpha channel of a given image can be used as a Mask, to control the mix of color or the mix of shaders

White areas will be one element of the mix, Black areas will be the other, and any shade of gray will be a partial mix.

1: To control the color of a shader.

If you want to use the color information of the image over the color of a given shader, in a way that all other properties of the shader are homogeneous, then use a color mix node, and have the mask be the factor for the color of the shader. Plug Alpha to the Fac of the mixRGB and the resulting mix to the shader's color input.

Pay special attention to the order in which the sockets are connected.

The black areas of the mask(or "alpha" channel) will use the color set in the RGB mix node, and the white parts will use the color of the image used as texture.

If you are using more than one texture, then use both inputs of the color mix node to mix the textures.

2: To control the the mix of different shaders.

Use this setup if you want to use the mask to control the mix between two different shaders. Note that doing this will make the masked areas have different characteristics.

The mask (alpha) on the image will to control how a shader that uses the colors of your image texture combines with another shader.

Let's see how to deal with transparency then.

Adding an image on a glass object

Glass is not different than any other shader.

If the color image is intended to be part of the glass shader, then use a mix color node. The image's color will be part of the shader's color only in the areas determined by the image mask.

If the image is supposed to be opaque, or  be a completely different material, then the alpha mask should control the mix of two different shaders.

And now for

Real transparency:

If the image's mask is used to combine a transparent shader with any other shader, then you can see right through the mesh.

Or the transparency can take the color of the image:

What about the Principled BSDF shader?

It is the same as any other shader. Use the mask to combine colors, shaders or any of the other qualities.

In newer versions of blender the Principled shader has an input for Alpha. If you plug in the alpha channel of the image directly to the alpha input of the shader, you will get a fully transparent object, except in the areas controlled by the alpha channel. In this case you don't need an additional transparent shader.

And, just for fun, you can use the alpha mask in as many combinations as you can think of.

For multiple images with alpha channel overlaid on top of each other:

When working with shaders remember that, RGB information and Masks(based on alpha channels) follow separate paths.

So let's break this in two parts.
RGB

First Combine the RGB information using the alpha channel of the image being overlaid as a mask (fac) to control mix over the background image.

Alpha

Then you can use the sum of all of the alpha channels as a mask to control the mix of color or shaders. You can use a Convert>Math node and set it to add mode.

To mix the colors for a shader color:

For a mix with other shaders:


How to set the Origin to the center of an Array?

I have an intuition that this MIGHT work, so try this. Hover your mouse(pointer) over where you want the origin to be(here:the centre of the array) and then hold down shift and right click .
This actually places the cursor(the small round thingy in the viewport) there. Now right-click the mesh and set origin to 3D cursor(there's an option for that under set origin).This places the origin where the 3D cursor is and voila! The origin is set to the centre of the mesh.
P.S. I'm a beginner in blender, like, an absolute noob. Please don't kill me if this doesn't work.


In your file the armature is child of the mesh, while it should be the opposite: select the armature and press Alt P (clear parent).
Then select the mesh FIRST, shift select the armature (mesh has to be highlighted orangy, armature yellow), then press Ctrl P with automatic weights.
In this way, in pose mode the bones will control the mesh.


How can I use physics connect functions in Blender 2.8?

you need to create an empty and go to physic tab and add constraint ! the empty is the link between 2 rigid body object :)


How to make a mesh follow certain rules?

After the help of @amonroejj i found the solution. To achive this kind of scenario we have to set up FK and IK while connecting bones. And I was not aware that connecting two bones allows mesh not to deform and strech...


Where is the "default color" of a face, when a texture is applied?

Viewport display (for solid mode) and the material itself are controlled by two different settings
Take a look in MaterialProperties>ViewportDisplay on the object, it could have been mixed up

By the way, if on MaterialProperties>Surface the "Use Nodes" button is off, it will use Viewport Display by default


Render 100k objects each with independent color and scale through time

The most fundamental issue with your node tree is the fact that you included the file parsing node tree inside the loop. So for n number of iterations, you are slowing your node tree by n number of times, in this case 500x ! Furthermore, you need to take advantage of Animation Nodes's victorization abilities, that is, some nodes can process a set of data by default, without the need to use loops. And finally, as you suggested, the data can be cached, and caching is something we can do in Animation Nodes.

While CSV can be used, you data set seems to be very big and so it is recommended that your file is in a binary format which you can parse using python and pass the data to Animation Nodes using a script node, alternatively, you can use something like json or yaml.

Parsing

Lets say your CSV file is as follows:

1,1,0,1,8,1,5,7,3,0
6,1,4,1,3,9,6,6,0,7
0,7,8,6,1,2,7,9,5,6
8,4,8,2,0,7,2,4,6,1
4,7,4,6,6,1,0,9,0,3
0,3,8,4,8,3,4,5,0,1
9,2,3,0,8,1,5,2,7,5
2,4,9,5,7,3,4,4,6,0
4,3,1,2,0,6,4,7,6,4
5,9,8,1,6,1,1,8,8,5

Where the first three characters are the x,y,z locations and the rest of the line is the scales at frame 0,1,2, .... This sample file can be parsed as following:

The output Locations vector list is of the same length as the number of objects, where each vector represents the location of one of the objects. However, the Scales vector list is different, it is structured such that the first n number of vectors are the scales of the first object at the frames 0,1,2, ..., the second n number of vectors are the scales of the first object at the frames 0,1,2, ..., and so on. Notice that n is equal to the number of frames there is.

The parsed data is constant, so we can safely cached it. Caching can be enabled through the advanced node settings of the loop:

Instanced Object Transforms

There are multiple ways to generate and position the objects, each have its own limitations, the first of which is by using the Instance Object Node which you used in your node tree:

Using the parsed scale data is not as straight forward as the location data. Notice that the scale of the first object at frame zero is at the index 0, the scale of the second object at frame zero is at the index 0+p where p is the number of frames, the scale of the third object at frame zero is at the index 0+2p and so on. So in general, to get the scales at the frame f of the nth object, we use the general formula f+np. Also, notice that the number of frames is equal to the length of the scales list divided by the number of objects. By using all of previously mentioned facts, we can get the list of scales at some frame using the Slice List Node using the step size as the number of frames:

Notice that we disabled End in the slice node to instruct the node to take steps till the list end. And by animating the scene, we see that it does work as expected:

The problem with this implementation is that it will be relatively slow at higher number of objects, in the next section, I will introduce you to another method to instance tens of thousands of objects with no problem.

DupliFaces

Blender has this feature called DupliFaces, it allows us to instance objects along polygons where the scale of the objects is the area of the polygon and their locations is the centers of the polygons. In Animation Nodes, we can create a mesh composed of triangles such that their areas equals to the scale of the objects and their centers to the locations of the objects, and by using this mesh as a base for dupliFaces and by using a sphere as the parent object, we get exactly what we want:

The Unity Triangle Node is only available in version 2.1, so if you don't have it, just create a mesh with vertices locations equal to:

$$
\begin{bmatrix}
-3^{-\frac{1}{4}} \\ -3^{-\frac{3}{4}} \\ 0
\end{bmatrix}
\begin{bmatrix}
3^{-\frac{1}{4}} \\ -3^{-\frac{3}{4}} \\ 0
\end{bmatrix}
\begin{bmatrix}
0 \\ \left(\frac{2}{3}\right)^{\frac{3}{4}} \\ 0
\end{bmatrix}
$$

Notice that to activate duplication, you have to change dupli_type to be FACES, parent of the sphere to be the mesh we created and use_dupli_faces_scale to be True. And that's what we did using the attribute nodes.

A blend file that implements simple Duplicate Groups in AN:

Conclusion

Don't use loops unless necessary.
Put anything outside of loops if you can.
Cache subprogrames if needed.
Use Duplicate Groups whenever you can.

Coloring Objects

I researched coloring the Duplifaces instances and found that there is no way to color them individually, that is, unless we can decode the random output of the Object Info Node and extract the object index out of it or generate a 3D color map and evaluate the instances locations at it, which is also very hard to do in cycles. We really need a better render engine, a render engine we deserve !

So our options are limited when it comes to coloring:

Use a material for each object. Disadvantages: 100k material in a single scene ... I will reject this method.
Another method would be to use a single material and vertex colors. Disadvantages: Objects have to be Deep Copies, that is, meshes have to be copied as well !
Set object index for each object and use the Object Index Output from the Object Info Node as texture coordinates for a Nx1 image where N is the number of objects, this texture stores the color of each object in a pixel.

Vertex Colors

This method being simple, it gets slow rapidly, it is 80x slower than our original implementation. Notice that Deep Copy has to be enabled.

Object Index

This method is also simple, but much faster, much lighter and much much more memory efficient. This is due to the fact that we don't Deep Copy the objects and we set only a single integer instead of a full vertex color map.

First step is to set the Pass Index of each object to be 0, 1, 2, 3, ... which represents the index of each object, then we create an image with dimensions Nx1 where N is the number of objects. The first pixel is the color of the first object, the second is the color of the second object and so on. To create this image we use the script:

if imageName in bpy.data.images:
    image = bpy.data.images[imageName]
    image.generated_width = width
    image.generated_height = 1
else:
    image = bpy.data.images.new(imageName, width, 1)

image.pixels = [c for color in colors for c in color]

In the material side, we normalize the indices to represents texture coordinates for an image by dividing by the number of objects. The implementation is as simple as:

Notice that if the number of objects is constant, you may removed the Object Attribute Output node because the objects already have their indices set, this will reduce the execution by almost half! Also, note that we can automatically set the value of the divide node through animation nodes using the Cycles Material Output Node:

I think it is obvious which method you should be using.


What helped me most times is increasing the size of the light source. At default, e.g. point lamps have a size of 0.1 units, so when calculating caustics blender just has rounding errors, I guess.

Of course, raising the size of your light source higher and higher will produce softer and softer shadows, so you have to play with the values.

Another guess: Don't lighten your scene with objects with emission materials alone – they will not produce enough light. Add standard point or area lights where necessary.


Perspective, while it is the way we see things in the real world, is an illusion.

These train tracks look like they are converging, but obviously they can't be.

.

Orthographic projection is a way of seeing 3D shapes in 2D at their actual sizes, without perspective distortion.

Here is a comparison of orthographic versus perspective, with the same camera angle.

The orthographic version doesn't look "right", but the tracks appear parallel, which is how they actually are.

By moving the camera backwards and increasing the focal length, you can kind of get an ortho-like look.

Assuming you are modeling from an orthographic or nearly orthographic reference image (obviously it is impossible to get a true orthographic projection from a camera, but photographs can be "close enough" if taken with a long focal length), modeling in ortho is the best way to go. It does take a little getting used to though..


From your supplemental comment, you seem to be creating game content for the Unity game engine, which will limit the set of possible answers, but the answer will still depend upon what kind of content you are making. Inorganic content--vehicles, metal objects, and painted surfaces, may be better colored by defining the color properties of the material. Organic content--living things (even imaginary ones)--and complex items like highly detailed structures may be best done with an image texture mapped to the surface of the model using UV unwrapping.

If you've got some modeling experience, I'd suggest Ben Simonds' book, Blender Master Class, where he discusses a wide range of coloring techniques for various kinds of elements, organic, and inorganic.

ns


How to rename different UV maps in blender 2.74

You can now Double-Click (or Ctrl+Left-Click) on the name of items in 'UI Lists' and they will change into an editable text field. Press Enter to confirm the new name once typed.


Objects pass through their moving container's walls during rigid body physics

You're going to have to increase the Steps per second a bit more. The motion of the box is too fast, and the spheres may find themselves suddenly "out" of the box (or inside the wall!) in the next solver's step, when in the previous they were inside.
The solution is to have another step in-between so that the collision is not inadvertently skipped, and in this intermediate solver's step the sphere is just next to the boundary, and it feels the collision force kicking it back in. This is what "Steps per second" does.
Increasing the solver iterations further can also help.


As far as I see, if normal is positive light colours bump outwards and dark inwards, if negative - the other way round.

The rest doesn't seem easy, but here are some links. I think "Method" is mostly about quality:
http://kishalmi.servus.at/3D/bumpcode/

"Space" should tell in which space the normal vector will be stored. But the results look strange.

Anyway - why not use cycles?


On reading the linked “about logo” page I’d say ‘no’. Mostly due to the paragraph :

  You will visualize and promote your own branding more prominent than
  you use the Blender logo. The Blender logo only can be used as a
  secondary brand, which means it has to be clear for an average viewer
  that this is not an official Blender or Blender Foundation website,
  publication or product.

IMO, by making the Blender logo part of your logo (the eye) there is no separation between your logo and the Blender logo so it isn’t clear as a “secondary brand”, making it appear to be endorsed or affiliated with Blender.


Render Layers are not visible in compositing when I close and open the program

No, blender does not save the rendered layers as part of the project.

You need to render them again, or you can save them as an image first and import them back into blender for compositing.

To keep the best quality use a "output file node" and save as EXR multilayer. Read: Save all render passes to a single EXR image and Different render per layers? and How can I render all render passes to files in Cycles?


Automatically picking high-poly / low-poly model based on distance to camera?

The Level Of Detail  settings in Blender 2.7 will be only available in the game engine.

Someone else had an approach to control the subdivisions of a multires modifier using a driver and use the distance from cam to an object.

See this Blog post detailed information and demo file.

It does not support switching different meshes only subdivision nor LoD for different textures.

My approach would be to have different Objects / Meshes parented and calculate the distance from camera to each object. For a quick test I parented a lores version to a higher mesh version of a model.

Like so:

Depending on a distance threshold the visibility of the lores or the hires parent is easily controlled by a script:

import bpy

threshold = 9

scene = bpy.context.scene
camera = scene.objects["Camera"]
cam_pos = camera.location
print(cam_pos)
for ob in scene.objects:
    print( ob.name )
    if ob.name.startswith("Cube.LowRes"):
        d = cam_pos - ob.parent.location
        dist = d.length

        if dist > threshold:
            ob.hide = False
            ob.parent.hide = True
            ob.hide_render = False
            ob.parent.hide_render = True

        else:
            ob.hide = True
            ob.parent.hide = False
            ob.hide_render = True
            ob.parent.hide_render = False
        print( ob.location )
        print( dist )

If you plan to use this with for an animated camera you could consider adding a bpy.app.handlers.frame_change_pre and call the script before each frame.

Demo file here


Difference Materials Link vs Copy Material to selected

They behave differently if the Active object has less Material slots than the Selected object:

Copy deletes all slots and add those existing in of the active object
Link replace only the first slots, and keep the extra slots unchanged.


Test code that equates the angle between the two bones.  It doesn't take into account bone roll.

import bpy
from math import degrees

from bpy import context
arm = context.object

pb1 = arm.pose.bones.get("Bone")
pb2 = arm.pose.bones.get("Bone.001")

v1 = pb1.head - pb1.tail
v2 = pb2.head - pb2.tail

if pb1 and pb2:
    print(degrees(v1.angle(v2)))
else:
    print("Invalid bone name(s)")


I would use the bevel modifier, and not apply it, that way it remains editable, and suppressible.

Also You can Limit by Vertex Groups.

Everything you want all in one Modifier.


Why does blender render a single image instead of the whole video?

Here are a few things to check:

The animation button in the render panel (or CtrlF12) is used for animation. The render button on the left (with a camera icon) will only render one frame.
Frame step. The default value is 1, meaning that it will render all of the frames in the specified range. Higher values will make the render/playbak skip frames. In any case it shouldn't be too high (it's too high in this screenshot, for example)
The Start and End frame determine the range of frames to be animated/rendered.

By the looks of your comments, these probably aren't your issue. However we might as well have them in an answer, since they're things that in general affect your symptoms.


The most likely problems are either due to flipped normals, fast moving soft body (moving so fast as to jump through the plane before collision can be detected), or inappropriate Collision settings.

The first thing to point out is that the collision is an approximation. The soft body solver steps the soft body vertices through a 'step' and compares the positions to any collision surfaces. If the new vertex position is within one of the collision 'zones' (ie, the 'Outer' and 'Inner' settings on the Collision panel) then it will be repelled by the surface on the next 'step'. If the step size is too large for a fast moving vertex to be detected then it can pass straight through a surface unnoticed. To resolve this issue you can tweak the Soft Body Solver settings - drastically increase the Min Step setting and the steps will be considerably shorter, resulting in the fast moving vertices being more frequently sampled and, hopefully, hitting the collision zones.

The next problem is with flipped normals. If a vertex approaches the opposite side of a surface then instead of hitting the surface it will be drawn through the surface to the other side. The normals should (almost) always point to the "outside" of the object so as to repel collisions to the exterior.

The final problem is setting the Internal collision bounds larger than the depth of the object. The collision settings are in scene units (so, by default, Blender Units). The default 'Inner' collision settings of 0.2 are only appropriate for objects that are more than 0.4 units in depth. For example, a cube with 0.4 units per side. This would mean that down to 0.2 units below the surface would be considered for repulsion from that closest surface but anything below that would be repelled out of the other side. If you set collision 'Inner' greater than half the depth of the surface then you start to get strange results where the top surface collision zone interferes with the opposite surface collision zone. IF the Inner is set to more that the total thickness of the object then you can end up with a situation where vertices close to the surface are drawn through the surface as they are within the collision zone of the far side of the object!

So, follow the following rules :

Keep Normals pointing 'out' of the object
Set Min Step high enough to ensure any vertex motion is not too great per step - faster objects require more steps but more steps take longer to calculate
Carefully select collision depths to avoid overlapping zones - avoid Inner being more than half the minimum thickness of the mesh.


First, some statistics:
Your file is 255MB big, the scene has ~780k vertices, the shaders take several minutes to compile, and it used 2GB memory.
In the first step, I would reduce the number of vertices. You have a car driving on a long road and the camera is chasing it, looking at the tires... a great animation. So the car and tires are in the focus. But you don't need tires that have a total of 500k(!) vertices. Remove the Subdivision Surface modifiers. The wheels are spinning when the car drives and you can't see the tire tread at speed anyway.
The same applies to the interior of the car. The car has black opaque windows. You can't see the interior. Why is there a Subdivision Surface modifier with 2 levels?
The car can have a level 1 Subdivision Surface and you won't see a difference.
If you do this the scene has only ~240k vertices. Half of it has the car, the other half is used for the environment.
(Side note: The car looks a bit too small or the house too big)


Rendered textures, spots instead of smooth

Read this

What you have here is denoising artefacts from the blender denoiser. The solution to them is increasing your render samples or not using the denoiser at all.


missing files blender 2.82 Missing UVs, Textures, detected!

I had this problem too. In mode select Single Image instead of Material and you'll see an Add UV button. Just add that and you should be able to paint on the object. If not I'm not sure what else to do. It worked for me. Hope this helped!


Add a glow to a boolean modifier boundary

More than one way.

Use a vertex weight proximity modifier after the boolean to assign vertices to a "glow" group, then use a UV warp modifier to translate this glow group into add UV that you can read in your shader.

Our boolean will create new vertices, and vertex weight proximity only affects vertices already assigned to the group, so we'll first need to use a vertex weight edit modifier, immediately following the boolean, to assign all verts to our glow group.

Then our vertex weight proximity modifier overrides that, assigning only vertices that are close to the cylinder (from 0 to 0.13 distance in this case.)  We use that vertex group to warp a UV map where all verts have been mapped to 0,0 in order to convert weights to something readable by our nodes.  The empties off to the side just establish a 1 unit X difference for the UV warp mod.  See Weight paint in cycles nodes?.

I'm not sure how the boolean modifier generates UV coords.  I believe it interpolates them from existing coords.  Here, any verts created by the boolean are being written properly to our glow map at 0,0.

In our material, we're simply using our UV output from our glow map-- which, remember, represents the proximity of any face of the cylinder-- as strength.  I'm doing a little math just to make it look better.


Best way to model the top of a rook piece?

You never want triangles on a mesh you are going to subdivide as they will result in pinching.

The images above seem to have some, introduced by the bevel tool probably.

Using a pair of edge loops to sharpen the rings, and then a pair of edge loops top and bottom per crenelation you can get close to the shape you want. But there is some blockiness when you look down from top view.

If you want a smoother circumference, you can

-select the face loop you have inset near the top and hide them. (Hiding faces will prevent edge loops from continuing past them when added.)

-Add some additional "spoke" edge loops as shown. As there is one ring hidden, the loops won't cross the entire object, creating some ngons in the inset area.

-Scale the new short edge loops up just slightly on the not z. scale the entire section above the hidden faces down about half that much to split the difference

I know, I just said don't use triangles and then here I go introducing poles in to your mesh, but they are nicely tucked away, it works and it's easy :P

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

Source: I just finished watching 4 hours worth of topology videos by Jonathan Williamson, the cg cookie guy.


The calculation of transparent shadows is a little bit slow, so the casting of transparent shadows (behind your glass) is deactivated in the default settings. To get the shadows or better the light you have to activate Receive Transparent in the Shadow-Settings in the material tab for each Material, wich receive light through an object.

< activate Receive Transparent

see Shadows in the Blender Manual


One mesh in blender can have multiple materials, so you can join your input meshes into one for blender. Simply assign a separate material for each input mesh.


Imported OBJ doesn't seem to render correct in object mode

It seems to me that it is like a clipping issue here:

Where can the viewport clipping parameters be changed?

But, for me it's more about scale. Normaly, objects fits in default clipping settings, but your is so huge! So I suggest you this:

Select all the staff, (it's looks like it is already selected) when press S,0,.,0,0,1,Enterto make it 100 times smaller (or even more if you want).
When apply scale by pressing Ctrl+A -> Scale

Unfortunately import OBJ does not have scale option


How can I make a node setup, where only round emitter glows outside the image?

You could enable an emission pass in the render layers tab:

Then blur and overlay the Emit pass:


How Do I stop the Red and Green Cylinder from moving

Tell me if that simple solution could answer:

Create one unique armature from bottom to top with bones following your object shape.
Put your armature in Pose mode. Select an arm, then select its bone, and ctrl P > Bone to parent the arm to its bone. For the vertical arms, select the bone it is supposed to be part of and same thing, parent them.
Move your bones, the arms should follow in the right way.


As you have learned, ngons do not subdivide or deform well, and that is the very reason they should be avoided...

Also, the quality of the deformation is directly related to the amount of subdivisions of your mesh so you need a lot more vertices and faces.

A possible solution is to create a surface made out of quads.

Delete all the faces and subdivide (W) that long edge on the left side:

Make sure that you end up with an even number of vertices for the whole object

Select all of the vertices ( A)

Press the space bar and type Grid fill (note that if you have an odd number of vertices the grid fill operation will fail)

Then play with the values for Span

to get a nice distribution for the newly created quad faces.

The mesh will deform much better now.


The Subdivide operator can be found:

In the Context menu aka Specials menu (RMBor W in case of using 2.7 keymap)

As part of the Edge menu in Edit Mode

Or via Spacebar by searching for Subdivide


How do you apply a texture to select faces of a mesh

The simplest way if the texture isn't UV-mapped, is to assign each face to separate materials in Edit mode:

then assign appropriate texture to each material, as needed. Otherwise if the texture uses UV map, just separate the UV maps for both sections of the object:

then paint each sections with the appropriate color (the roof is the top section, in this picture).


VSE - A strip with a PNG/transp won't show as long as there's another one above it

You want to select both strips and add a alpha over effect strip.


μm is Micrometre, one thousandth of a millimetre (0.001 mm or about 0.000039 inch).
If you try to calculate the volume of 81.38x23.00x59.80 um it will be around 0,0001mm3 or 0,0000001cm3 that is to small and rounded.

If you want to measure object in imperial units you need to go to scene tab and select this unit system from presets:


Blender doesn't follow the coordination of objects. What am I missing?

As @DuarteFarrajotaRamos mentioned in the comments, those values are delta values for translating object. You can access the co-ordinates of the object by selecting the object, pressing the N key and under transform tab, you could see the co-ordinates of your object. You can change them as per your need.


How does the cycles render-passes (for example: diffuse) works out when using colored light source?

Direct and indirect passes are lighting passes. You literally add them to add light to your pixels. That light can be either white or colored light and it may hold intensity values well above 1, as they are scene values.

These passes contain the information of light coming from the light sources of your scene and interacting with surfaces (glossy, diffuse, etc.) both directly and indirectly (via bounces).

In real life, the colour of materials is actually a factor of absorption of wavelenghts, creating the ilusion of colour when those materials interact with light.
In a CG scene, when you light a red surface, it absorbs blue and green components (a part of the spectrum) from your light source and bounce back red.

This absorption can be expressed mathematically with a multiplication, hence why you multiply the lighting passes by the shader base colour to retrieve the appearance of the lit surface.

The multiplication of an RGB image by colour sort of mimics the behavior of a colored glass: It lets a part of the spectrum pass (the colour of the glass) and blocks the other parts.

As Carlo mentioned, producing your own test scene will clear up your doubts. Go try yourself and inspect the passes with a viewer node, it will show what information each pass has and it will make sense.


As @Mr Zak suggests in the comments, the Cycles Settings panel does not show in the object properties menu if the active object is a Camera, Empty Object, Lattice or Forcefield; regardless of how many objects you have selected.

Although it is not 100% clear from your screenshot which object is the active object, it appears that you have several Empty's in your scene which may be the culprit, if not the camera.


Ronin,

I've taken a look at the model, you have a simple vertice problem which is solved like this:

Select vertice 1 and then select vertice 2

Hit Alt + M and select "At Last" to merge at the second vertice

Do this for both of these, and your problem should be solved

I would also recommend deleting these faces as they are only taking up vertice count and can potentially mess up the model.

Before

After


Is there a way to subdivide a cube while a shape of a sphere is maintained?

You can do this non destructively by adding a subdivision surface modifier set to simple, and a cast modifier with the Cast type set the sphere and the factor set to 1.

Another method is W>Subdivide smooth will come close to achieving the effect you want, as far as I know, it doesn't divide correctly, and will create a mesh that isn't quite spherical.

Screen shot of modifier settings:


Why is my texture not showing up in 3D view?

To enable textures in object mode (can skip if you're working in Eevvee Rendered mode or LookDev) :

To enable the texture to appear, click use nodes, then click on the little circle next to the color to select your open image:

Hope that helps.


Cycles Random material with alpha texture

For random colors just plug the Object Info node's random output to a Color Ramp with the desired random colors as shown bellow:

Use a constant color ramp if you want only solid colors, or any interpolated version if you want a range of variations.

For random alpha textures inside a particle system it is probably easier to just create five separate objects (they can share mesh objectdata) with five different materials applied "By object" with your different alpha maps.
Group these objects into a single group with Ctrl+G and the use that group as dupli in the particle system.

Turn on the "Pick Random" option and the particle system will take care of choosing each object arbitrarily.


How to duplicate insets/extrusions on objects

In the case you discuss, I'd duplicate the window, plus the surrounding four vertices, that is, the ones you used the inset tool to create the window from, so that you're copying 5 plane surfaces, instead of one. Then, delete the edge (and only the edge) behind the new location of the window—that is, the edge in the green box,

which will have the result of deleting the two faces of which it is a defining component as well. If your copy of the window includes the four faces around the original window itself, then the fact that the illustration contains merely a rectangular outline of the new window suggests that after you made your new copy of the window by duplicating the desired vertices, edges or faces, you separated the duplicated elements into a new object by pressing the P key, and choosing "by selection". Otherwise, even in solid shading, you'd see all five faces in the new object, just as you do in the original window.. If this is the case, you need to select the new window and the old side you duplicated it from in object mode, and join them into the same object by pressing CTRL-J. Then create new faces around the new window as needed.

This technique might result in some awkward geometry right around the new window, as shown,

complicating UV mapping, shading, and other bits, but if these become a major concern, they can be dealt with later, by deleting a larger part of your mesh, and redoing the geometry.


Export constraints and inverse kinematics

FBX or collada can bake effects of the constraints while exporting animations, that’s all. There is no way to export constraint/IK systems themselves, afaik.

Further more, I’m not sure that would make sense at all, seeing how hard it is already to support basics of exchange between applications that all have different ways of handling common topics (referring to animation and armatures e.g.), I would suspect things rather complex and advanced like constraints to be a plain nightmare.


Why is the wood grain texture I applied to my model not showing?

To get your procedural texture to show up in the material, go into the textures context tab, and in the mapping panel, change "co-ordinates" to generated, then, in the influence panel, under "diffuse", put a check beside color. Areas to be changed in orange boxes shown:

.


Objects not showing up when in render view. Only the background shows up

Seems that your objects have cycle shader and so if you activate Cycle Render as your renderer, it is just fine...


How to create a lattice and link all objects to it procedurally?

The proper way is to not use operators:
import bpy

scene = bpy.context.scene

lattice = bpy.data.lattices.new("Lattice")
lattice_ob = bpy.data.objects.new("Lattice", lattice)
lattice_ob.scale = (5, 5, 5)

for ob in scene.objects:
    if ob.type == 'MESH':
        mod = ob.modifiers.new("Lattice", 'LATTICE')
        mod.object = lattice_ob

scene.objects.link(lattice_ob)
scene.update()

The .new() methods return object references to be used for subsequent method calls and property assignments in contrast to operators, which run isolated and only return a status (e.g. {'FINISHED'}). Some methods also take objects (the second parameter of objects.new()), whereas operators don't support objects/pointers, but only references by name (StringProperty).
//update: For Blender 2.8 and above, I believe you would do it like this:
import bpy

collection = bpy.context.collection

lattice = bpy.data.lattices.new("Lattice")
lattice_ob = bpy.data.objects.new("Lattice", lattice)
lattice_ob.scale = (5, 5, 5)

for ob in collection.objects:
    if ob.type == 'MESH':
        mod = ob.modifiers.new("Lattice", 'LATTICE')
        mod.object = lattice_ob

collection.objects.link(lattice_ob)


How to change material's color in blender game engine?

First you have to enable Object Color, that is found in the Properties window, Material tab, then under the Options region Object Color.
One quirk I found, be sure that the diffuse color of the material is pure white [1, 1, 1]. If it is not you will only be able to control the color up to that level. Example: say the material's color is red [1, 0, 0], now because the green and blue channels are 0 you will never be able to get any value in those channels.
Now the material will use the object's color, that color is found  under Properties > Object > Display > Object Color*.
To change the object color while the game is running use this bit of python.
cont = bge.logic.getCurrentController()
obj = cont.owner
# set the game object's color
obj.color = [ 0.0, 0.0, 0.0, 1.0]

The color method is looking for a vector in the form of [Red, Green, Blue, Alpha], (You can just leave the alpha set to 1, I have yet to find a place where it is used.)
The game UI for changing the color
Creating the interface is the most complicated part.
Here is a working  demo file with three sliders, one each for red green and blue.
The three sliders all have a game property one for each color channel. They also have these logic bricks. The only difference among the three is the property name.

This script is what takes the input from the logic bricks above, and changes the three values.
scene = bge.logic.getCurrentScene()
cont = bge.logic.getCurrentController()
own = cont.owner

if cont.sensors['Mouse'].getButtonStatus(bge.events.LEFTMOUSE) == bge.logic.KX_INPUT_ACTIVE:
    posZ = cont.sensors['Mouse1'].hitPosition[2]
    if posZ > 1.0:
        posZ = 1
    elif posZ < 0:
        posZ = 0
    own.worldPosition.z = posZ

prop = cont.actuators["prop"]
prop.value = str(own.worldPosition.z)
cont.activate(prop)

Then another script on the object you want to change the color is this script. A always sensor set to True pulse mode makes the script run constantly.
scene = bge.logic.getCurrentScene()
cont = bge.logic.getCurrentController()
own = cont.owner

r = scene.objects['handle']['r']
g = scene.objects['handle.g']['g']
b = scene.objects['handle.b']['b']

own.color = [ r, g, b, 1.0]


Material Instances Using Same Node Set Up

It's true that making duplicate material, the new material is a new entity. But what you may miss is since you have multiple materials in an object, the object may still use the same material as the sphere. Try this:

Select the object with multiple materials.
Enter edit mode, select faces that you want (or I assume you want to select everything)
The materials section now will have Assign, Select, and Deselect.
While the faces are selected, select the material you want from the materials list, then press Assign button.

  I click on the Icon NEW MATERIAL (indicated in Teal colour), so I can
  duplicate the existing material Node set up and assign it on another
  object(s).

You don't have to do this to be able to assign it for another object. You can just select other object, then click the material icon next to the name field, then choose the previous material with the node set up.
Note that Blender doesn't save unused material (indicated by 0 in front of the material name when you click materials list), means the next time you open the file, they won't be there, so instead you can just make sure the material is used by an object to not disappear later when you open your file.
OR you can also preserve unused material by clicking the shield icon (fake user button) next to the duplicate button, so it is saved even though no object is actually using it.


Letters not hit by light or causing shadows?

Your letters are parallel to the light rays and therefore not lighted. Rotate the light or letters so that the the letters' surface is hit by light.


Blender 2.81's render device set to GPU doesn't show the viewpport render

Ok so it seems that restarting Blender resolves the problem.
However I know that this solution does not explain the cause, so if someone knows what it is or how to resolve it, go ahead


Change the origins of the flower center and petals and stem by using

[origin to geometry]

as depicted in the image above.

The

flower center
flowers petals
stem

should be quickly changed to have their origin modified as above or with the mesh itself or perimeter.  I see your petals have the correct parent of the flower center. Suggestion. Names of objects can be quickly improved The visual stem mesh should have a name like [stem]. The flower center should/could have the [stem] as parent, depending on animation complexity.

Above image shows more correct placement of origins.  Your can manually improve the flower petal origins if that suits your tastes.

Currently your origins are not in the correct place.


Reset blender environment on each script run

I fear that this can only give a partial answer.

I wrote an add-on (totally work in progress..but whatever) which gives the python console in Blender a second function. Hitting Enter, executes normal python stuff, but I can type commands and hit Cltr+Enter and the add-on will read the current line and parse it and react to it. One command I do tend to use a lot is wipe it removes all objects/meshes, the code for it is pretty much:

    elif m == 'wipe':
        remove_obj_and_mesh(context)
        add_scrollback('wiped objects and meshes', 'OUTPUT')
        # history_append(text=m, current_character=0, remove_duplicates=True)
        history_append(text=m, remove_duplicates=True)

This even prints the message 'wiped objects and meshes' in blue to the Python console

The code for remove_obj_and_mesh() is:

def remove_obj_and_mesh(context):
    scene = context.scene
    objs = bpy.data.objects
    meshes = bpy.data.meshes
    for obj in objs:
        if obj.type == 'MESH':
            scene.objects.unlink(obj)
            objs.remove(obj)
    for mesh in meshes:
        meshes.remove(mesh)

I've not tested that on hidden objects, but if you can link a representative file / blend state which you would like to wipe entirely or selectively, i recommend posting it and that will let us/me answer more concisely.

ps. blenderscripting.blogspot is my blog, i should probably change that code


Can I scale 1 image in animation to bigger and still maintain the visibility of the image in front of it?

So, basically: You can achieve the wanted effect on different ways. You could try it via changing location and so on, but the easiest way is: just scale the images and set key animations.

Go to the start frame, select the image of the e.g. earth. Press "S" and scale it to the wanted start size. Now press "I" and choose "Scaling" from the pop-out-menu. Now go to the next frame you want to define (for example the last one) and repeat the steps. Same you can do for the alien. Just make sure to have a small space between alien and earth for avoiding weird overlaps.

For more information about animating, google a bit ;)

I am not sure whether I understood your last question right (^^) but as scaling just affects the size and not position, overlapping another image by "overscaling" shouldn't happen. Provided there are really only images (that have no depth). Object can overlay each other if the depth becoms too big, logically.

Hope it helped :)
Greets, Jaspa


Is it possible to download the manual from the Wiki and integrate it into the help menu?

You cannot directly download the blender wiki… well not as normally as you are asking, there are ways (and even if you did get it, as far as implementing or getting its content into Blender, that's another story).

You can reach the manual from inside Blender however and some documentation functionality is already implemented somewhat..

Hover over a button and you should see a short description etc.. This can be useful for getting operator names.

For more information, right click on the component in Blender and you can choose to go to the Online Manual or the Online Python Reference

You can also just grab a zip of the python reference for offline viewing directly from the front page.


How should I create a realistic landscape based on a real place?

This is a quite long task to do.

First you'll also need some texturing for the ground.

Then you'll need to have the models of all the building, then texture every one of them. Then the same thing for the roads and so on...

Their is an addon call blenderGiS (https://github.com/domlysz/BlenderGIS) which can take care of importing google data, i.e. building (the one google knows the shape) and road (it import the road a curves i believe).

This solve partially the problem of how to get all the 3D model in blender. However, you'll have to do some modelling for the road or if you want very realistic building model since google has only the very low poly models of building.

Then you need to texture everything.... So good luck !


There are two problems that need to be solved:

The shortcut you're attempting to assign is already in use for the viewport navigation. You may want to change these so you're still able to use them with a different key binding.
The identifier for the operator is not correct, but creating a new shortcut isn't necessary since the mode selection already exists in the default keymap. You only need to adjust the key binding from the regular 1, 2 and 3 keys to the numpad ones.

In order to solve problem 1):

Open the keymap preferences
Switch the filter method to Key-Bindings.
Search for "Numpad"
Scroll down to find the 3D View section and adjust the shortcuts that use Ctrl + Numpad 1, Ctrl + Numpad 2, Ctrl +Numpad 3. (If on a Mac there will also be Cmd + Numpad 1, Cmd + Numpad 2, Cmd +Numpad 3, in which case either the Ctrl or Cmd set can be deactivated, freeing up some shortcuts.)

In order to solve problem 2):

Open the keymap preferences
Switch the filter method to Name
Search for "Select Mode", the identifier for the operator is mesh.select_mode.
Adjust the key binding to your liking.


Retopology: Are self intersecting edge loops legal

The answer was given by Leander in the comments section:

You cant use Self Intersecting loops, that's a novice mistake.
Instead use "Mask Topology".


Where can I get the first Blender 2.8 build?

the first build with EEVEE

is a rather arbitrary point in time, the blender 2.80 evee development started as a branch from the current development of blender, it was identical to the normal blender releases. There have been no tagged releases containing evee, the daily test builds have been the only available versions.

As blender is open source, you can build any variation of it that you want. The blender 2.80 development is being done in it's own branch so you just add git branch blender2.8 after you have a copy of the repo. You can list the history of the branch and checkout any commit from that list that you want and compile it as it was at that point in time.

So you can build any version that you want, but to get daily experimental pre-built binaries you have to get them the day they are available.


How to detect clicks on empty space via python?

It's actually really simple:

Go to User Preferences > Input and change the filter type from Name to Key-Binding
Search for action and find the 3D View category
Change view3d.cursor3d to object.select_all
Set Action to Deselect

Clear search filter
Expand 3D View > Mesh and Add New
Set it to mesh.select_all and Deselect
Bind it to Mouse, Action and Press


How to scale area light icon in viewport?

You can scale rectangle with S or when you bring cursor closer to rectangle, drag the corner handle.

But I would say you are asking how to change light Distance represented by a line. For that you would have to go to Light Properties > Custom Distance and change parametr (even when it is disabled it change the widget).
It is accessible only via Eevee. Seems like it would need a touch of GUI designer :)


Limiting precision level in Animation Nodes?

Non list types are represented using python objects, so you can't really change the precision.

Vectors types lists in Animation Nodes (i.e. Vector3DList, Vector2DList, EulerList,...) are composed of float typed numbers, which is the smallest possible type, so you can't have smaller precision than that.

A float list in Animation Nodes is actually composed of doubles, so you can reduce the precision by using a FloatList instead.

An integer type in Animation Nodes is a long, so you can reduce the precision by using a ShortList, a CharList, or an IntegerList. Though I believe two of them might have the same precision on some systems/compilers.

Finally, I think it is unlikely to get a performance boost out of this, at least in the context of AN. So I think you are better off optimizing your node tree somewhere else.


How do you create a Math Formula for a Model Object?

There's a Mesh Function add-on:

generates a UI for making parametric surfaces:

Blender 2.79-

Or use Sverchok's scripted node. This may be more complicated at first but allows a lot of customization.

import math
from math import pi as PI
from math import cos, sin

def sv_main(p1=0.3, p2=0.7, vdivs=20, points=200):
    verts_out = []

    in_sockets = [
        ['s', 'p1', p1],
        ['s', 'p2', p2],
        ['s', 'vdivs', vdivs],
        ['s', 'points', points]
    ]

    r2=20*p1
    r1=10*p2
    theta = 1/points
    vtheta = 1/vdivs

    for v in range(vdivs):
        v_points = []
        for i in range(points):
            t = 2 * PI * (theta * i)
            p = PI * ((vtheta*v) - 0.5)
            x = r1 * cos(t) * cos(p)
            y = r1 * sin(t) * cos(p)
            z = r1 * sin(p)
            x = x + r2 * cos(t)
            y = y + r2 * sin(t)
            v_points.append([x,y,z])

        verts_out.append(v_points)

    out_sockets = [
        ['v', 'verts', [verts_out]]
    ]

    return in_sockets, out_sockets

Because the script makes a nested list of each V ring of verts, the UV Connection node can make the appropriate "UV edge-surf".

For help with Sverchok in general see the documentation.
For help with Scripted Node specifically first have a look at the dedicated document about it

Blender 2.8+

for Blender 2.8 and Sverchok you will use ScriptedNode Lite, and it requires a small modification to the above script. I think you'll agree it's less verbose.

"""
in p1 s d=0.3 n=2
in p2 s d=0.7 n=2
in vdivs s d=20 n=2
in points s d=200 n=2
out verts_out v
"""

import math
from math import pi as PI
from math import cos, sin

r2 = 20 * p1
r1 = 10 * p2
theta = 1/points
vtheta = 1/vdivs

for v in range(vdivs):
    v_points = []
    for i in range(points):
        t = 2 * PI * (theta * i)
        p = PI * ((vtheta*v) - 0.5)
        x = r1 * cos(t) * cos(p)
        y = r1 * sin(t) * cos(p)
        z = r1 * sin(p)
        x = x + r2 * cos(t)
        y = y + r2 * sin(t)
        v_points.append([x,y,z])

    verts_out.append(v_points)


I guess what you need to do is pin your UV map:

Let say you've made your first unwrap with a seam. Select all in the UV Editor and press P in order to pin.

Create your second seam.

In the object, select the part you want to unwrap again, in the UV Editor remove the pin for this part with AltP.

Unwrap again. In the UV Editor, it won't affect the pinned vertices, it will only affect the non-pinned vertices.

Move and scale the new islands wherever you want in the UV Editor.


The yellow color sockets output three scalar values, one for each of the color channels Red, Green and Blue. The output information is in a linear scale.
(see: Cycles - (Shader) Nodes - inputs outputs - What are the exact data types? and What is the meaning of the color of the node sockets in the node editor?)
The Color Space on the image texture node  will determine how the color values are interpreted. Images in display referred formats (like png, jpg. tiff and most video formats) are presumed to be in sRGB color space. Such images are encoded using a transfer function (sometimes called "gamma curve") that has to be linearized to to work properly in blender. Blender color and light operation need to be done using a linear scale, so using sRGB as Color Space is the correct choice. The linearization works by applying an inverse sRGB color transform to counteract the baked in curves.

(source)
For images used as maps, such as bump maps or normal maps, that are presumed to use linear values, with no transfer function (or "gamma curve") baked in, the correct setting is Non Color Color Space. When using this setting there will be no color transform applied to those elements on the render path.


How can I make flaky edges for cinnamon stick?

I separated the Object Data so I could modify each model independently.

The model on the left has the Solidify Modifier Applied since it restricts Vertex Painting and UV Mapping, (I wanted to try a few things there.)

The model on the right is mostly the same as you made it.

I used Vertex Paint and a Particle System on both of them.

There is a Group of several jagged models on a hidden layer that are being used to simulate the flecks along the edges.

It's really now just a matter of cloning those pieces using the particle system and using weight painting to control the distribution on the cinnamon stick models.

To make a series of Objects connected using a Group, press g while in Object mode after you have selected all the Objects for the group.  They should now all be highlighted in green.  I find this works best when you have the Objects facing down the y-axis with the Origin at (0,0,0).  I also, prefer to rotate them in Edit mode to avoid having to apply the rotations.

In the Particle's Render tab, activate the Group option and Select the group.  It would be better to change the name 'group' to something more like 'flecks' since Blender also calls Vertex Groups 'group' and since Weight Painting adds a Vertex Group, this can be confusing.

Also, in the Particles tab, add 'Group' to the Vertex Group's Density
field.  Now any weight painting that you've done on the model should control where the flecks show up.  Adding the Vertex Group control to the Length helps here as well.

Here's the modified .blend file.


Here's a way to achieve this without the Try-Except block:

import bpy

for bone in bpy.context.selected_pose_bones:
    # Create a list of all the copy location constraints on this bone
    copyLocConstraints = [ c for c in bone.constraints if c.type == 'COPY_LOCATION' ]

    # Iterate over all the bone's copy location constraints and delete them all
    for c in copyLocConstraints:
        bone.constraints.remove( c ) # Remove constraint

On a more general note, the remove method is very common in blender collections, so when you try to delete a member of a collection always have a go at this in the console:

bpy.data.materials.remove( myMaterial )
bpy.context.object.modifiers.remove( someModifier )

Also note that this method usually takes the actual element reference (modifier object, constraint object, etc) as a parameter, not an index.


Smoothing out angular object in blender?

In the object mode select the object then there is option "subdivide surface" in the "Add Modifier", as shown in figure at right by red color point 1, after selecting it,
Click the view untill "view 2" as you can see I have View 1 in point 2 written in red color
At left you will see the smooth the press that smooth option


Label points in plane and get position after transformation

One thing you could try is creating separate vertex groups for each point you want to label and then using the following Python code in the script editor to get the positions for each vertex.  Let me know if it works (or if it doesn't).
import bpy
import bmesh

ObjectName = "Plane"
VertexGroups = ["VGroup 1", "VGroup 2", "VGroup 3"]

obj = bpy.data.objects[ObjectName]
vGroupIndex = 0

def select_obj(obj):
    obj.select_set(True)
    bpy.context.view_layer.objects.active = obj

def create_cube():
    bpyscene = bpy.context.scene
    mesh = bpy.data.meshes.new("Vertex")
    cube = bpy.data.objects.new("Vertex", mesh)
    bpyscene.collection.objects.link(cube)
    select_obj(cube)

    bm = bmesh.new()
    bmesh.ops.create_cube(bm, size=1.0)
    bm.to_mesh(mesh)
    bm.free()

    return cube

def get_vertices_in_group(a,index):
    vlist = []
    for v in a.data.vertices:
        for g in v.groups:
            if g.group == index:
                vlist.append(v.index)
    return vlist

def create_boxes():
    boxes = [];
    for vgi in VertexGroups:
        vg = obj.vertex_groups[vgi]
        box = create_cube()
        bpy.ops.object.constraint_add(type="COPY_LOCATION")
        box.constraints["Copy Location"].target = obj
        box.constraints["Copy Location"].subtarget = vg.name
        boxes.append(box);
    return boxes

def get_locations(boxes, should_delete):
    for box in boxes:
        print(" ")
        print(box.name)
        mat = box.matrix_local
        pos = (mat[0][3], mat[1][3], mat[2][3])
        print(pos)
        if should_delete:
            bpy.ops.object.select_all(action="DESELECT")
            select_obj(box)
            bpy.ops.object.delete(use_global=False)

boxes = create_boxes()
get_locations(boxes, True)

You can replace ObjectName with whatever your plane is called and VertexGroups with the list of the names of the vertex groups you end up using for each vertex.
The way it works is by creating a box for each vertex group named in the VertexGroup list, and then using the copy location constraint to move the box over to wherever the vertex is.  Then it uses the box's matrix_local to find it's actual position (just checking the box's location doesn't take constrains into account and thus just returns (0,0,0))
It doesn't work to just find the vertices in the vertex groups and spit out their positions (vertex.co) because that only gives the position of the vertex relative to the object's origin as it is in edit mode (i.e. it won't account for armature poses, constraints, or even moving the mesh in object mode)
I doubt this is the fastest or best way to do this, but hopefully it will work well enough.  Hope it helps, and let me know if it works (or if it doesn't)


If you read the python console start message you will notice that some modules and some variables are builtin or have been imported for our convenience. eg bpy and C = bpy.context.

PYTHON INTERACTIVE CONSOLE 3.7.3 (default, Apr  3 2019, 19:16:38)  [GCC 8.0.1 20180414 (experimental) [trunk revision 259383]]

Command History:     Up/Down Arrow
Cursor:              Left/Right Home/End
Remove:              Backspace/Delete
Execute:             Enter
Autocomplete:        Ctrl-Space
Zoom:                Ctrl +/-, Ctrl-Wheel
Builtin Modules:     bpy, bpy.data, bpy.ops, bpy.props, bpy.types, bpy.context, bpy.utils, bgl, blf, mathutils
Convenience Imports: from mathutils import *; from math import *
Convenience Variables: C = bpy.context, D = bpy.data

You need to include your imports in the text editor. To see errors Where does console output go

also consider using for j, name in enumerate(markerlist): to enumerate without using range and length methods. And using scene = bpy.context.scene will use the current (context) scene no matter its name.

import bpy # NEED THIS

scene = bpy.context.scene # < the context scene

markerLIST = ["foo", "bar"]

for j, name in enumerate(markerLIST):
    scene.timeline_markers.new(name, frame=j)

Consider giving the list both the name and frame

import bpy # NEED THIS

scene = bpy.context.scene # < the context scene

markerLIST = [(1, "foo"),
              (20, "bar"),
        ]

for j, name in markerLIST:
    scene.timeline_markers.new(name, frame=j)


You can change it in the user preferences in the left corner by clicking on File then User Preferences. From the window that opens choose the Input tab and then change the keyboard shortcut for the desired key. Then you are done.

You can get the pdf for keyboard shortcuts. It's a simple keyboard shortcut PDF and may help you in future.


The trick is to use some supporting geometry. Rather than extruding, add a face and use the knife tool to make an additional edge:

If you use 'c' with the knife tool you'll get a perpendicular edge.
Now loop slide your new edge with 'C':

If you don't want to add and then remove faces, you can select the two edges that are adjacent to the edge you want to extend and subdivide them:

then use 'f' to connect the two new vertices:

and do the loop slide:

Also, start the edge slide with 'gg' and then move the edge slightly before entering 'C' so that Blender knows which direction you want to extend in.


Appended group opening in original location

Not sure you'll need to muck around with the Graph Editor - Try this first...

Select the main armature or whatever it's parented to.

Press SH-S --> Cursor to selected.

SH-A  and add an Empty.  (It will appear at the the same origin/pivot point as the armature or parent)

Parent the armature (or parent) to the Empty, choose  "Object (keep transform)"

Drag the empty around and the model should follow it.  Place it somewhere.  Run the animation.

It should do it's thing but now from it's new location.


How to create a seamles UV map for an hexagonal grid texture?

I haven't played RL in a while, but are the ceilings the same beveled rectangle shape?

It looks like your images are being stretched as they get closer to the beveled edge.  It also looks like your screenshot isn't from Blender, so I don't know how to do it in whatever software that is, but if you're working in Blender I'd suggest going to UV mode and adjusting the vertices until it looks better.  Also, check your texture and see how the edges line up at the top/bottom and left/right.  It might take some photo editing and/or scaling to get it to work.

Good luck!


Material that only renders direct or bounce light?

You can do it in the compositor, assigning to your mesh an object index different than 0.


How to mix 2 textures using different UV maps on one object

I figured things out. I don't really understand why it works, but i was able to resolve my problem by inputting alpha of one of the textures into "Mix shader" factor.

This is a easy stuff, but i didn't expect it to work, because my UV sets are very different, and if merged together will interpenetrate each other and create a mess, so i didn't consider doing alpha of one of my textures as a mask.


Names of bones in Dope Sheet have very faint text color and yellow background color

I think you can find your culprit in here, in Blender Preferences -> Themes -> Dope Sheet.


By default, Blender does not add all the nodes necessary to create the "fire" aspect of the Smoke Sim to the Material Output.  Basically you need to edit the material of the flame in order to make it visible in Cycles.

1.) There is an Attribute Node that must be added with the name "flame".
2.) The Factor output goes into a Color Ramp Node that you will edit for the desired color.
3.) That Node's Color output will go into an Emission Node since fire "emits" light.
4.) You will then add that shader to the rest of the material shaders:

EDIT: I've included a .blend file below that has all the basic settings enabled and tweaked for creating a simple fire in Cycles:

FYI, here is a pretty good video tutorial for explaining the basic settings for fire in Cycles: https://youtu.be/u-zK7Bu8cAI


In the header of a 3D view, right-click on the View > Frame Selected menu item, and add it to your Quick Favorites and/or create a new keyboard shortcut for it.


BGE: Which script names produce a "module has no attribute" error?

wave is indeed a module from Python's standard library, as you can see in the link below. As it deals with heavy data processing (wave sound files manipulation), it is probably a compiled C extension, and you may find it as a .pyd file extension (which is equivalent to a Windows DLL). Refer to Python standard library to avoid using already taken module names and be a bit more specific about your own module names (like game_wave, and so on).

wave module on Python standard library documentation: https://docs.python.org/3/library/wave.html


You can key frame the actual color by just hitting "i" on the color box

Starts out blue - hit "i"

Move the timeline and box and change the color and hit "i" again.


How do I bake animation for exporting animation created by Wave modifier

You could try exporting alembic.. that would export the deforming geometry into an .abc file that can be ready by unity and other animation packages.


White colors in view port vs render output Eevee

To make emission lighting work properly in EEVEE, you need to use an Irradiance Volume (under "Light Probes" in add menu).

As you can see, without the volume, as soon as the emission object is out of camera view, the light from it disappears:

Scale the volume to encompass the area you want to boost the accuracy of the lighting (including emission values). You can adjust the detail from the properties panel.

Additionally, you need to bake the indirect lighting. Otherwise, although emission materials may glow (with bloom), they do not provide any lighting

Although I realize now I had some world lighting adding to the situation in the first image, you can still see that the lighting is more pronounced in this last photo. Also notice the lack of any light in my scene tree. All lighting is through emissions (except for a small amount of world lighting - that is a failure of my example, but does not change the effectiveness of the Irradiance Volume)

You can see the difference, as the room is now lit, even though the emission object is out of camera view:


Why is this anti-aliasing artefact happening?

Looks like you have transparency on the Island material, switching it off seems to do the trick,


Figured out the problem (in this case) occurred due to UV unwrapping and an image texture that wasn't single colour. The UV unwrap crossed over parts of the image that was empty and created the black lines in seemingly random places. New UV unwrap and new image texture solved the problem.


  This big lamp bone won't do much good there because it's root is in a place where the lamp doesn't have any joints.

  I would solve that with two Locked Track constraints. The first one is for looking up and down. Parented to that is the second bone with another Locked Track to handle looking from left to right. Both are tracking the same target.

Here's the setup from Haunt's trick bag:

Bone 1 is the boss. It has a Locked Track with Z locked and -x tracking bone 3. It can only move up and down. The blue joint is parented to that.
Bone 2 is parented to bone 1. It has a Locked Track with X locked and Y pointing to 3. It can only move left and right. The red part of the lamp is parented to that bone. It doesn't matter at all how high bone 2 sits as long as it sits on the axis of the neck. It only rotates around the neck axis anyway.
Bone 3 is the target. One and two point there.
Bone 4 is there for convenience purposes. The root of bone 1 can't be in the middle of the lamp's head (bone 2 could be, but who cares, you'll hide them anyway), so there's an offset. Bone 4 has a Copy Location Constraint to bone 3 and a Copy Rotation Constraint to bone 1, so the tip of bone 4 is where the lamp is looking. You can make bone 4 unselectable in the outliner. That way you can't miss the target bone.

  In the end, you'll only have two bones visible, possibly with customs shapes: bone 4, so you see the exact focus of your lamp and bone 3, so you can animate the head. Btw, Luxo's neck seems to be perpendicular to his head which makes things a little easier regarding his focus.


how are the math node operations in cycles calculated?

Here is a list of the mathematical equivalents of each operation.

Add: Out = Value1 + Value2.
Subtract: Out = Value1 - Value2.
Multiply: Out = Value1 * Value2.
Divide: Out = Value1 / Value2.
Sine: Out = Sin(Value1).†
Cosine: Out = Cos(Value1).†
Tangent: Out = Tan(Value1).†
Arcsin: Out = Sin⁻¹(Value1).†
Arccosine: Out = Cos⁻¹(Value1).†
Arctangent: Out = Tan⁻¹(Value1).†
Power: Out = Value1 ^ Value2.
Logarithm: Out = log(Value2, Value1).††
Minimum: Out = Smaller Value of (Value1, Value2).
Maximum: Out = larger value of (Value1, Value2).
Round: Out = Value1 rounded to nearest integer.
Less Than: Out = 1 if Value1 < Value2, else 0'
Greater Than: Out = 1 if Value1 > Value2, else 0'
Modulo: Out = Value1 (mod Value2).‡

Note that some operations use only the first input, in such cases the second input is ignored completely.

†. All trigonometric functions use radians.
††. log(x, y) = the logarithm of x to the base y.
‡. x mod y = the remainder when x is divided by y.


Why bendy bone segmenting does not work?

Your bones don't seem to be displayed as B bones but as sticks. You need to go in the Properties panel > Object Data > Viewport Display > Display As and choose B Bone.


How can I uniformly modify a pipe with coding?

It may be that you need nothing more than a proportional edit, set to 'Linear' profile, and in 'Connected' mode.

With Median Point as your pivot, select an edge loop at one end of your pipe. The extent of the scaling along normals (AltS) will depend not on the geometric distance from your selection, but on the topological distance (the total edge-length from your selection).. so it works round corners, linearly tapering as you go.

The circle in the 3D view may no longer be a visual indicator of extent - just keep growing it until you begin to see the influence at the other end of your pipe.


Render outputs includes the scene incorrectly or uses the wrong input

Since this was a very strange behaviour, I wanted to check the whole setup in the node editor.
I realised that it seems I was searching in the wrong part of the rendering pipeline. Somewhere I got the idea to look at the compositor window.

This is what I saw:

I have no idea how or why the setup was that way. It may was caused by the motion tracking workflow I did at the very start.

Since my only goal was to overlay the movie clip with the coloured objects, I deleted everything but the movie clip, the rendered scene and the alpha mixer (plus the two outputs of course).

With this configuration I got what I wanted and blender render did work as well for rendering.


I worked it out a quite some time ago, but maybe it will help someone else. I did bad UV mapping, begginer mistake.


You are plugging a texture node directly into the output node.
You must plug the texture node into a shader node such as a Principled BSDF first in order to get the color information from the image to the output correctly.
Below would be the correct setup:

See this question for more information on closures.
Side note, you also do not have a camera in the file you provided. Add one and you will be all set :)


How to render the movie texture in the Open GL viewport rendering?

Thanks to Jerryno's tips, I've found an answer how to do this finally in Cycles. I've discovered, that to make it work, Blender has to have the preview of the texture visible. So I've set up windows as below. In one window you have the viewport shading set to Material and in other one it is set to Rendered.

When you press play button all images refresh fine. After pressing the Open GL render active viewport button (or clicking Render--> Open GL Render Animation) you get the movie with an animated texture. Don't know why, but sometimes you'll have to press/click it few times until it works though.
...............................................................................................................................................

I tried to make it work in Blender Internal also. When you press play button images don't refresh, unless you do one tricky thing. You have to keep the Preview and Image panels of the Texture header expanded. Then you hover the cursor over Preview panel and press Alt+A. Now the images in the Texture viewport shading are refreshing well. Sadly they don't behave the same after pressing the Open GL render active viewport button. I guess making the Open GL animation render with a working video texture is impossible in BI.


Blender supports different render engines and these can have quite different options. In this case you seem to have selected Blender Internal renderer while you actually intend to use Cycles. Simply change the drop-down at the top of the window to Cycles.


How to make procedural Powder Coat material?

You could probably accomplish this pretty easily with a Noise Texture. I just scaled it to 60 and upped the detail and roughness a bit. I mixed it with white before running through a Bump Node to make the effect less jarring, and mixed the main color with an Ambient Occlusion Node to highlight the dimples. I also increased the metallic value to try and make it match the image you posted. Don't forget to enable Ambient Occlusion in the render properties panel:


The point is to imagine the several angles your mesh will have to be bent.

It can be composed of an initial shape and 3 modifiers : mirror, simple deform and subsurface.

Here, there is a final curve : the "U" general shape.

But before that the mesh can be flat. Here the mesh before using the two final modifier (simple deform and subsurface) :

The main point is to use quad everywhere so that :

Edges are in the good position to be bend to the "U"
Subsurface modifier works well

Notice the selected line on the screen capture : it is here to preserve the outer edge and avoid the subsurf to deform it too much.

As you want to print it, you may want a "lot" of subdivision.

Here is the modifiers stack :

Here is the blend file


Edge Crease

Use the subsurf, but insted of loop cuts, select the sharp edges, and press CTRL + SHIFT + E then 1 which will make the crease of those edges one.

Advice

Instead of autosmooth, you could use smooth shading and an edge split modifier after the subsurf. If you select both angle based and sharp edge splitting, you can add additional sharp edges by selecting them and marking them sharp at the CTRL + E menu.

Edit One

The edge split actually messes up the pointiness. You can use the auto sharp as originally.

The Blend

Edit Two

The edge crease - besides retaining the sharpness of the inset - also makes those edges not going little deeper, where they should. This is demonstrated by this simple circle:

You can start from a higher resolution cylinder to make those glitches less apparent. The higher the resolution of the base mesh, the less that glitch is visible:

Note: The mesh density at the part where you want to use the pointyness is important, other loop cuts may be  removed. I have also updated the Blend.


You have marked your face as a freestyle face.

Either unmark it, by  RMB selecting it and pressing ⎈ CtrlF in edit mode to open the face menu. In the face menu choose clear freestyle face. You can also untick Face Marks in the mesh display options, if you only want to hide the face marks.


Check your normals. If some of the facess are turned inside out, pointing inward into the inside of the mesh, they can be seen as dark areas.
Before recalculate normals (in the toolbar (N) in the 3D View, or CtrlN):

After recalculate normals.

Note that normals will only be recalculated for selected faces, so you probably want to select all (A) before recalculating.


I can't install blender on my hp desktop pc

Just tried it use the 32 bit that will work


How to find which machine rendered a specific frame in a render farm

You can do this by adding custom metadata to the image using a Python script that is executed by each server. In the network folder, create a script named metadata.py with the following code:

import bpy, socket

name = socket.gethostname()

bpy.context.scene.render.use_stamp_note = True
bpy.context.scene.render.stamp_note_text = name

In your render command, add the -P flag with the path to the script, e.g.

blender -b path/to/file.blend -P path/to/metadata.py -o path/to/image.png -a

This stores the name of the machine in the "Note" section of Blender's metadata. You can view the metadata as described here to see which server is giving you trouble.


How to export a 'posed' mesh as an STL file

Ok, I figured out that after I pose the object, I then need to convert it back into a mesh. Then it will export as an stl file. I selected the object in 'object mode', in the object menu selected 'Convert to -> Mesh from surface....'

(I tried 'apply modifiers' but it didn't seem to work for me)


Import/Export problem for .obj files in Blender 2.79

I had similar problem. It's caused by Widnows Defender Security Center.
I solved it by opening Security Center -> Apps & browser control -> Check apps and files set to off


Animation Key Frame Summary - Change editor text color

It's a long time since I changed mine but I think you'll find that setting in Preferences > Themes > Dope Sheet. Scroll down to 'Theme Space List', click the down arrow, and the setting should be under 'Source List Text'. If not, it's in 'Theme Space' settings above that section. Have a play with the colors (making a note of the current setting) and see what's changing in the interface.


is there any way i can use crossview3d while editing?

for blender v2.79 you can try this:

in the properties editor switch to 'Render Layers'
than activate 'views'
this defaults to 'Stereo 3D'
now go to the main menu 'Window' there is a new option 'Set Stereo 3D' - click it
here you can find multiple different ways - one is 'Side-by-Side'
if you choose it you can additionally enable 'Cross-Eyed'

for this to work you have to enter Full-Screen mode (Alt+F11).

additional information can also be found in this answer
and in the official documentation on multi-views


Why is there so much more hair in render than viewport?

Apart from the children display and render amount, there is another Amount option under the Viewport Display panel. You might have set it low. So at render time its rendering 100% of the hair particles.


From what i can see in the image your object has about 166000 Vertices. In Edit Mode vertices are displayed in a certain size independent from the polygon size, so it may well be that you only see the black vertices, while all edges are hidden because of the vertex "display size". Here is an example with 4 rings of increasing vertex density:

Also none of your vertices is selected right now, so this would explain why the mesh appears in black. So i guess when you hit A then your rings will turn from black to light orange (the color of selected vertices)

Maybe you had added a subdivision modifier to your Curve ? When converting your curve to a mesh the subdivision modifier would be applied...


How to combine Cycles and Blender render god-rays?

If you set Alpha to Transparent in Render Settings > Shading for the BI scene:

The render will have an alpha channel: (Note that you have to enable RGBA in Render Settings > Output to be able to save it with the alpha channel)

(I made the spot lamp red so it would be visible here)

You can then use the Alpha Over node to mix this with a Cycles render:

You could also use the alpha channel as a Factor:


Your screen shot is not showing normals,
Please try to select one Object and flip the normals in your required direction
select other object and flip the normals to your required directions

as you combined the Objects all ready please use the mouse hover and L key to select each object.

Take a look of the image if I understood your issue correctly

I hope it will help you


Select bones. CTRL+A (apply transformation), play animation on Blender. It will deform. This is the same result you see in Unity. Delete your animation. Correct and regenerate (re animate) your bones. Now, if you export, unity will see them correctly.

You ALWAYS need to ZERO (freeze), CTRL A (apply transformations) To anything you do in rigging before start animation.


Im new and confused what these files mean... (new to blender)

The first image is indeed the albedo, which is the base for a material. The rest are for things like bumps, roughness etc. The second one is for roughness, the third one is the normal map, and the last one is the displacement map.


Why does trying to render with Cuda on a remote server fail?

I don't know your specific error code, getting this ***** to run on server took me forever. What helped was getting the latest Daily Build and installing it instead of the default blender package. Also try a similar code to mine if nothing works (mine works for two Titans XP's, you'll have to rewrite it for your GPUs I guess).  If I remember correctly enabling all devices enabled CPU and caused blender to only use that.

def gpuSettings():
    bpy.context.scene.render.engine = 'CYCLES'
    bpy.data.scenes["Scene"].cycles.device = 'GPU'
    bpy.data.scenes["Scene"].cycles.feature_set = 'SUPPORTED'
    bpy.context.user_preferences.addons['cycles'].preferences.compute_device_type = 'CUDA'

    # Switch render engine to cycles
    cprefs = bpy.context.user_preferences.addons['cycles'].preferences

    for device in cprefs.devices:
        if device.name == 'TITAN Xp':
            device.use = True
        else:
            device.use = False

    #print('Compute_device_type: ', cprefs.compute_device_type)
    for device in cprefs.devices:
        if device.use == True:
            print('USED: ', device.name)
        else:
            print('NOT_USED: ', device.name)
    print('Will be used: ' + bpy.data.scenes["Scene"].cycles.device)
    print('Feature set: ' + bpy.data.scenes["Scene"].cycles.feature_set)
    print('Render engine: ' + bpy.context.scene.render.engine)
    return


Copy center of mass of an object to another object

Never mind. I got it. Cursor to Selected, then Center to Cursor.


How can I make an infinite loop in Python in Blender？

Blender scripts are not subprocesses: if you trigger an infinite loop in a script/addon, Blender will freeze as well until the script finishes what it is doing.

The reason why you can't see an outout is that Blender's print() funtion displays the text in the console window, that you can open in Window -> Toggle System Console

If you execute your script then you'll see that your text keeps being written and the script is working

If your code is very long you could make it a subprocess or execute externally (but you rarely need to do it), while if you just need to execute it once in a while you can use modal operators

with modal operators, for instance, you can  execute your script every 0.1 seconds and make it print your text, so in that 0.1 second Blender has time to update the UI


Snap object on top of surface of other object

Use Blender's snapping feature with Snap Element set to Face. The configuration group is right on the 3D View's header.

If you activate Snap during Transform (Shift + Tab or the magnet button), you don't have to hold Ctrl while grabbing the object.

You can also Align rotation with Snapping Target (2nd button from the right) so the snapped object aligns its orientation with the face's normal.

It's possible to snap the lower (-Z) part of an object to another's surface, by placing the object above its intended target. It seems snapping uses the nearest point of grabbed object, and its relative position to target before transformation. I get these inconsistent snapping positions if the object's moved from above the target, and need manual adjustment to keep it outside the surface:


He's in edit mode, try pressing the Tab button to enter it.

By the way, I'd absolutely recommend you checking out this tutorial, especially the first 2-3 lessons. It goes in detail about Blender UI and all its menus and submenus.


Acces unmodified Normals on object with Custom/Transferred normals

Animation Node can be used to assign vertices normals to vertices colors in near realtime. Using those normals in cycles won't yield the same results as the Phong smooth shading cycles uses, however it provides very similar results.

Background Information

Understanding How Vertex Colors Work

The name Vertex Color is a bit misleading, it should be noted that color data is not stored per vertex, but rather per loop. A loop is basically a vertex of a polygon, so if a vertex is part of four polygons, it will compose four loops, to understand this better, lets look the following illustration:

The above is a mesh with 4 polygons, each polygon has 4 vertices and subsequently 4 loops. We represented loops by colored dots, you notice that each vertex compose either 4 loops as blue loops, 2 loops as red loops or a single loop as violet loops. Now, If we were to color all loops white expect the blue loop in polygon three, we will get something like this:

There are some advantages of storing colors in loops instead of vertices, the main advantage being the ability to color polygons. If colors were stored in vertices, it would not be possible to color a polygon with a single color, think about it ! To color a polygon using loops, we just have to color all loops in the polygon with the same color:

On the other hand, to color a vertex, we have to color all loops that are part of the vertex, same-color dots in the above illustration:

In case of coloring vertices, the fragments (pixels or dots) in polygons will be colored according to a convex combination of the colors of its vertices (a bilinear interpolation for quads), such interpolations are particularly useful to represents smooth shading in your case !

So if we were to color vertices based on some color list, we will have to identify the loops that are part of each vertex (same-color dots in our illustration) and color those loops based on corresponding color from the color list. We will also explain polygon coloring for completeness.

Understanding How Loops Are Stored In Meshes

Vertices have indices which we can use to identify and select them by, the same goes for polygons and edges. How are loops ordered and how can we identify them? To answer that, let us consider this simple cube as a study case:

Where polygon indices are shown in red and vertices indices are shown in blue. The ordering of loops follows two rules:

Loops of the first polygon are stored first, loops of the second polygon are stored next, and so on.
Loops in individual polygons are sorted from the lowest vertex index to the highest.

We can represent the loops as an ordered pair $(x, y)$ where $x$ is index of the polygon it is part of and $y$ is the index of the vertices that it is composed of, and the set of ordered pairs for quadrilateral mesh will be:

$$
\begin{aligned}
&(0, 0), (0, 1), (0, 2), (0, 3),\\
&(1, 0), (1, 1), (1, 2), (1, 3),\\
&(2, 0), (2, 1), (2, 2), (3, 3),\\
&(3, 0), (3, 1), (3, 2), (3, 3),\\
&\dots
\end{aligned}
$$

To understand this better, we drew the indices of the loops over the study case :

Coloring Polygons

In order to color polygons with flat colors, we have to color all loops in a polygon with the same color, in the above case, in order to color the polygon with index zero, we will have to color indices $(0, 1, 2, 3)$, to color the polygon with index one, we will have to color indices $(4, 5, 6, 7)$, and so on. Notice that the indices are in the pattern $(0, 1, 2, \dots)$, grouped in groups of length equal to the number of vertices of the polygon, so all we have to do is generate a list such that the first $n$ number of colors are the color of the first polygon where $n$ is the number of vertices in the first polygons, the second $n$ number of colors are the color of the second polygon where $n$ is the number of vertices in the second polygons and so on. In practice, we loop (iterate) over polygons, get the number of vertices in it ($n$), get its color from the color list, append it to an initially empty list $n$ number of times. An implementation in animation nodes is as follows:

Don't worry about the Set Vertex Color Subprogram, we will study it in a second. Notice that we used the polygon normals as colors in here. Also, we represent colors using 3D vectors; because they in fact are (Vertex Color doesn't support Alpha Channel).

Coloring Vertices

Vertices coloring is a bit harder to understand but easy nonetheless. Lets look at the study case one more time:

Remember that in order to color vertices, we have to color all loops that compose that vertex, in the above case, $(0, 4, 8)$ should have the color of the vertex at index zero, $(1, 5)$ should have the color of the vertex at index one, and so on. Notice that polygons are merely an indicator of which vertices are in each polygon, now remember that loops are stored in the same order of polygons, so the algorithm for generating the loops colors is as easy as looping (iterating) over polygons, using the indices of the polygon to get the colors at the same indices, append the colors. Take your time to understand it, you will only understand it if you think about it. An implementation in animation nodes is as follows:

Notice that we use the vertices normals as colors in this example.

Set Vertex Color

Animation Nodes currently does not have a node to set vertex colors directly, so we will have to write a small script to do that, a possible way to do it is as follows:

#Create a vertex color map named "Normals" if it is not already created.
if "Normals" in Object.data.vertex_colors:
    map = Object.data.vertex_colors["Normals"]
else:
    map = Object.data.vertex_colors.new("Normals")

#Loop over Colors and assign them to the vertex color map.
for i, color in enumerate(Colors):
    map.data[i].color = color

The script creates a vertex color layer named Normals which is then filled with the data from the Colors list, the Colors list is a 3D Vector list of $n$ Vectors, where $n$ is the number of loops in the mesh.

Answer

You probably already know how to set the vertex normals to vertex color map by now, we did it couple of time above, so such a node tree should achieve what you want:

But wait, there are some things to take care of. Blender only store the colors in the interval $[0, 1]$, but our vectors are signed, ideally in the interval $[-1, 1]$ if normalized. This can be handled by linearly remapping the $[-1, 1]$ interval to the interval $[0, 1]$ in Animation Nodes, then in cycles use the inverse remapping function to transfer the vectors back to the interval $[-1, 1]$. The remapping function can simply be $\frac{V + I}{2}$ where $I$ is the identity vector matrix, and the inverse remapping function will be $2(V - I)$. Notice that $V$ has to be normalized, because while Animation Nodes doesn't care about the magnitude of the normals, cycles does, and will yield unexpected results if not handed normalized vectors. Moreover, normalization has to be done in Animation Nodes due to the assumption we made that the vectors are indeed normalized in the remapping function.


As mentioned in the comments this a complex enough that it might warrant modeling it by hand. If, however, you don't need an extremely clean topology you can easily do it with a combination of an Array + Boolean modifier. At least the radial part that is, the other one seems simple enough to do separately by hand.

Create your step as a mesh object, but make sure it is a closed, manifold solid object (you'll need it later for a Boolean modifier).

Add an array modifier to it, set the $Z$ offset to the desired height of the step and set it to Object Offset

Now add an Empty object to the scene, and give it the exact rotation you want between each step. Say you want $12$ steps in the curve part, that will go around $180º$, then you have $180 º / 12 = 15º$, so rotate the empty $15º$ about the $Z$ axis and point the Array modifier Object Offset to it.

When you have the array set up, just add a new mesh object with the exact shape of the staircase boundary, a simple box will do. Making sure the steps are large enough to cover the whole volume.

Now add a Boolean modifier and you are all set. If you get any artifacts with the Boolean operation be sure to leave a small gap between each step.