what can you call from the attribute node?

Currently you can get:

density When used on a domain object, this is gives a scalar defining the density of any smoke inside the domain. All three outputs are the same.

flame When used on a domain object, this is gives a scalar defining the density of any fire inside the domain. All three outputs are the same.

color When used on a domain object, this is gives the color of the smoke. The color and vector outputs are the same. The fac output is an average of the channels.

N This gives the normals of the object. You can also get this info from the normal output of a geometry node.

Ng This gives the true normals of the object. You can also get this info from the true normal output of a geometry node.

pointiness This gives a scalar representing the amount of curvature of the object's surface based on it's normals. You can also get this info from the pointiness output of the a geometry node.

uv This gives the UV coordinates of the active UV map (the map with the camera icon active). Same as the UV output of the texture coordinate node.

generated This gives the generated coordinates of the object. Same as the Generated output of the texture coordinate node.

tangent This gives the tangent coordinates using the object's active UV map. Same as the Tangent output of a tangent node with direction set to UV map.

name of uv map
This allows you to get the UV coordinates stored in a specific UV map belonging to the object with the material. You usually want to use the vector output, though the color output is the same. The Fac output gives an average of the channels.

Note that as of 2.71 there is a dedicated UV map node which makes this obsolete.

name of vertex color set
This gives the vertex colors stored in the named vertex color datablock. Again the color and vector outputs are the same, and the Fac output is an average.

In the case of a vertex color datablock and a UV map with the same name, the UV map will be used by the attribute node.

There are actually quite a few more in the code, the ones listed above are just the ones which appear to work as of 2.74 930bf58 (latest master at the time of writing).
For a complete list, see line 192 of /intern/cycles/render/attribute.cpp:
I put //no output next to the ones which appeared to do nothing.
switch(std) {
    case ATTR_STD_VERTEX_NORMAL:
        return "N";
    case ATTR_STD_FACE_NORMAL:
        return "Ng";
    case ATTR_STD_UV:
        return "uv";
    case ATTR_STD_GENERATED:
        return "generated";
    case ATTR_STD_GENERATED_TRANSFORM:
        return "generated_transform";   //no output
    case ATTR_STD_UV_TANGENT:
        return "tangent";
    case ATTR_STD_UV_TANGENT_SIGN:
        return "tangent_sign";          //no output
    case ATTR_STD_VERTEX_COLOR:
        return "vertex_color";
    case ATTR_STD_POSITION_UNDEFORMED:
        return "undeformed";            //no output
    case ATTR_STD_POSITION_UNDISPLACED:
        return "undisplaced";           //no output
    case ATTR_STD_MOTION_VERTEX_POSITION:
        return "motion_P";              //no output
    case ATTR_STD_MOTION_VERTEX_NORMAL:
        return "motion_N";              //no output
    case ATTR_STD_PARTICLE:
        return "particle";              //no output
    case ATTR_STD_CURVE_INTERCEPT:
        return "curve_intercept";       //no output
    case ATTR_STD_CURVE_RANDOM:
        return "curve_random";
    case ATTR_STD_PTEX_FACE_ID:
        return "ptex_face_id";          //no output
    case ATTR_STD_PTEX_UV:
        return "ptex_uv";               //no output
    case ATTR_STD_VOLUME_DENSITY:
        return "density";
    case ATTR_STD_VOLUME_COLOR:
        return "color";
    case ATTR_STD_VOLUME_FLAME:
        return "flame";
    case ATTR_STD_VOLUME_HEAT:
        return "heat";                  //no output
    case ATTR_STD_VOLUME_TEMPERATURE:
        return "temperature";
    case ATTR_STD_VOLUME_VELOCITY:
        return "velocity";              //no output
    case ATTR_STD_POINTINESS:
        return "pointiness";
    case ATTR_STD_RANDOM_PER_ISLAND:
        return "random_per_island";
    case ATTR_STD_NOT_FOUND:
    case ATTR_STD_NONE:
    case ATTR_STD_NUM:
        return "";
}

Note that for the most part the attribute node seems to be used as a sort of "testing node" for inputs which aren't yet available in other nodes[citation needed]. I suspect old attribute names are not removed when they do get added to another node (e.g. pointiness) as this would break backwards compatibility.
At any rate, this would at least begin to explain why there is little to no documentation about this node.


Right after adding your object, uncheck the [   ] align to view option in the toolbar. If you don't see the toolbar, hit t and it will pop up on the left side of the 3d view.

Edit --
Just to add Zac's comment: you also can access this menu by hitting F6 after adding your object.


Cycles not rendering with background image

One thing is the background image you see in the view port to guide with your setup and another is the background you render. Here is the setup to create a background image in your rendered scene.

Regarding your second question, this type of setup wont reflect the background in your final render, to do that you should follow the previous answer about HDRI.


add object at specific location with python?

The tooltip of the Add > Mesh > Plane menu path shows this information, press Ctrl+C to copy it to clipboard.

Tooltip

All of these menu items trigger operators and take several optional arguments, location=(x,y,z) included. The same applies to the other items in the Curve, Surface Metaball etc., menus.

Docs

The total list can be found in several locations, in the docs

Blender's Python Console

use the auto complete feature (ctrl+space) in the Blender python console after typing bpy.ops.mesh.primitive_

The arguments to the bpy.ops.* can be found doing auto completion too

Info Panel

You can see the history of most of the code which has been triggered in the UI, in the Info panel if you drag it down


Mirror modifier mirrors on different axis/axes from the selected one(s)

If the ear was rotated, you will need to apply the rotation. To do this, in object mode either press
CtrlA then R or click Object > Apply > Rotation.

See: Why is it important to apply transformation to an objects data?


Using update
In your operator add a property
double_angle = BoolProperty(update=self.double_angle)

Add a double_angle method to your operator
class sharpenOperator(bpy.types.Operator):
    '''ToolTip'''

    def double_angle(self, context):
        if self.double_angle:
            self.angle *= 2
            self.double_angle = False

Add to the draw method
    row = box.row(align=True)
    sub = row.row()
    sub.alignment = 'LEFT'
    sub.prop(self, "double_angle", text="", icon='X')

    row.prop(self, "angle", slider=True)
    sub = row.row()
    sub.alignment = 'RIGHT'

    sub.enabled = self.angle < radians(90) # doesn't work in F6
    sub.prop(self, "double_angle", text="", icon='X')


Keep straight and sharp lines when sculpting with Dyntopo

Change the Dyntopo Detail Refine Method settings from Subdivide Collapse to Subdivide Edges.


Yes you can.

Just go into the Vertex group. Look for the down arrow button, right click on it and select "delete all groups".


Ok, I've just been testing myself, basically it's what I said before. OBJ file format specification probably doesn't support "vertex groups" feature.
There is no such structure or way to store that information in this file format.

What blender does apparently try to map vertex groups to the "poly groups" feature of OBJ. Since polygroups - as the name implies - only stores groups of faces it as a few caveats as it can't unequivocally map vertex groups to faces, so it can't store certain cases like single isolated vertex from vertex groups.

The minimum supported is probably three vertex, which is the least possible to define a face. This is what my four-corner vertex group (to the left) was imported like, two separate meshed with the four corners separated from the main one (colors for clarity purposes).

So short answer is it is not supported, either find another file format that supports this, recreate you vertex groups in your destination application, or fix them by hand there.


I don't think that is possible, at least the results will look different.
Cycles uses a completely different rendering system than what realtime graphics applications like Unity use.

The Cycles Renderer is a ray tracer and has full knowledge of the whole scene all the time. It can model shadows, reflections, refractions and indirect lighting pretty easily, but they cost a lot of computation power.

Unity on the other hand uses OpenGL and Direct3D for rendering. Both APIs are optimized for realtime graphics, but during rendering only single objects are known. Reflections and shadows have to be faked by rendering the scene multiple times from different angles. To get performant global illumination it is precalculated and refractions are usually faked by distorting the final image.
So even if you export all the settings from Cycles to Unity, the rendering engine in Unity can not use them correctly.


How do I change the mode of perspective?

If this is what you're asking, you can switch from User Perspective to Orthographic by using the Numpad 5 key.  The perspective type is given in the upper left hand corner of the 3D view.

The differences can be found here: What are the differences between Orthographic and Perspective views?

Essentially, Orthographic is a "non-real-world" view in which all dimensions have the same scale... i.e. objects that are farther away appear to be the same size as objects that are near-field.


First setup your equirectangular image as an environment texture to the world surface :

Go to the world panel, in the surface part: choose 'environment texture', then your image and select 'equirectangular'.

(below, the world panel setting on the right, the node equivalent on bottom and the view rendered on top with default cube in place)

Add a camera, set it to 'panoramic' in its property panel, then choose 'equirectangular'. This camera will be used to render the scene, so you can here choose its orientation in order to have the same centered image as your original (as you need).

Add a text... somewhere... depending on where you want it to be.

To adjust its position, go in camera view Numpad0 in rendered mode, select your text, and move/rotate/scale it as needed

Now we need to render the image :

Go to the render panel, choose the size you need and the format you want, and click on 'render' :

Save your image F3 and in the options which are at the bottom left, choose the export format you want :

You are done. To test the result, simply set this new image as environment texture (as we did for the original image at the begining)


Assigning two shortcuts for the same action

There is a way, but it's a very bad idea
You should not do it. Middle click is used too much to practically change it and retain important functionality in Blender's keymaps.
You would have to add a new entry here in the Preferences(F4 -> P), Keymap tab, under Screen, Screen(Global):

But you would also have to search for and remove all the conflicts:

That would break stuff.
This would be a very bad idea.


If you set the emission to a large number, it will shine very bright in the scene on other object, which you may want, however, I used a fresnel input to find the outer edges and used a color ramp to convert them to red and white.


I came up with this - color ramp was the solution


Matcap is about giving color information relatively to the normal of the faces.
It is spherical to encode all the possible normal orientations smoothly.
So, if you render your material onto a sphere plus a plane that cuts the sphere at its middle, you can obtain the desired image texture.

To render a square texture, change the settings is the output properties:

The camera is placed on top, on the middle, and its focus length is adjusted so that the sphere fits the view:

I've placed all the shader nodes in a group.
For the sphere (the node group contains your shader settings):

In order to reuse it for the plane with a tangent input as we want the plane part to continue smoothly from the sphere at 90° angle:

Once all this is done, you can simply render F12 the image and save it.
To reuse it in Blender, you can setup a node tree as indicated here for instance.
You may also want to add it in your preferences to use it in viewport rendering:

Result:


How can I view textures without a material? (Blender 2.8)

Without a material, as far as I know, you can't view a texture.

You can view the texture in Solid Shading mode using Texture as Color without shaders and material output.

This mode uses UV mapping of a mesh directly, no Vector transformations available.


what would be the equivalent tool to this in blender

You can use the "proportional editing" hiding all the part of the mesh (H) you don't want to move.
here the process:


Render without a display adapter (XEN virtual machine)

Use the --background (-b) flag to prevent blender from attempting to open a GUI.
blender -b -E help should work as expected.


Adaptive Subsurf is meant to change density of a mesh (as regular Subsurf). You can't control smoke by this as smoke is a Volume simulation.


It's hard to tell what is your problem as you don't show any wireframe. If I had to do this kind of object I would begin with the inner circles, then the main outer circle, then extend the shape, then extrude, bevel, add edge loops to sharp the edges, etc...


Weird blotchy shadows in blender cycles (denoising)

This is how to use Intel Optix Denoise node in compositor.
Basically instead of using the Blender denoiser, using this node allows you to denoise a scene using low samples, and without creating splotchy/dark areas.
Downsides? This node may cause blurring in some areas, when used with very low samples.
This image is with regular denoising, rendered at 4 samples (to show effect):

This is the same scene, but using the denoise node in the compositor to denoise:
This is the original image without any denoising:

As you can see, it has a major effect on render times, and denoises well, but it can be blurry on very low quality renders.
You can enable this node by going to the compositor, and clicking "use nodes". Then add the denoise node between the image node and the output node. (You can press Shft+A to pull up a search menu for the node).
A simple connection between the image points should do the trick:

If that is too smooth, you can try connecting the image node to both the image and albedo points on the denoise node:
The node runs on your CPU, so there should be no reason why you can't get it to work.
For more info about connecting the denoise node, see this post:
How to properly connect the Denoise node in Compositor?


Is the roughness setting is based on a standard measuring unit?

There are several models how light interacts with surfaces. Cycles supports Beckmann, Ashikhmin-Shirley, GGX and Multiscatter GGX models. They all model surface imperfection (roughness) with microfacets:

  We assume that surfaces that are not perfectly smooth are composed of many very tiny facets, each of which is a perfect specular reflector. These microfacets have normals that are distributed about the normal of the approximating smooth surface. The degree to which microfacet normals differ from the smooth surface normal is determined by the roughness of the surface.

So the roughness is only a statistical value how microfacet normals deviate from the mean (smooth surface). How the surface looks is determined by the lighting model used.

There are many methods for measuring surface roughness on materials and they all are also just statistical values. They are based on the amplitude and frequency of surface imperfections ( how they deviate from a perfectly smooth surface). These imperfections can be measured using profilometer.

The Beckmann model uses Rdq roughness and like this it's results could be validated against physical objects. The Beckmann specularity distribution formula is defined in this paper on page 6.

The Principled shader uses the GGX specularity model and uses perceptual roughness defined in this Pixar paper. It is the same roughness that many apps use, like Arnold renderer, Substance painter, most pbr game engines, and many others (Renderman of course, etc..):

Roughness = (Perceptual_roughness)^2

This perceptual roughness has more linear progression and is more friendly to artists, but doesn't directly correspond to physical methods of roughness measurement.

Blender version 2.79 has inconsistency in this (between Principled and GGX glossy). If you want the same result using Principled shader as you are used to from Glossy GGX, you need to square root the roughness.

However this inconsistency is planned to be fixed in version 2.8 and unified using perceptual roughness.

You may find this related answer thread also useful:

What do glossy distribution models do?


I took a look at the given answers, and here want to show you how I solved this question in the end.

@risingfall 's answer worked but has the downside that the trail only extent in certain directions relative to the particle object. Also, if I would like to change the molecule to another one later on, I would have to remodel the whole thing (yes, not too much work in this case, but nevertheless).
I tried to work with @Duarte Farrajota Ramos suggestion, but since my blender experience is not great I did not understand how to use the Btrace addon in my case. Anyways, the suggestion taught me that I can use an animated scene even if the desired result is static.

Here, I want to quickly show you how I ended up doing the scene so that it might help somebody else out:

I created a particle system on a circle object as above.
I chose "Grid" as the particle distribution method. With the according "random" slider you can add a random offset to the regular grid locations.
Under the velocity dropdown, I set the Random-Value to 1. This gave the particles a random velocity (random in direction and absolute). To prevent some particles being larger than others because they moved towards the camera, I set my camera to orthographic, so that all position deviations in the direction of the camera got projected into a plane.
I rendered the scene with a very slow shutter speed and a very awkward shutter curve (see image below), to get the desired effect of a motion trail fading out the further away from the molecule it gets.

To obtain the look of an unblurred particle with a blurred trail behind it, I re-rendered the last frame used in the motion blur, to get an unblurred version of the molecules "last" position, and overlayed them later in an image processing software.

The final result looks like this:

What I like about this solution is that the trails have the same color as the objects and have different lengths depending on the component of the random velocity in the direction of the camera. I could also remodel the molecule and would not need to do anything else than rendering again. Furthermore, the particle positions are not too random. :)
What I dislike is that one can clearly see that the blurred and sharp version of the image are overlayed in post (the trail loses the impression that it originates from a 3D-Object), but I have not implemented a solution for this yet. One option would be to duplicate the objects at the last frame and setting the duplicates velocity to zero. This way, the particles that create the trail would generate the impression that the trails comes "out of the particles" and does not lay behind them. I don't know how I would do this though.


Blender not using selected compute device

It shows GPU core clock at 135MHz. There is something wrong with that. Usual clock speed of GTX750TI is 1020MHz. It could be that for some reason the driver crashes and it switches to some sort of a safe mode. Updating drivers would be first thing to do. I would try using it just after rebooting the PC. If it works just after a restart then it will be clear that the problem is indeed with the driver crashing. The GPU could be overclocked too much or it might be overheating or it might not be able to get enough power.


Is it possible to make the object change color when touching another object?

I found a way to implement this. I just need to bind the driver to the nodes.
It's not an easy way, but it works great!

Here, the material nodes (each key has its own, independent) are based on a variable that is controlled by the driver, which, in turn, looks at the local rotations of the key.

The difficulty is precisely in the quantity: 88 keys with 88 materials and the same number of drivers.

each key, just in case, is tied to empty, which are collected together and attached to the main empty.

The recipe is as follows:

create the first material with nodes according to the example above
RMB on value -> add driver "guide"

You configure the driver by example. Here the "key name" will change from material to material (the name of the object-synthesizer key is implied).

you transfer the key to the pressed state and turn the ColorRamp until it is white at rest, and green when it is pressed.

An important point:
before all operations, you need to reset the rotation and scale of each key to normal, via Ctrl + A .

You duplicate the key, put it next to it, duplicate the material, rewrite the name of the key in the edited driver and repeat until you assemble the keyboard.

Then link through empties and you can move the synthesizer by pulling the main one
Here it is also important that the animation is exactly the rotation of the keys according to their local coordinates.


Mantaflow. The liquid just doesn't respect the collision object

I agree this seems to be some bug and have seen several posts.   One suggested solution was to use a Surface Thickness equal to the volume of the collision object.   However, Thickness is defined in the docs as an ADDITIONAL dimension beyond the mesh.  When I play with Thickness, it works but has to be a minimum of 0.5 and has a deleterious effect on the liquid boundaries as you'll see here:

I dread to suggestion a solution where a duplicate, hidden collision object that is some 0.5 (what is the translation to units?!!) larger than the visible collision object.
Perhaps another (degenerate) solution is to set "Is Planer" if the collision object is simple or if you break up the collision object into sub-objects. This appears to work.

So until others can be helpful in assisting with a solution (or admission of a bug), then perhaps there is something useful here.


Why do i have bald spots with hair particlesystem?

For some reason that I cannot find, some of the interpolated child hair strands are growing inwards -no bald areas actually. You can see little dots in those areas which are the root of that bad children that are growing inside the mesh. The interpolation is bad though the face normals are fine and I couldn't find any other cause for this.

So, as the problem is the interpolation between parents, the solution is adding more parents manually.

Go to the Particle Edit mode, then choose the Add tool and add a parent wherever there is a bald spot. Then, the Children will rearrange around the new parent and will face towards the face normal as the parent.

You can se above that I fixed the right leg.

Note that doing this means have more parents and, eventually, will create more children too. You might want to change the number of children.


I like keeping things procedural, and as much non-destructive as possible.

If you strive for the same goals, then you can use these techniques.

Draw a curve or mesh object in the shape of the cuts you want to make, select it, then Shift-Select the mesh object and enter Edit Mode.

Under Edit Mode select all faces and use the Knife Project modifier to cut the shape into the object.

Now in your mesh mark all edges you want to use as "edge extrusions" as sharp. Ctrl+E > Mark Sharp including the ones you cut and any other you may want.

Then just use a combination of Edge Split modifier > Solifdify modifier > Bevel modifier, and you have an easy to edit object with only the desired edges with indents.


Mirror image disappears when joining with another object

Objects are not carrying their modifiers. After joining them, only the main object's modifiers will be valid. If you have a mirror modifier on the cross apply it first, then join them.


How to make objects follow a ellipse? (Duplication around ellipse)

Create a plane, create a curve, scale the curve in Edit mode to make an ellipse, give the plane an Array and a Curve modifier with the curve as Curve Object:

Create your tower object, parent it to the plane. Select the plane, in the Properties panel > Object > Instancing, press on Faces, your tower will duplicate around the ellipse shape:

To make each instance independent, select the towers and press CtrlA > Make Instances Real. If you want them to not share the same mesh, go into the header menu > Object > Relations > Make Single User > Object & Data.


Is there a modifier to transform proportionally along a circle? (for tri-lateral symmetry)

Thanks to @Jerryno, I have an even more general solution than I was hoping for.  In fact, it addresses any degree of symmetry that I need.  Here are the details.

Here is my base geometry with only a subsurf modifier:

Notice it also shows a Bezier circle that I will be using.

1 - Add an Array modifier with a fixed count of 3.  Notice that Merge is checked.

This gives a result like:

2 - Next we want to use a Curve modifier to bend things around the circle.

This gives something like:

3 - Don't fret about the gap.  In order to close the gap, select the Bezier Circle and type "3/pi" in the X Scale and Y Scale.  Since Blender interprets the Python expression it will show .955 in the cells as in:

Which gives the very satisfying result of:

Interestingly, if you change the Array modifier fixed count to anything, N, and change the scale on the circle to N/pi, you can get higher degrees of symmetry (e.g. w/ N = 5):

How cool is that?!  (Man, I love Blender!)

One more thing might make this even more convenient.  Since we have an odd number (3 in my case) of repeats, it isn't truly symmetrical.  When I edit, it looks like...

If you want this edit to be truly symmetrical (i.e. each edit affects 6 analogous areas in the final geometry), then put a Mirror modifier for the X axis first in the modifier stack and only start with half of the original geometry.  And we get...

So to summarize, the full recipe of modifiers for this N-lateral symmetry is:

1 - Mirror Modifier in X

2 - Array Modifier w/ a fixed count of N

3 - Curve modifier with a Bezier Circle

4 - Make sure the Bezier circle has a radius of N/pi


You need to go to Edit Mode, right click on the big ball under the ankle, press E and make another bone.


Old school material shader (ambient, diffuse, specular)

Its not the same, but there are similar parameters in the new eevee renderer.
Using the Specular shader you can tweak diffuse + specular color.

Via world properties -> color you can tweak the ambient color

Also accesible in shader editor:


in final render it remains visible from the start! The castle isn't supposed to show in the beginning

The eye icon controls the viewport visibility. The render visibility is controlled by the camera icon. Both of them can be keyframed independently of each other. This way you can have an object visible while you model, e.g. to make sure it doesn't intersect other objects, while hiding it in the render, or hide an object in the viewport, to make otherwise obscured objects easier to edit, while having it show up in the render. The screenshot below is from Blender 2.79, and in 2.8 it is slightly different, but similar enough that this image should suffice for both versions.


Texture appears in Edit Mode but not in Rendered mode

Figured it out. I needed a mother loop cut to stop the subsurf at the limits of the object...


Where are the default matcap files located?

You can't add matcaps in blender 2.79 or lower, as in the release notes of Blender 2.66
(March 6th, 2013) it read:

Currently a set of 24 (GPL licensed) Matcaps have been compiled into Blender.
[...]
Loading own matcap image files will be added later. That needs design and code work to get it stable and memory-friendly.

6 June 2018: This option has been added to the development version of Blender 2.8 as shown in this youtube preview by the Blender Developers


Choose unit scale that you like:

0.001 if you need to scale meters to millimeters.


I found a way to do this that takes a fixed number of inputs (it also has the useful property of mixing its inputs given a non-integer):

This is extensible, but only by manually editing the node group.


'Material' option does not exist in the 'Select Similar' menu

Vertices don't have material data connected to them, Faces do. So you need to change to Face select mode in the 3D View header and then press Shift+G:


You need to do the following:

Apply all transformations to mesh and armature (select mesh/armature then CTRL+a)
Make the armature the parent of your Mesh. To do so in Object Mode select the badger mesh and then on the Object tab at the bottom there is a "Relations" menu. Open it and click on the "Parent" text box. Select the Armature object and set the option below to "Armature":

Then select your Armature and go to Pose Mode and select a bone which you want to assign to faces (here the head bone):

Then shift click on the badger mesh. With the mesh selected go to Weight Paint mode. Now you can assign faces to the done by "Painting" on the mesh. Assigned faces will become red:

With the faces assigned you can now go back to Pose Mode of the armature and the faces should follow deformations of the bones. Note the "Pose Position" selected in the panel to the right:

One advice: your mesh is very distorted and it will be hard to achieve something satisfying without some rework of the mesh. I did some cleanup, if you like I can share my edited mesh...


To rotate an object, press the key 'r', and then press either 'x', 'y', or 'z' to get the rotation in a specific axis (This is not required. You can press 'r' and rotate freely.). The rotation will be based on the origin of the object, or the tiny yellow dot that shows up when you select it. In your case, if the origin is not at the base of the wing, follow these steps:

'Tab' to enter Edit Mode
Select the bottom face of the wing
Press 'Shift + S' and choose 'Cursor to selected'
Exit Edit Mode
Right click >> Set Origin >> Origin to 3D Cursor

Now, when you rotate in object mode, it should rotate and flip down.


Small errors when baking displacement maps

Looks like a baking bug to me.

Investigation shows the artifacts are already present in the .exr and the displace works as intended. I just subdivided a plane to 16.78M polys for 4096 texture and it showed the same result as you posted.

Artifacts in .exr:

Then I tried converting the curves into mesh, different curves resolutions and smoothings, normalized/unnormalized bakes but I always got black pixels at different random spots.

When I plug the raw bake into compositing nodes and inspect it it has artifacts, so it is not the exr.

The only solution that worked for me are smooth modifiers after the displacement, which is not really a solution.


AO map is pixelated. Any way to fix it? (pictures below)

Properties panel > World tab > Gather options : enable Falloff then play with the Distance and Strength values.

Do your test AO bakes at 5 Samples and when you are happy with the result then up the Samples to 20 or so for the final bake.

Note, enabling or not the Ambient Occlussion option in the World tab will make no difference to the bake. The Gather options will be greyed out but they can still be changed.

Normally AO bakes are greyscale, if that is what you want then put a check against Normalised in the Bake panel.


How to run a modal operator after file open?

You can use a handler to start your operator after a blend file is loaded, ensure the handler function is marked as persistent to keep it active between file loads.

This is of limited use on blender start, it will work if the addon is enabled and the splash screen is not shown on startup. If the splash screen is shown the operator does work but the display is not updated while the splash screen is visible, dismissing the splash screen also stops the operator.

from bpy.app.handlers import persistent

@persistent
def load_handler(dummy):
    bpy.ops.object.modal_operator('INVOKE_DEFAULT')

def register():
    bpy.utils.register_class(ModalOperator)
    bpy.app.handlers.load_post.append(load_handler)

def unregister():
    bpy.app.handlers.load_post.remove(load_handler)
    bpy.utils.unregister_class(ModalOperator)


How to make characters hand/pass each other objects

In the same way that you've already created a Child Of constraint for the first character, you can simply create another Child Of constraint for the second character, and point it to the same object as a target. Only, the second character's Child Of constraint should have its influence slider set to zero, and keyframed at zero for whatever length of time that the first character is to have the object in hand. Likewise, the first character should have the Influence slider for its own Child Of constraint set to be fully active, and also keyframed as such, for that same duration. At the time that the hand-off happens, you simply keyframe the influence of both Child Of constraints to have reverse influence from what they both had one single frame beforehand. This works very well. The two characters do not even have to have anything in common regarding their rigs. They certainly don't need to have rigs that are exact copies of one another. They simply each need their own Child Of constraint, and each of them needs to point to the same object. The only thing that changes is the influence.


how to render in user perspective and not camera perspective

There is no real way to do that. (For example many settings like defocus depend on the camera object.) You simply will have to move the camera around.

Firstly: You can move the camera around like any object (grab with G, rotate with R and scale with S), but it is easier to go to the camera perspective (numpad 0) and enter fly mode (Shift+F). This allows you to position the camera in a more practical way. (See this in more detail here: https://youtu.be/xcZmyD9jkI4)

Secondly: If you want to save the camera's position for some reason, you can simply add a new one to the scene (Shift+A) and set it to be the active camera by pressing the Ctrl + 0 hotkey. Now the scene will be rendered from it and hitting 0 will make you look through it. You can tell which camera is active by looking at the camera object from another view: the small triangle above it is filled when it's active.

Thirdly: If your user perspective is "just the right way", you can align the camera to it (I can't remember the hotkey, but hitting space and looking for something along the lines of "Align camera to view" should get it).


Click this icon and select Median point.

Read more here : Pivots


Make sure Emitter is checked under Render at the Particles panel.


The suggestion is ... do [not] rely on the concept of undoing any action in the Console window.

Use the Text Editor window for functions you write for long term value

By writing functions and executable statements in Python in the [Text Editor] window you can more easily test your concepts, and save your work with Blender or as an external file.
The written record is invaluable.
Clearly the [add ons] of Blender are written with a text editor and saved as files.
The console is superb for investigating structures with statement completion and dir and type.  1 to 3 lines of Python is useful. (Replace 3 with your personal Python number comfort level).  There are some add ons (probably) that will assist in the exploration as well.
In MS-Windows I use the up-arrow key to type again the last statements.
The Blender [user] interface allows a concept of configurable Undo.
Be careful not to do undo desired typing in the text editor window
If Python in the console deletes a OS file, I would not expect Python to restore it.  Not a simple example and perhaps I have not looked for an api that performs that service.

In the Blender screen capture above a function is written at the top of some file and invoked at the bottom of the same file.  Alt-A invokes the script.  There is a button as well on the menu bar .. not shown.  The above example is just some random sample and only meant to show a function definition and call of the same function.

Console for Simple Ops

When the Python Console was used for simple operations, Undo worked in the (different) 3D View window. Image above.  Console do action.  3D View Undo action.  As a quick preview for further study please note the following.  I looked at the text in the [Info] window as a means to write the text in the [Console] window. The info windows presented the Python of my manual user actions. I may have never used the the translate function before. It is no longer critical that I remember.


You need to apply your Mirror modifier before unwrapping, otherwise the faces will overlap.


Can you paint textures in Blender 2.8x with values > 1? (I.e. HDR)

I'd like to paint them as they should be.

Not really sure what that means. Art is trickery. The only rule is, "if it looks good, it is good".

That being said, one way to do what you want would be to texture paint on an image, assign that as the color input to an Emission node, and crank the Emission node strength up to 200 or whatever.

If you feel fancy, you could add multiple textures to a single object with a Mix Shader.


Why does my obj become transparent when I import

This looks like Backface Culling, i.e. when you see the backside of a face it is invisible. This helps for example if you want to see if some face normals are pointing in the wrong direction.
To disable Backface Culling, choose the material in the Material Tab and go to Viewport Display > Settings > Backface Culling and disable it (that's Cycles, in Eeevee it's in the overall Settings of the material).
But: if your material is invisible from the outside this presumably means that the normals on this object are turned inside out. In the Viewport Overlays you can enable "Face Orientation", the outside of faces are shwon in blue, the inside in red. I guess the faces of that object will show up in red.
To correct that go into Edit Mode, hit A to select all faces, then Shift+N to Recalculate Normals. You can tick Inside here if they are still red.
If only some faces are red and some are blue and recalculating normals doesn't make them uniformly red or blue, you can select the faces you want to change, hit Alt+N to bring up the Normals menu and choose "Flip".
EDIT: As I commented above, if the material has a texture which is supposedly not black, than you might have a combination of Backface Culling and Alpha Transparency.
Your screenshot shows that hat is transparent/invisible in front of the hair but all black behind the hair. Backface Culling and Alpha Transparency are shown differently in different Viewport Shading:

In Solid view, you only see the faces without any transparency.
In Material Preview, Backface culling makes faces transparent/invisible when seen from the backside/inside, while Alpha Transparency results in alpha values of 0 shown in black, not transparent. Alpha values > 0 have no effect and will make the material look opaque.
In Rendered view, backface culling is disabled and doesn't effect the material, while Alpha Transparency will make the material more or less transparent according to the alpha value.


You'll find it in the Preview sidebar:

Shortcut 'P' is for setting the preview range, and will not influence the playback speed.
If you do not want to mess with proxies(which is the natural next step), try lowering the resolution percentage:

Nb. make sure that the project resolution is set to match your footage, by selecting a movie strip and in the menu select Movie Strip > Set render size.


How do I find the closest point on another mesh to a vertex with Python?

Using closest point on mesh.

Similarly to the answer here https://blender.stackexchange.com/a/40979/15543 code hacked together to find the closest point on mesh of    all other mesh objects in the scene to vertex[0] of the active mesh object.  Adds an Empty on the hit point.

import bpy
import bmesh
context = bpy.context
scene = context.scene

edit_obj = context.active_object
me = edit_obj.data
mesh_objects = [o for o in scene.objects if o.type == 'MESH']
bm = bmesh.new()
for sphere in mesh_objects:
    if sphere == edit_obj:
        continue
    smwi = sphere.matrix_world.inverted()

    bm.from_mesh(me)
    bm.verts.ensure_lookup_table()
    vert = bm.verts[0]
    v1 = edit_obj.matrix_world * vert.co # global face median
    local_pos = smwi * v1  # face cent in sphere local space

    (hit, loc, norm, face_index) = sphere.closest_point_on_mesh(local_pos)
    if hit:
        v2 = sphere.matrix_world * loc
        bpy.ops.object.empty_add(location=v2)
        print(sphere.name, (v2 - v1).length)
    bm.clear()


Why are the longer edges being beveled more?

Object transforms are sort of like a non-destructive "offset", which is applied on top of the raw mesh data.

When you scale (or translate, rotate, etc.) an object in object mode, the actual mesh data is not affected. You can press AltS to clear the object scale at any time and go back to the basic mesh (similarly, AltG and AltR clear location and rotation).

So when you edit an object in edit mode, the object will appear with the object transforms, but you are editing the mesh data directly (without any transforms).

To visualize this, I'll use extruding, since it's effect is a bit more obvious than beveling.

What happens in the gif:

I extrude the faces of the normal cube. As you can see, the extrusions are all the same size.
I then scale the originally unscaled cube along the X axis. The extrusions along that axis are larger, since the mesh data is being "stretched" along the X by the object scale.
I extrude the faces of the already scaled cube. Naturally, the two cubes are now roughly the same. It's sort of like I'm editing the normal unscaled cube which is then scaled up on the X each time it's displayed.
I undo the extrusion on the scaled cube and apply the scale.
By applying the object transforms to the mesh data (CtrlA), the underlying mesh data is modified according the object transforms (which are then reset).
Now extruding the no-longer-scaled cube results in even extrusions.

Note that object scale only has this effect when it's not uniform across the axes. For example, a scale of 3, 3, 3 will not stretch the cube and make bevels or extrusions skewed, as all the axes are being stretched the same amount.

This goes for modifiers too. Modifiers operate on the base mesh data before it's adjusted by the object transforms.


Texture glitches and artifacts when camera is far away?

Is the decal a separate geometry from the disk itself? If so, have a look at this article:
https://en.wikipedia.org/wiki/Z-fighting


How do I parent a single bone from a rigify metarig to a cube without it parenting the whole metarig?

Yes, I don't think you can parent an individual bone to a mesh object. You can constrain it tho, so maybe that could solve your problem.


Add pixels to an existing texture inside blender

With Compositor window: here is an example of a 1024*1024 image as backplate of a 500*500 image, that you can save as image, even without rendering.


No you don't, Blender can render on CPU. But a compatible GPU is highly recommended in most cases. You can argue that some CPUs are better than some GPUs, but a high end GPU is probably the most reasonable way to go for most people.

Since you are asking this question though, I would recommend to go with what you have for now and play around and learn the software. The GPU questions is about how much time your computer needs to render. After all you probably don't want to wait several days or month to render your animation and on the other hand, you probably don't need more than you have until you know the software quite well.


Connect points of motion tracks with (smoothed) lines

Tracking information creates a constraint.

To convert constraints into keyframes, open the constraint section of the properties window and press Constraint to f-Curve

The tracking information will be converted to keyframes, the curves for those keyframes can be displayed and manipulated on the Graph Editor.

There are a few built in tools to clean up curves in the key menu of the Graph Editor.

Here's the same motion path after applying the "Clean Keyframes" function:


You could try some Smooth Vertex to a couple of the edge loops.


I think you are experiencing two things:

1: Noise due to a low number of samples.

2: A fixed noise pattern.

The fix for the first one, is increasing the number of samples.

For the second one, change the noise seed using the timer Icon. That will make each frame have a different noise pattern.


You can do it in the top of your screen:


Animation Nodes add-on does not appear after installation

The current Animation Nodes add-on only works with Blender 2.8x which is documented in the Can't install Animation Nodes issue.

  Animation Nodes needs at least Blender 2.80

  The latest version of Animation Nodes only works with Blender 2.80. Install a newer Blender build.


How to install freestyle stroke shader script to Blender 2.8

It won't work without a bit of reverse-engineering. The modules have different names, and they have a few Blender-specific calls.. Check out your [Blender installation directory]/scripts/freestyle/styles for Blender examples.. and the Blender Freestyle API.

You've probably already been there, but the background reading makes for a good start, if you're trying to get your head round other people's code.


How to do GPU rendering on MacBook Pro 2016 (AMD Radeon Pro 460)

I recently got the MacBookPro 2017 Radeon Pro 555 2 GB + Intel HD Graphics 630 1536 MB. Having both GPU on apparently causing Cycles not to render.

Just turning on Radeon Pro 555 and turning off Intel HD Graphics and the Cycles render works.


How to create smooth surface (skin) for a model made of beams?

I think your best way forward is to either contact the producer of that model (they may have a version with smooth skin rather than the cubes and beams) or to reproduce a similar model and pose using a model created with a tool such as MakeHuman  or the Manuel Bastioni Lab add-on (although that looks to have been discontinued... however, there's a community supported branch available at https://github.com/animate1978/MB-Lab/wiki).


This chess-like pattern means transparency. You have activated Transparent in Film section of render settings.


Tetrahedron isn't proportional even though math seems to be correct

Input is not correct

Diagram illustrating only the top view looks directly onto a tri normal.  Hence in top view the verts are 120 degrees apart. It appears you have also used this for front (for example) and wrongly assumed the other verts would be sitting on 30 degrees south (120 degrees from north).  In front view the triangle we see has an edge angle (The tetrahedron dihedral angle of 70 degrees) from the base, as seen in right ortho view (LHS)
In an answer to this question have hard-coded a regular tetrahedrons coordinate points.
https://blender.stackexchange.com/a/143372/15543
seen as coords in code below. Note these coords are for a unit edge tetra containing verts at (0, 0, 0) and (0, 0, 1) and aligned such that an edge is parallel to x axis.

Coordinates for a regular tetrahedron
Expressed symmetrically as 4 points on the unit sphere, centroid
at the origin, with lower face level, the vertices are:
$$v_1 = \left(\sqrt{\frac{8}{9}},0,-\frac{1}{3}\right)$$
$$v_2 =
> \left(-\sqrt{\frac{2}{9}},\sqrt{\frac{2}{3}},-\frac{1}{3}\right)$$
$$v_3 =
> \left(-\sqrt{\frac{2}{9}},-\sqrt{\frac{2}{3}},-\frac{1}{3}\right)$$
$$v_4 = (0,0,1)$$
with the edge length of $\sqrt{\frac{8}{3}}$.

Could have changed to match these coords,  instead for example sake have:
To make the origin at the center of geometry averaged coords, and set it as the origin (0, 0, 0).
Made all the distances from origin to point unit, scaled by inverse of length.  All edges have same length..
To skin quickly used the bmesh convex hull operator.
.. and finally reported the distance and latitude and longitude from the origin point.
import bpy
from mathutils import Vector, Matrix
import bmesh
from bpy import context
from math import degrees, pi

coords = [Vector(c) for c in (
    (0, 0, 0),
    (1, 0, 0),
    (.5, 3**.5 / 2, 0),
    (.5, 1 / 3 * 3**.5 / 2, ((3**.5 / 2)**2 - (1 / 3 * 3**.5 / 2)**2)**.5))]

o = sum(coords, Vector()) / 4

print("origin", o)

me = bpy.data.meshes.new("Tetra")
me.from_pydata(coords, [], [])
me.transform(Matrix.Translation(-o))
me.update()

# all have the same distance, not unit
for v in me.vertices:
    print(v.co.length)
# scale to unit.
me.transform(Matrix.Diagonal((1 / v.co.length, ) * 3).to_4x4())
bm = bmesh.new()
bm.from_mesh(me)
bmesh.ops.convex_hull(
    bm,
    input=bm.verts,
    )
bm.to_mesh(me)
me.update()

# make the object
ob = bpy.data.objects.new("Tetra", me)
context.collection.objects.link(ob)

# calculate and report radius / lat / lon (local space)
z_axis = Vector((0, 0, 1)) # north
y_axis = Vector((0, -1, 0)) # 0 longitude
for v in bm.verts:
    lat = pi / 2 - z_axis.angle(v.co)
    if v.co.xy.length < 1e-7:
        lon = 0
    else:
        lon =  y_axis.xy.angle_signed(v.co.xy)
    print(v.co.length, degrees(lat), degrees(lon))

Output, spherical coordinates (in degrees)
Radius, Latitude, Longitude
----------------------------

0.9999999701976772 -19.471218922405377 60.000001669652114
0.9999999701976772 -19.471218922405377 -60.000001669652114
0.9999999478459345 -19.47122575259455 -180.00000500895632
1.0 90.0 0.0   # north pole.

In both this version and yours the distance from the origin to vert is 1, however your input latitudes are not consistent with keeping equilateral triangle faces.
Result above suggest that for a regular tetrahedron with apex at north pole, the three other points are distributed 120 degrees of longitude apart on latitude 19.47 degrees south.


What is my PC Capable of Doing in Blender?

Well, First of all, your PC is perfectly fine for learning Blender. You can do everything and anything with it.

Even an EEEPC with 2x1.6 ghz and 2GB ram is enough to do that. You might want to run it under Linux but that's not a problem.

You can test the performance easily. Just make a cube with 10k faces and duplicate it until rotating gets sluggish. Sluggish means: stay below that. You'll find your threshold in the upper right. You can also hit SPACE and type redraw timer. That'll tell you how long Blender takes to redraw the screen with its current content.

Rendering: also, just make test scenes and find the stuff you still find bearable.

There's cool low poly stuff out there. Blender is also very cool for cutout animation. Check Monty Python and Terry Gilliam for that (well, or South Park). Watch a game walkthrough like Limbo, check a movie like Renaissance and you can see that it doesn't take fancy lighting, 50 million polygons and lots of reflections to create atmosphere. ASDFmovie is very successfull, too.

You could do a full 90 minute movie with your machine and the rendering wouldn't be excessively long as long as you don't try to do Pixar and know enough tricks. If the story is great and the acting is decent and the camera work is good, simplified visuals can even be a strength.

If you are frustrated with your PC being small, you are actually frustrated with your current income. The PC is only a symptom. That would be subject to strategic planning and lots of learning and practicing and daily focus on a course that financially makes sense and is sustainable.


Change the main camera for your scene in properties panel:


Why does my armature deform incorrectly?

Here is an answer to your problem, it is basic rigging problem, you should follow tutorials on this topic:


control the rotation of the particle instance to face to camera

Thanks CG Boost: https://www.youtube.com/watch?v=aLVodLos41Q

Here is a summary:

Create an Empty that you parent to your camera but placed far away behind it on the local Z axis. This will be used to lock the particle source orientation that will "look" at that general direction

place the source particle object somewhere in the middle of where most particles will be (in the middle of the forest)
Add a Track to Constraint to the source particle object, use the empty behind the camera as target
Add a Limit Rotation constraint to the same object to keep it strait.

This way, generated particles should all face the general direction of the camera as long as the empty is far enough behind it.

Also if you have trouble with your source object in the middle of your scene, just put it on a difference scene along with a linked duplicate of the camera.


Some settings in properties > world are missing?

This is because you are using Cycles as your render engine.

Here is the correct wiki page.

Those settings you saw are only there when Blender Render (also known as Blender Internal or BI) is selected as the active render engine in the Info panel > Header:

Note you can do everything that you could do using those settings in BI in Cycles, however the process for setting some of the things up is different in Cycles.

The number of samples is controlled in Properties > Render settings > Sampling:

Note that samples behave differently in cycles and BI, see this question.
AO in cycles is always added, if you want to multiply you must enable the AO pass in Render Layers > Passes:

And then multiply it with your render in the compositor:

The world background color can be set either from the world settings or the world nodes:

Both settings are the same, setting one sets the other. If you want sky textures or gradients, use Texture and Mapping nodes.


How do I remove vertex from vertex groups to edit hair particle system?

Removing vertices is fairly straightforward; select the verts and click the "Remove" button right next to "Assign" while your group is highlighted.

If the problem is that the changes aren't showing up then you can usually rectify this by changing the "Seed" input (seen below) to force an update.

Aside from that, make sure you aren't applying any Particlesystem modifiers as that will finalise any changes you make. If none of these solve your problem then I don't think I fully understand what the problem is, perhaps you could be more specific

[EDIT] Blender doesn't allow retroactive edits to particle systems that have been edited in "Particle Edit". However there are tricks to overcome this issue:

You can control many aspects of the hair including length and density using weight painting as seen in the "Vertex Groups" section (Verts in a groups are assigned a uniform weight of 100% by default which can give unrealistic results)
Your image has strand of hair grouped into superstrands which each end in a point, all of these things can be achieved with the "Children" panel which appears when you tick "Advanced".
If you wish to point all the strands downwards you can give them an initial velocity or just give them physics and let a simulation handle it (I personally think this is more effort than it's worth)

Always make sure you've finalised your particle settings before you go into Particle Edit


Convert animation node result into editable object

Most of the time you can simply copy the output of Animation Nodes in the viewport and continue to work on that copy. The node tree that created the object can be deactivated.


You will find it here:

action=bpy.data.actions['yourAction']
#or
action=bpy.data.objects['yourObject'].animation_data.action
#
action.fcurves[fcurve_index].keyframe_points[kf_index].left_handle
action.fcurves[fcurve_index].keyframe_points[kf_index].right_handle

You can easily explore blender's data structures with the outliner using the datablocks option and the interactive python console using autocompletion (Ctrl+Space).

If you hover over properties in the editor with python tooltips enabled it often will show you the path to the property.

Hint:

If the object has not been animated yet and thus animation_data is None, use the object's method animation_data_create to create it.

Afterwards assign an existing action to animation_data.action or create a new one:

action=bpy.data.actions.new('Your Name')

Note to the developers of blender:

In this case the path shown in the graph editor is abbreviated bpy.data.objects...left_handle and it is not possible to right click -> copy data path. So the hint shown is kind of useless.


live unwrap missing form 3d viewport options

It seems like there are 2 Live Unwrap.
The first one is in the Options or in the N panel > Tool > Options, it will automatically refresh the UV map whenever you change the seams of the object:

The other one in the UV Editor. According to the docs, it "continuously unwraps the selected UV islands while transforming pinned vertices":


Object in animation not rotating as expected

If the final keyframes put the object back in the starting position, at 0°,
what happens is (for the first video):
- rotation starts in the required direction, from 0° to 180°
- on reaching the 180° keyframe, the rotation starts for the second part, rotating from 180° to 0°, not from 180° to 360° (which is what you wanted, but didn't specify).

Adding an extra keyframe at 270°, only means that the object will continue rotating until it reaches the 270°, and then go back to 0°.

For blender, 0° is not the same position as 360°, if you want to get a full rotation, your end position must be 360°.


Pair Of Pro Duo for a Blender workstation

I have a Pro Duo and I don't see why two of them can't work together. With 2 cards, you'll have access to 4 compute devices since each card has 2 GPUs.

Checklist:

These cards a really long, make sure your case can fit them.
These cards are 250W each, so make sure you have a 750Watt+ power supply. Also, they require a set of 6+8pin PCIE power connectors for each GPU.

The rendering performance will scale very linearly with additional GPUs. But keep in mind that you are still limited to 16GB of video memory(per GPU), not the combined total video memory (64GB).


How can I create a chaotic structure from a triangled mesh

If i understood the question

Press Shift+A Add cube.

In edit mode press W subdivide

Press F6 and play with the settings with Fractal and Along Normal

To make the faces from Quad to triangulate In Edit mode Press Ctrl+T or In edit mode -> Mesh -> Faces -> Triangulate faces.


How do I create this material in cycles (2.79)?

I'm not sure the materials have anything particular, it looks like normal plastic, like a Diffuse mixed with a Glossy, with various values, plus perhaps Fresnel and SSS. It seems to me that what you think comes from the material may actually comes from the work with lighting, so maybe you should dig that aspect?


Blender 2.8 - all non-rendering objects gone from viewport but still exist

Did you unselect the Show Overlays button


How to find image coordinates of the rendered vertex?

This script gives projected the 2D pixel coordinate from a 3D world-space location.

The (0, 0) origin is the bottom left of the image(common for math, OpenGL and Blender in general).
A negative Z return value means the point is behind the camera:

Example:
# Test the function using the active object (which must be a camera)
# and the 3D cursor as the location to find.
import bpy
import bpy_extras

scene = bpy.context.scene
obj = bpy.context.object
co = bpy.context.scene.cursor_location

co_2d = bpy_extras.object_utils.world_to_camera_view(scene, obj, co)
print("2D Coords:", co_2d)

# If you want pixel coords
render_scale = scene.render.resolution_percentage / 100
render_size = (
    int(scene.render.resolution_x * render_scale),
    int(scene.render.resolution_y * render_scale),
)
print("Pixel Coords:", (
      round(co_2d.x * render_size[0]),
      round(co_2d.y * render_size[1]),
))

See the Python Source-Code if you're interested in exactly how this works.


How can you make the mesh in a 3D view a bit transparent?

You want to set your background image like this:

Set it to front and give it some opacity.

Transparent mesh you can only make in Blender Internal in GLSL shaded viewport by setting the material Z Transparency Alpha or by giving it a transparent texture.


Adjust the reference angle of the 2D rotation stabilizer

Ok I answer my own question :)

The reference angle of the rotation stabilizer is based on the angle of the points at frame 0 of the footage, regardless of the Start/End of the project. This angle will be the reference to maintain for the rest of the footage.

Therefore, to adjust the offset angle of the stabilizer, simply put the marker used for rotation at a different location at frame 0 only, then keep the rest of the track and go observe the results in the middle of your footage.


As generally we select the object we want to edit, and then operate, this seems a non-well implemented function.
This is the fastest way I've found:
Box select all the objects in the graph editor list, press numpad + three times (until every channel is expanded, press - to collapse).
Select the point you want to edit and press shift H to hide everything else (Alt H to unhide).
The corresponding channel will be the only one with the eye icon active.


This is a rather common issue with this technique. what is happening:
In order to understand how "bumpy" something with completely different geometry is, blender uses a "third model" called a "cage". (when it's unchecked, the cage just uses the selected model to make it, with the solidify modifier I presume) the cage shoots rays from itself to both the low and high poly geometry, and compares them both to itself. This is a rudimentary technique though, and fails in some specific cases: notably in acute angles when the cage passes through some geometry that's closer to it than the intended geometry. in a visual sense, this is a simplification, where the blue line is the cage.

(in reality, there's no extra face at the top, or if there is, there's some more geometry smoothing it out a little, and probably extending your issue down the legs a bit because of how the cage contracts at sharp, concave corners!)
notice how parts of the cage will see the "backside" of the model first. Basically, you want the cage to be as small as possible while still providing good results. shrink that .3 to half or less, unless the distance between the sculpted and low poly geometry differ that much- and at that point you should probably consider shrink wrapping the lowpoly to fit the high poly geometry more closely. normals are for making glancing and stark shadows better, not replacing proper geometric shapes big enough to add very noticeable bumps to a silhouette.
use the measurement tool and draw a .3m line on the pants, and visualize how big that cage is- that should assist you in finding the right cage size!


Subtract tool in Weight Paint doesnt work on some specific points

You selected the face mask for weight painting. In this mode you can only tweak faces which have been previously selected in edit-mode.
Click on this icon :


Not sure exactly what you want to do, or how you plan to use this information, but depending on you purpose Knife Project tool may do what you want.

If you need to generate actual geometry from this, one way to obtain a bi-dimensional projection from a shape onto another is using the Knife Project tool.

For this to work the projection receiving object must explicitly be of mesh type. Also the objects to be projected must b non manifold, or open geometries for a projection to be found. If you want to project all edges (visible and invisible) then ideally you would have only a "skeleton" composed of edges.

Proceed by entering Edit Mode on all your cubes or whatever geometries you choose, select everything and then erase all faces with X > Only Faces.

Exit edit mode, select all cutting objects, and in the end Shift-Select the plane you wish to project onto, so that all objects remain selected, but the plane is the active one.

Without deselecting enter Edit Mode on the plane objects, switch to User Perspective if desired by pressing Numpad 5, adjust the perspective as desired (the Knife Project operator is view dependent so current viewport position/aperture matters), then invoke Knife Project from the Spacebar-Menu.

Have in mind that this will invariably produce bad topology


Can you distribute an Eevee render job over tiles for high res renders?

Blender currently doesn't support tiling in Eevee, however as stated in Rich Sedman comment, this can be achieved by tinkering with the focal length, Shift X, and Shift Y. First, you will need to figure out how many tiles you want. Try to figure out what is the maximum resolution you can render in your project, it is usually not much higher than the maximum resolution supported by your graphics card, but it doesn't seem to be capped at it anymore. Divide the resolution of the final image by the number of tiles on each axis so it is smaller than or equal to the maximum resolution you can render, let's call this number n. For example, if I want a final image with a resolution of 20000 by 11250 and the maximum resolution I can render is 8000 by 4500 I can use 3 as n since 20000/3 = 6666.66... ≤ 8000 and 11250/3 = 3750 ≤ 4500.
Now you have to change the lens unit to Field of View and divide your focal length by n.
Now you have to divide the sensor size by n, you could use depth of field but different depths of field cause different distortions as Jachym Michal pointed out – thanks Jacym :).

Now you have to set up the Shift X and Shift Y. If the image is wider than it is tall the first Shift X value is n/2 - 0.5 times -1 (just add a minus in front of the number) if it is taller than it is wide you must multiply the value by the width divided by the height e.g. if the aspect ratio is 9:16 you should multiply the values by 9/16 which is 0.5625, keyframe the Shift X value. Now you need to set up the last Shift X value of this row, to do this, go to the frame n (assuming the first keyframe was on frame 1), and enter the new Shift X value, which is the same value as before but not negative and keyframe it again. It should look something like this:

Now duplicate these keyframes n - 1 times, so the camera will go from the left to right n times. It should look something like this:

Now it's time to set the Shift Y values, the values should be n/2 -0.5, just like before. If the image is wider than it's tall you must multiply the value by the image height divided by the width e.g. if the aspect ratio is 16:9 you should multiply the values by 9/16 which is 0.5625. Where the values were negative in Shift X they should be positive and vice-versa. So go to frame 1 and set the Shift Y to n/2 -0.5, multiply it by the height divided by the width if the image is wider than it is tall, and keyframe it. Now go to the frame where the next Shift X keyframe is and keyframe the Shift Y again, this will make the Shift Y remain constant while the Shift X goes from left to right. Now advance one keyframe so the Shift X goes back to the initial value, and subtract n/2 - 0.5 if the image is wider than it's tall multiply it by the height divided by the width of the image and keyframe it. Now go to the next keyframe (the default key for this is the arrow up), keyframe the Shift Y value again (like on the last row, it will keep the value of the last keyframe, so the Shift Y will remain constant as the Shift X scans through this row). Repeat this process for all the rows so you have an n by n grid of tiles. Now change the interpolation to linear by selecting all the keyframes and right-clicking them and then choosing linear under interpolation. It should end looking something like this:

Now you change the end frame to the total number of tiles or n². You will also need to change the resolution to your original resolution divided by n on both width and height. Render an animation rather than a still frame.
Now you have a sequence of images that when read from left to right and top to bottom with a limit of n images per row will create the final image (that's why it is important that the Shift X starts negative and Shift Y starts positive). To create the final image you can use a variety of pieces of software, such as image editors, however, due to the large dimensions of the images you can run into memory issues with them, so you should probably use a free and open-source software called ImageMagick. To do this open a terminal on the folder with the images you rendered and run magick montage -mode concatenate -tile 3x *.png final-image.png replacing the 3 in "3x" by n and the .png in "*.png" by the format you are using if it's not PNG. This will take a while and can make your computer irresponsive depending on the size of the final image. If you feel like throwing 75 euros at the problem or you don't mind a bunch of demo marks on the final image, there is a little piece of software called Very Large Image Joiner you can use, it will make the process way faster and will use almost no RAM, but it's 75 euros if you don't want those demo marks.


location info of objects not changing in any frame for physics simulation (but their position changes)

I found the answer to my question in case someone else needs it, global translation can be accessed as follows.

bpy.data.objects['obj'].matrix_world.translation


Hollow object with Boolean filling up with ocean modifier?

So, I didn't change anything, but I clicked on and off all the render icons for the booleans and now it works. Either something got left off that I didn't realize or it fixed whatever bug was occurring. – Remington Jul 18 at 19:01


How do I set up freestyle to exclude outer lines?

Here is how you do it...

The logic is: "Crease" AND NOT "External Contour"

You get the NOT by using the X on the side.

Do you need more explanations about this please tell.


Smoke Animation Lengthened past 250 frames

The duration of all simulations (smoke, physics, particles, cloth, rigid body, etc) depends on the start an end frame settings for the simulation's cache.

For fire and smoke, select the smoke domain, then look for the cache settings of the simulation. By default the cache goes from 1 to 250 frames, but you can make the start and end frames make it whatever you want.


Well I think I might see your problem. If you are trying to view your textures through the 3D Viewport without the need to render the scene:
There is a button that should have a white ball with up and down arrows on it aka "Viewport Shading" is its name and it sits to the right of "Object Mode" button in which that button also has up and down arrows on it. Here is a pic:

The picture you see above is the editor or "3D View Editor". Now in this picture you will see that white ball im talking about next to the "Object Mode" button. Now click that ball in your blender "3D View Editor" and set it from Solid to Texture or if that does not work set from Texture or Solid to Material. If all else fails then try and get a recent version of blender.
Let me know if this does not help you in any way! :D


Expand selection (Ctrl +) to the specified direction in edit mode?

If you've selected a pair of elements which bear some logical relation to one another ( e.g. along a loop, along a ring, every other along a ring ) then Select Next Active (CtrlShiftNumpad+) makes a pretty good job of carrying on the sequence you started.


Cylces does have the bad habit of stretching the pixels past the edges of the image.

One quick solution is editing your image and adding a black or transparent border all around. (All you need is one pixel wide ...).

Cycles will then repeat that border...

Or you can create a file that is a black border around a transparent image and use that as a factor on a mix node to create a color frame past your image:

or a different shader:


Transfer particle cache from one file to another

I was investigating this recently and had to resort to reading the source code to figure this out (blender/source/blender/blenkernel/intern/pointcache.c and ptcache_filename()).  I was never able to find any documentation for the various idiosyncrasies.

When you create a Disk cache the files end up being named in the pattern %s_%06d_%02d.bphys.  The %s is a prefix; the %06d is a frame number;  and the final %02d is the index number.  For example: 537068657265_000231_00.bphys .  It turns out that 537068657265 is what happens when you convert the ASCII for "Sphere" to hexadecimal.

However, if you double-click on the item in the list of caches and give it a name that will be used as the prefix on the filename instead.  The fact that this defaults to blank makes it easy to overlook the fact that you can give the cache a name instead of using the hex-encoded name of the object the particle system lives on.

It is possible to use these files as an External cache, but it takes an extra step.  You provide the directory containing the files as the File Path, then you have to rename the cache item in the list above it to match the prefix of the files (for example 537068657265) .  If you do not rename the cache item from the default blank then it will look for files named like _000231_00.bphys (a blank prefix) and since they do not exist you get the No valid data to read! error message.

Alternately, you can rename all the files to have a blank prefix using a shell script like

for i in *.bphys; do
    o=${i#537068657265}
    mv $i $o
done


Here is how to composite your scene. This may also resolve your other question: Posterized shadow pass in Cycles?

Since you only use Glossy and Diffuse shaders, we only need the glossy and diffuse passes enabled in the render passes.

What you are experiencing are not fireflies. These artefacts will not be visible after the correct compositing.

The reason for that is the premultiplication of very transparent pixels after anti-aliasing.

In some edge pixels the popcorn overlaps the box. In a pixel which the box covers just slightly and which is mainly filled by a popcorn the glossy color of the box will be close to 0. The Glossy is going to be multiplied by the Glossy Color. Hence it needs to be unpremultiplied. There are plenty of tutorials on premultiplication and unpremultiplication in compositing and why they are important. Here is an explanation of the technical background. Color correction also only works with unpremultiplied data. Your scene is fine.


Can i open and edit reStructedText (.RST) files with Blender?

Blender can open any text file in its text editor. The file browser will not show the .rst files if you have filtering turned on, click the little funnel icon to turn filtering on/off.


Eevee
For this of kind lightning you have to add Irradiance Volume object and under Render Properties > Indirect Lightning > Bake Indirect Lightning.

Notes:

your dimensions of object is huge (chair 40 m) ... you can select all and scale it down or go to Scene Properties > Units and change it to something like 0.02 to result with something closer to reality
usually is used Sun light type (but I see it penetrates walls too much and I don't know how to avoid) always helps to ad Solidify modifier to walls
to avoid unwanted volumetric penetration change Render Properties > Volumetrics > Start to 4 End to 10, Distribution 0.8

Cycles
Same setup (irradiance is not used off course) ...

If you need brighter interior, there is more things you can try, but just increasing light Strength seems to be enough.


You are in Edit mode of the mesh. If you want to convert Grease Pencil layer into curves / mesh you need to exit Edit mode of any other object. Or you can use Bsurface addon to convert GP drawing into the mesh right in Edit mode on the fly.

Simple Converting Grease Pencil drawing

Once something is drawn on the mesh, exit Edit mode of the mesh (the Edit mode of Grease Pencil may be left on) and choose Convert in the Toolshelf > Grease Pencil. You'll have options to choose that you want it to convert to - Path, Bezier Curve or Polygon Curve.

Converting sketches to geometry
Drawing with Grease Pencil

Convert Grease Pencil in Edit mode

Use Bsurfaces addon to use Grease Pencil as retopo tool and convert it into mesh surface while in Edit mode.
After enabling addon create some simple mesh, enter Edit mode and delete its vertices. After that, draw with Grease Pencil and once finished, in the Toolshelf > Tools > BSurfaces rollout press Add Surface to convert your strokes to surface.

The Bsurface needs either 2 Grease Pencil strokes (shown above) or one stroke and one selection of geometry (below). To make strokes drawn with Grease Pencil to connect to already existing surface draw a stroke, select the edge loop of that surface which is the nearest to the stroke and then proceed to Add Surface.

Watch the tutorial on more techniques about using this functionality.


An updated 2.8 answer can be found here

In both edit mode and object mode; press N to open the Properties. Scroll down to the 3D cursor. There are three number fields one each for the X, Y, and Z axes.
For finer control use Alt or Ctrl while dragging the mouse. Also see the Manual.

Note the coordinates are always in Global, how the transform orientation is set makes no difference.


If i understood your question. This is the answer
Add a plane -- Add texture by uv mapping
Add a array modifier & curve modifier
In array Fit curve
And in Curve modifier -- object -- bezier curve
Click the bezier curve now and go to edit mode
and extrude and u will get the road with the path


scaling a circular shape while keeping its thickness

Add a curve with desired shape and set its orgin point as shown below. Then add the one segment of the model in the same place where the curve origin point is.
Add the Curve and Array Modifiers to the model segment. Set the proper array count.

Now scaling the curve and increasing the array count, you have a bigger object while keeping its thickness.


If i understood the question here are steps follow it

Import the SVG file
Convert the curve to mesh by press Alt + C and select curve from Mesh
Go to edit mode Press U and select Project from view (Bounds)
Make a new window as node editor and connect the image.
Assign the material to the mesh.


Here is the solution that I came up with:

1: These nodes are a fresnel node with other nodes to disperse it

The second group is a color ramp to blend in the fresnel to the rest of the material
This is a mix shader to add it to the rest of the material


Can I use existing curves with the "Stroke method -> Curve" in "Texture Paint"?

Stroke method curves, though stored and named for recall, do not function as regular curve objects or can they be converted to regular curve objects. This is actually something I asked for as a feature request - that they be able to be converted to and from stroke curves just like mesh objects can be converted to curves and back again.


Final rendering add reflection on materials

You most likely have lights in the scene that are hidden in the viewport. Go to the outliner, enable the render visibillity buttons by opening the filter menu in the top right and check if any of the disabled lights are enabled in the render.


Make sure Global Undo is enabled.
For 2.8x and 2.9.
Edit > User preferences > System > Memory & Limits: Global Undo

For 2.7x use  CtrlAltU > User preferences > Editing > Undo:

That panel is called the redo panel, because when you change a setting on it, blender actually redoes the previous operator with the new settings.
If blender can't undo the previous operator first, running it again will add it's effect on top of the result of the previous operator (which is not the desired effect at all).
So this panel is disabled when undo is not available.


How can I reset the cursor in the UV Editor with Python?

It is possible to adjust cursor from another context with the following snippet:

import bpy
ob = bpy.context.active_object
for area in bpy.context.screen.areas:
    if area.type == 'IMAGE_EDITOR':   #find the UVeditor
        cursor = area.spaces.active.cursor_location   # get cursor location
        area.spaces.active.cursor_location.x = 0.5*1024;
        area.spaces.active.cursor_location.y = 0.5*1024;

Because you want to normalize in the (0.0,1.0) interval you will have to actually multiply this with the texture size (in my example hardcoded 1024 number).


Changing a material effects both text objects

Most likely this is because both text objects are assigned the same material (this could happen if you duplicated one from the other).  If a material (or any other datablock, i.e. particle system, image, etc.) has multiple users it will display the number of users in a small box to the right of the material name.  To make a single user copy of the material simply click on that box.

The material "Material" has 2 users, clicking on the 2 box will create a new material with all the same properties and name it "Material.000".  Changing this new material will not affect the original material "Material".


Baking multiple materials into one texture

To make this work properly, you need to have an active Image Texture with your new image file in each material you have in this model. Basically, what you have to do now, is to CTRL+C on Image Texture in Everything material, visit each other material and CTRL+V. Then baking will give you appropriate result.


How to add edge in a cylinder so that only the end can be scaled?

You can either add a loop cut, or cut the cylinder with the knife tool, or move your current end and extrude another edge to make it longer.

CtrlR is the keyboard shortcut for adding a loopcut.

To add a loop cut simply press CtrlR then LMB  (to confirm the count of one new edge) then move the edge down to the end and LMB  again to confirm the spot.

K is for the knife tool.

To use the knife tool you are going to want to press
Z after you started the knife tool, to enable "Cut through." Then after you made the cut press Enter or Space to confirm and leave the knife tool.

To extrude a new edge, first select your current end now press GG for the edge slide tool, move the end to where the taper starts.

A little trick to get the new extrusion along the same normal, press F to create a face. From that face blender will be able to continue the next extrusion along the exact same angle.

Now press E to extrude a new edge, simply LMB  when it is in the correct spot.


Why does my mesh get distorted when switching from edit to object mode?

I duplicated, Z-grabbed and separated a "shin-loop" from a Make Human,  built it into a boot shape (I wanted to keep the vertex groups for weight painting). When I changed to object mode the mesh completely distorted.

Looking at the shape keys under Mesh I unticked the Relative check box - this seems to have worked.


There are several issues with your model that prevent proper results.

You have inverted normal in your model - Unrelated to texturing but can cause issues, fix it by ticking Flip in the Screw modifier
Your curve object has unnaplied transformations (more importantly scale) and has an offcentered origin point, both of which will negatively affect your texture coordinates and make them harder to work with. Apply scale and properly place the center relative to the object.
You inconsistently use Vector type of mapping in Vector Mapping nodes for textures, all should be set to Texture
You use duplicate Texture Coordinates Vector mapping and Wave texture nodes which are not necessary
Your shader node setup also seems far too convoluted, and looks like it could be simplified.

Here is my proposed node setup to achieve an identical result. Not sure exactly what you final result should look like, you may need to adjust the color ramp node to suit your liking. The Modulo node will control the tiling size.


How can i fix subdivision surface + bevel modifier issue with modifiers

Try meshing your object like this:

See how are the edges/faces here?
Is a little bit different.


How do i remove the the default HDRI in Blender 2.8 eevee?

There shouldn't be any HDRI applied when creating a new project. You can set your own HDRI or change an existing one in the world tab. If you want to remove an existing HDRI you delete the nodes connected to the color socket or change the texture to one you like better.

Click on the button behind the color field.

Select environment texture from the dropdown. This will allow you to select an image that is used as background.

Click on Vector and select the Mapping node. This allows you to change the orientation of the HDRI.

Click on the Vector socket of the Mapping node and select Generated from the dropdown. You select and .hdr or .exr image to light your scene

Example of how it could look like.


Copy pasted Body and armature not rendering

Try appending or linking the newer versions of the rig into the scene instead of copying and pasting. Copying and pasting may cause naming conflicts on certain nodes, or duplication of unwanted elements.

Under the File menu at the top of the screen, you'll find both the Append and the Link option. They are similar in that they both allow you to take the content of an external source file and make that content appear in your current scene. The main difference is that with an append, the contents of what are transferred are physically copied into your scene and become new, independent versions of those contents, whereas with linking, only a reference to the original content is made present, and as such, it cannot be edited outside of the original source file.

I recommend appending for now because linking is a bit complicated in some ways, and often requires extra steps, including the creating of a proxy rig afterwards. By appending, you don't have to deal with that.

If you do decide to append, though, before you do, consider putting the rig you want copied into a new collection in your current scene first, and give the collection a unique name that you can easily identify. Make sure ONLY the rig itself and its deform mesh is in this new collection, and no lights or cameras or any other extras. This way, when you do the append, and are asked for the content to be appended, you can simply choose this collection from the list of available contents, and in this  way, easily ensure that you get copies of only what you want added to the scene.

One final thing. Save your current scene before beginning the append, but save it as a new version of the current file separately also, and append from the new version of the file only, not your current one. Blender doesn't seem to like it when you append from the same file that is open at the moment.


Is it possible to achieve Buffalo Plaid Texture with Checker Node?

This one will allow you to change size and any of the three colors with only one node.

EDIT:

I've improved this method so it's now possible to group it and use it as just one node with all the controls:

And this is what is grouped:

What is basically doing is generating black-gray-white pattern, assign RGB values to these colors by Color Ramp than separating them and allow to change them.

Blend file:

First Answer:

I don't know if this is the simplest way, but you can make something like this using two Wave Textures.

Value node controls checker size and Color Ramp is used to change colors.


From that example, you seem to be looking for kitbashes/models. Kitbashes are essentially prebuilt parts that are typically focused around a specific style or theme such as industrial, sci-fi, gothic etc. These can greatly speed up your workflow. You can try poking around for free ones, but unfortunately, most of the quality kitbash/models need to be paid for.

Another thing of note: you still need modelling experience to use them. I'm not aware of any addon/program that will essentially build an entire model for you.

One great source of free models is the Sketchup 3D Warehouse. You're going to need a third-party program to convert the SketchUp files to importable ones for Blender. i3DConverter works for that.


How to scale same material on two different objects separately without affecting the other?

If you have to use the same material, the most straightforward way would be to use the UV texture space,and give each object a UV map with its own transform (including scale)... but this is a 2D space.. (below)

For 3D, you can use the Generated texture space, and manipulating that on the objects, using ShiftT > S (optionally constraining withXY or Z). (below)

Or, you can use the objects' Pass Indices (set in the Object Properties > Relations panel) to discriminate between objects. In the node tree, That number can be picked up using an Object Info node > Object Index, and used any way you like.


Convert particle system wont work properly : it modifies the geometry

When the particles are converted, they aquire their size as particle, so generally much smaller than the original object.
From that, if the displacement is set to "global" coordinates, the mapping of the object on the voronoi texture becomes very small and so has few variations.
As solution, set the displacement to "local" coordinates and the mapping will be equivalent between your original objects and the converted particles.

Alternatively, you can change (lower) the voronoi texture size once the particles are converted.


Emit particles from boolean intersection

Easiest way would be to just select all faces with the yellow material in Edit Mode, there is a button under the Material Slot list to do that, and duplicate them.

Separate those duplicate faces into a new object and add a particle system to it. You can make the Emitter invisible to rendering, and also make it wireframe in the viewport.

Another way is to use Vertex Groups. Just select the yellow faces as above and create a new Vertex Group to which you add the selected vertex. You can then use that vertex group to influence the particle emission by assigning it ti the Density field in the Vertex Groups section under the Particle system settings.

Have in mind that Vertex Groups are not an unequivocal way to define face selections, so some "bleeding" is expected if you select all vertex.

Also see Assign Particle System to parts of a mesh


First you must go to the dopesheet, then select the text you want to animate. In the dopesheet you see four keyframes, those keyframes you have to change. So go with the timeline (the green line in the dopesheet) to the first keyframe, the values of the scale is in yellow (that means it is keyframed) so change the x value to .5 and click on I to insert a keyframe (make sure you are in the 3D view, or above the value when you hit the I. Go with the timeline to the next keyframe, you are on the right frame if the values from the scale are yellow and repeat everything.


Properties Editor: How to change short to int for "Pass index" button in Relations?

Instructions:

1) Read useful info on following websites:
RNA, Property, DataApi.

2) On this websites blender guys give description how they are creating their gui. Description is not very easy to understand, but following sentences gave me an idea, what is wrong, when I try to convert button from short to int.

  More later about saving and loading, what we have to be careful about in the DNA files is alignment. For compatibility between different compilers and platforms, all members must be aligned correctly. The general rule is that if the size of some member variable is n, it must be defined starting at a location in the struct that is a multiple of n. For example ints must be defined at locations that are a multiple of 4. Structs must be created at locations that are a multiple of 8. If for some reason this does not work out, padding variables can be added in between (usually named pad, pad1, ..). Alignment errors in DNA structs will be printed during compilation.

This is exactly the error, which I was getting, when building the program with my changes.

  Align 4 error (32 bit) in struct: Object col[4] (add 2 padding bytes)

Then I have noticed that all over the code in the "DNA_object_types.h" developers were adding padding variables (void pad, char pad1, char pad2[3]...) for the aligning of the memory.

3) So when you create additional property or variable in DNA, you should align it properly. More on alignment you can find in the file "dna_genfile.c".

  IMPORTANT:

  do not use #defines in structs for array lengths, this cannot be read by the dna functions
  do not use uint, but unsigned int instead, ushort and ulong are allowed
  only use a long in Blender if you want this to be the size of a pointer. so it is 32 bits or 64 bits, dependent at the cpu architecture
  chars are always unsigned
  alignment of variables has to be done in such a way, that any system does not create 'padding' (gaps) in structures. So make sure that:

  short: 2 aligned
  int: 4 aligned
  float: 4 aligned
  double: 8 aligned
  long: 8 aligned
  struct: 8 aligned
  the sdna functions have several error prints builtin, always check blender running from a console.

After I have added padding variable, "Pass index" was finally converted from short to int.


A suggestion is to use the Screw modifier for the railing walls & keep the array for the steps. You can control the height of the screw with an empty and the diameter either by scaling in object or edit mode.


How can I access focal length of active camera, render resolution using animation nodes most directly?

I don't know of a way to directly access the current Scene's properties in Animations nodes but you can circumvent that with custom properties
.

Add 2 custom properties to your camera and drive them using your resolution. Example with the resolution X :

Now you can access theses properties in AN using an "Attribute Input" node.

Note : To access the "Camera" part of the Camera "Object", the path is obj.data

So : the focal lens is accessed with data.lens


All you need is to add some strip at the bottom of the sequencer.

To add a solid color add a Effect Strip->Color and place it under your video strip.


How to change the size of the particles over distance traveled

Use the method explained here. In the file you share the problem is probably that your gradient is vertical when it should be horizontal:


How to create a Eye rig with cornea deformation

I tried with the Warp modifier but it seems hard to make it work with a complexe topology, a Lattice modifier seems much more convenient:

First remove all the Copy Transforms constraints of your 3 bones (not sure why you want those).
In Pose mode, close the eyelid a bit so that you'll be able to test the modifier when the eyes are closed.
Create a lattice in front of your eye: shiftA > Lattice. Scale it down.
Subdivide it a bit, for example U and W values > 7, and make it flat on the Y axis with a V value of 1.
Give your eyelid mesh a Lattice modifier. Choose the lattice as Object.
Select your lattice, go in Edit mode, select the central vertices and make it a bit round, use the Proportional Editing / Sphere falloff type to help you.
Parent the lattice to the eye bone: ctrlP > Bone.
Now when you'll move the bone, the transformation of the eyelid will follow.
If necessary make some adjustments to the lattice in Edit mode, or scale it up or down in Object mode, play with the modifier Strength (and create keyframes if the influence changes through time). You can also limit the lattice influence on only a part of the eyelid mesh (with a vertex group that you'll set in the Vertex Group field of the modifier), etc...


How to turn object into this for sculpting?

Without additional information, I would bet on "smooth shading" set on the cube (tool shelf on the left of the 3d view), it is not a 'different' cube.
It seems also having a subsurface modifier ('simple' method) on.
Try to switch back and forth between smooth and flat and you'll see the shading difference.
hope it helps


You first need to correctly realign the object's orientation.
To realign the object orientation with its face orientation, select a face of your object in Edit mode, create a custom orientation in the Transform Orientations panel:

In the Options panel (top right of 3D view) activate Transform > Affect Only > Origins:

In the header menu click on Object > Transform > Align To Transform Orientation:

Deactivate Only Origins, do an AltR, now your cylinder is aligned with the Global orientation again, it should be easy to align with the other cylinder.


How to move render to the left for space for text?

You can use the Transform node, for example:


Hide vertex colors in vertex painting view

In vertex paint mode, simply change the rendering to either look dev or rendered:


How to view Environment texture in Solid / Texture / Material view?

In the N panel of the 3D View, check World Background under Display.

Note: This won't change the shading of the objects, like if it were actually rendered, but just show you what the texture looks like.


Action not applying fully when importing model to Three.js

I should have mentioned this was using Blender 2.80. Some further digging found this issue on the exporter: https://github.com/KhronosGroup/glTF-Blender-IO/issues/439

Having upgraded to Blender 2.81, which includes the fix for this issue, my model now imports correctly with the animation as I expected.


I've got some results using this method: emission + inverted ColorRamp.

Using Eevee + Bloom the result looks immediately better, but I still have to fine-tune it for cycles. Problem is that either the light emitted is too weak or the bulb gets too white. I've also tried Filmic Blender with similar results.


In Cycles you can do this by using the Mapping Node and adjusting the Scale values.

The higher the Scale values, the more times your texture will repeat within the texture space.

If using Blender Render you can change the scale of the texture here:

If this will be for a game you may consider scaling the UV Layout instead.


Scene clip in Video Editor affects the image strip above it

I submitted a false bug report on this issue and a developer, Sergey, explained the problem: Color Management had been turned off.

Color management is on by default, and Sergey suggests not messing with it.  (someone else edited my .blend file)

To re-enable Color Management, go to the Scene tab of the Properties window and under Display Device, select sRGB.

The problem should be gone.  Please see the bug report for details on why this occurs.