How do you import a Compositing Node Set-up?

You can do this by making these nodes into a custom Node Group and then appending it to the file. To do this select all the nodes, and press Ctrl+G. (I would recommend not including the Render Layer and Composite nodes, as they will be present in the new file)

Now you can go to your new file and select File > Append and then navigate to the proper .blend file and then into the NodeGroup folder. Select the desired node group, and click Append.

Now you can go into your node editor and use Shift+A > Group to select your node group. You can edit it using Tab.


how to make current obj solid and other obj as wireframe?

If the viewport is in wireframe shading, going into edit mode will show transparent faces on the edited object, while the others only show wireframe. To have the active object fully solid while the others are wireframe, you need to set the max draw of all other objects to wire. You can select all objects and use copy to selected to set them all the same.

You can press numpad-/ to go into local view, this shows only the selected object/s, you can then go into edit mode without the others being visible.


How can I scale curved surfaces radius but leave its width alone?

Yes, so long as you know the center of the radius.

Place your cursor at the center of the circle.  Change to cursor pivot with . key.  Select your mesh.  Use the push/pull operator, available from spacebar search, or from the mesh/transform menu.  Move your mouse until you're happy, then LMB confirm.


Why can I only texture paint some parts of the model

In your first photo the reason why your texture looks so strange is because the UV associated with that face is squished in a way that it can only take the colour of a single row of pixels. A way to fix this is to select some of your edges and right click, then create seams. Then select everything and press U, then smart unwrap. This should be able to make your UV map easier to work with.


2.79 Multiple displace mods with different uv-maps and textures

After looking around I found my answer, but for anybody having the same problem:
it seems the maps "inherit" islands and textures from the previous map. I got it to work with choosing my maps, resetting (Unwrap - reset) the islands and starting over.
I guess the best way would be to create all the maps you need prior to unwrapping any faces to make sure you don't have any unwanted "leftovers".


How to resume a render that got interrupted?

If you were rendering out frames as individual images, then you should be able to just set the "begin" frame to the last rendered frame, and go from there.

If you were rendering to a video file, then no... there is no way to you probably can't get all that work back. The file that got created (if it got created at all) is probably corrupt and unrecoverable. It's possible that the video file will still open in the VSE, and just have an unexpected end, or be shorter than it should be. I've never been able to, but IF you can open it, you can determine the end frame, render the remaining animation (to images), and stitch the two animations together after the fact. Furthermore, rendering the partial video file to individual frames might make that stitching process easier, but it will be critical to get the frame rate correct, or you'll end up with odd timing issues.

This is why it's a good idea to always render to individual frames, and then use the VSE to put those frames together into a video file. Once you have the frames rendered, rendering them into a video file is a very fast process.


Use follow active quads.
Select the faces next to the seam. then select all and unwrap using folow active quads.


How to apply fcurve modifiers on top of each other, like object modifiers?

Have you considered the NLA?

Add Noise to your original fcurve.

Cycle with strip repeat
Add Noise to the NLA strip

Add Noise to the animated influence

Add noise to the animated strip time.

Produces some random patterns over the cycles, with a fair touch of overkill.  Just the repeat and noise modifier in the NLA would suffice.


Render settings for rendering an animation (with fire/smoke simulation)

Rendering 4k means almost x4 the time of a 1080p render, and adding a second card with the same power won't double the performance. However, rendering with two instances of blender, on two separate cards and on different frames, and you will have the best performance you can get from a single machine.

Also the OS counts, my experiments shows that on linux it's faster.

Some Advices:

Turn off caustic, and use some clamp to greatly reduce render time and be conservative with light bouncing setting.
Use all the rendering pass on one frame to discover the most noisy one, and then use branched path tracing to cast more ray where is really needed.
Bake everything you can bake in advance.
I bet you can reduce the time a lot if you follow these advices.
Render out on a series of png/exr, don't output to a video format directly.

Edit with more info:

For basic settings for light paths you can select "limited global illumination" in the dropdown (this will also uncheck caustics).

Filter glossy it's also sometimes useful.
Clamp settings. It's under Sampling (still in the render tab) start setting Clamp indirect to 1 or higher (it works the opposite lower values more clamping but I don't advice to go lower then 1).

A tutorial on "branched path tracing".

And again, pre-baking a combined pass and then rendering it using an emission shader will save time for every frame a lot!

These are general advices and don't apply specifically to fire/smoke because every render is different depending on the material used.

Of course if you need to make a long sequence, and you reach the limit of optimization you can always use a render farm. However, you can go a long way by just preparing the scene before rendering.


One "trick" you could try to use is adding texture with transparent "holes" to basic geometries, overlapping them to replicate some similar pattern. The "import images as planes" add-on (included but disabled by default) could ease the process somehow.

Eg:


Yep. Just convert the video into an image sequence and load it into an Environment Texture node as usual. Make sure you have 'Auto Refresh' enabled.


Here is one result you could achieve with noise and voronoi textures:

The concept is fairly simple, first create two base shaders.
 Here it is the two sets of diffuse/ glossy. One for the darker and lighter color of the paint. Then, just mix between them with a noise texture.

The scale of the noise texture will control how much variation there is between the two layers, and where the variation falls. The color ramp will control the intensity of the transition between the layers. Changing the interpolation to ease or b-spline might be interesting depending on your needs.

Then use voronoi (or some other texture with high scale) for bump to give the texture of the wall.

Here is the node setup for the example above:

click to enlarge


How do you make a loop cut a straight line (not follow the contours of the mesh)?

He presses SZ0, which scales the selected vertices to 0 on the Z axis, flattening them.

Another useful shortcut is E during edge slide, which aligns the new loop to one of the adjacent loops (press F to switch between loops).


How can i print out the maximum,minimum and average valence for all the vertices in the selected mesh?

Here is a script to collect the valence of all vertices of an object:

import bpy

def CalcValences( verts, edges ):
    #Initialize the valences with all vertices indexes
    result = {v.index: 0 for v in verts}
    #Add the valences for the vertices of each edge
    for e in edges:
        result[e.vertices[0]] += 1
        result[e.vertices[1]] += 1
    return result

# Get the selected object
obj = bpy.context.object

if ( obj ): # If it exists
    valences = CalcValences( obj.data.vertices, obj.data.edges )
    print( valences )

obj.data.vertices corresponds to the vertices, which each as an index as identifier.

obj.data.edges get the... edges and each edge stores a vertex index pair in vertices[0] and [1].

Concerning min, max and average, this is Python aspect, not Blender...

If more information is needed, please ask in comments.


VSE: How to add images on the video so that both the video and the image will be visible?

Make sure that the text image has an alpha channel to show the video strip below on the timeline. Also make sure that the new image strip has its properties (n-key) set to Blend type: Alpha Over.


How to select objects based on materials?

You can do this by selecting one of the objects with the material and then going to the 3d view header and choosing Select > Linked > Material or use ShiftL > Material.


I'm trying to export a character to UE4, but I can't seem to export the shape key animation and bone constraints, how could I get around this?

The usual workflow to export animation with constraints is to perform the animation in Blender, then select all deforming bones and bake the animation (Pose mode, pose menu, animation, bake action), visual transform, delete constraints.
In this way you'll export an armature with no constraints that can be accepted by all others softwares.
Be sure to perform the bake on a copy of your file, because it's a destructive edit.


How to change Alt + B Passpartout Bounding Box Color

Go to Edit > Preferences > Themes > 3D Viewport and set the color for Clipping Border to your liking.
If you use the Eyedropper tool in the color settings you should normally get the original background color by clicking on it, but for me it looks a little brighter. So maybe you have to adjust it manually.


Return the current release of blender on command line

Using akira's idea, you could use wget --spider to search the web page for links without downloading them. Then you could use something like awk or python to filter the output for the desired urls:

% wget -r -np --spider https://builder.blender.org/download/ 2>&1 | python -c "import sys; print(''.join([line.rsplit(' ', 1)[-1] for line in sys.stdin if all(term in line for term in ['http','linux'])]))"
https://builder.blender.org/download/blender-2.80-430cf7e15eef-linux-glibc224-x86_64.tar.bz2
https://builder.blender.org/download/blender-2.80-96f762500ef9-linux-glibc224-i686.tar.bz2
https://builder.blender.org/download/blender-2.79-e6acb4fba094-linux-glibc224-x86_64.tar.bz2
https://builder.blender.org/download/blender-2.79-e6acb4fba094-linux-glibc224-i686.tar.bz2


Why are the particles floating around the objects instead of sticking to it?

The emitted particles (sprinkles) are attached to the emitter (donut) in their origin points. If the origin point is far from the object, the emitted particle will be far from its emitter. Check the origin point of the emitted object, Perhaps it's not adjusted to geometry.

Select the emitted object (the sprinkle) > Right click > Set origin > Origin to geometry.


Prefetch maxing out 20+GB of RAM over a 355MB jpeg sequence

If you are tracking, you need the whole sequence and at full resolution (which conveniently you didn't mention... HD, 4k?).
Something to understand is that, even if your images are compressed as jpgs, blender will de-compress them to be able to use them, so multiply the number of horizontal pixels by the number of vertical pixels, then multiply that by 8(8 bit per pixel), and that number by 3 (Red, Green, Blue), and then by the number of frames, and that is the real memory usage.
Read: Why does Blender use so much memory for large textures?.
Also, not being able to cache the whole sequence is not a problem, as accessing jpegs is not very resource intensive. As long as you have enough resources to read the current frame you are fine.
What really matters is that you have enough RAM left to compute the solve information. So don't use all of your memory in the cache, and leave enough for whatever processing you need to do afterwards.


As an experiment, I tried doing this from the Graph Editor using a Cyclic Modifier with more than one channel selected at the same time. Unfortunately, it always favors one of the channels, and it alone gets the cycle modifier added.

However, the functionality you're after could be achieved using action strips in the NLA Editor. Because when you cycle those strips, it cycles everything in the strip, no matter how many keyframed channels it contains.

With the NLA open, and your action selected in the Action Editor (Action Editor is one of several editing contexts accessible from the Dope Sheet), push the strip down, so that it's accessible from the NLA. Next, press n to roll out the Properties Shelf (make sure you're floating your cursor in the NLA Editor window before doing this), and press the Strip tab. You will see that you have access to various ways of controlling the behavior of action strips. One of those is the Repeat option, which is under the Action Strip section. Here, you can enter a number and then the strip will cycle that many times.

Hope this helps.


1- Enable the Snapping Tool clicking the magnet on the 3D view bar.
2- Next to the magnet icon hit the icon next to it to select snap to what> Select
Verex.
3- Select a vertex along the neck edge.
4- Move cursor close to its desired destination.
5- Hit G, then ENTER when in snapped position.

Note: Transform manipulators doesn't work well with the magnet.


How to remove texture from selected faces?

Add one more Material and assign to the Under the roof part it will be a quick solution for you


How can I use the Displace Modifier in a way that allows me to raise an artwork at one spot and recess it on another?

If you really wish to go with displace, and you're working with displacing from an image texture, it should really just be a matter of calibrating the colors of the image texture.

50% gray = no displacement

white = full emboss, displace upwards

black = full deboss, displace downwards

Intermediate shades emboss/deboss a correspondingly intermediate amount

Using GIMP or the like, you should be able to composite your individual displacement maps into a single image so that everything is being displaced in the direction you wish. You may need to invert colors of various parts of the image, or modify the brightness/contrast (e.g., or levels, or curves, whatever) to control the relative amount of displacement.


How do I make an object always be a duplicate of anything?

If you duplicate the object in question using ALT+D as oppose to Shift+D The objects will be linked. Anything done to either object should be reflected with the other(s).

Edit:
Do note wiki.blender.org is a viable resource when looking for information like this.
The entry found here directly pertains to your question.


How do you properly align refference images

It really seems like the blueprints aren't very precise, as moonboots already mentioned.
Look:

I've used basic geometry as a guide and marked just two regions which should line up, but don't. The lower right part of the hood (where your active vertex resides) is clearly to high in front view (marked yellow).
In general, it is good practice to evaluate blueprints by doing this before you start.
Here are some rough steps to follow.

Research real world dimensions of your vehicle.
Create a simple box with those dimensions as reference.
Place the blueprints inside the box and make sure they match exactly on the bounds. (Roof, tires, side mirrors, trunk, front)
Check prominent features for alignment. I.e. by using more basic geometry.

That way, you can be aware of any issues right from the start.
--
Blueprints are very often not exact and it won't be possible to place geometry perfectly in all views.
When that happens, you can for example stick to those views that match and work with a bit of offset on the one that doesn't match. Or you can go half way.
Just maintain the shape / curvature of the misaligned view as a reference.
And you should always find good real world reference images to decide on how to proceed with areas where the blueprints are off or don't show enough detail.
--
So, as far as I can see from your blendfile, you've done nothing wrong with the blueprints.


Python - Linear interpolation before keyframe

Just to follow up with the help from @batFINGER:
import bpy

o = bpy.context.selected_objects[0]

for fc in o.animation_data.action.fcurves:
    fc.extrapolation = 'LINEAR'


How to get world coordinates of a UV parameter on a NURBS Curve Surface?

This isn't supported, in general Blender's nurbs support is quite basic.

Blender uses a method of calculating nurbs that steps over the curve in U and V directions at a fixed level of subdivisions (tessellated for drawing in the viewport), and there are no built-in methods to ray-cast into a nurbs surface, though such methods exist and could be added to Blender.

However if you really wanted its possible to take the nurbs data (before tessellation) and evaluate it from Python, but this would be quite an involved task.

As a simple solution you could just get the mesh of a nurbs object and (knowing the order of grid verts/faces), you could find the face that lies on a UV coord, then interpolate across the face... it wont give an accurate location but may be good-enough in some cases.


How to create geometry with "point and click" and set number of vertices?

This is a rather trivial problem. In edit mode, in the 3D viewport, locate the 3D cursor where you want the first vertex (starting point) and while holding down the CTRL key, click the left mouse button. Then, move the cursor to the location at which you want the other vertex (end point), hold down the CTRL key, while clicking the left mouse button again. Now, select the first vertex, and while holding the SHFTkey, click the vertex that you chose as the start point, and press the Fkey to join the two vertices with a line segment. With the line segment selected, use the subdivide tool (press the spacebar, and enter "subdivide" in the search bar) to create the number of intermediate vertices desired. The default behavior of the subdivide tool us to space the intervenient vertices equally between the end points.


How do i stop the normal map from offsetting light?

I'm not sure what the normal map is doing but try turn the roughness down to see if it can combat whatever is happening. Also try applying a different normal map and see if it still offsets the light, and post pictures of the results.


I can't see the 2nd layer rendered in the Compositor

The alpha over node uses the box's alpha (donuts are inside the box)

so it mostly covers your glow effect (white alpha will be over the other image). If the desired effect is what I suppose, i suggest you to use an Add node. (light is added)


Inside the shirt, there is a Ngon that breaks the flow of the edge loops, so your vertical Seam fails to "cut" the model in two halves :

A quick fix would be to add a Seam along on side of this Ngon :

It would also be a good idea to add a Seam inside the arm, same position as outside :

For your future models, i would suggest avoiding unnecessary NGons. Also, you can use the Solidify modifier instead of modelling the outside and the inside, it's much easier and avoid this kind of traps.


When I parent my head armature to my body armature it moves

Nevermind I found it, you have to select keep transform


Evee and Workbench use Gpu when rendering but Cycles doesn't

As mentioned by @Eric Xue, the Ryzen 7 4800u is a CPU with only integrated graphics. Unless you have a dedicated graphics card, i.e nVidia Geforce RTX, or AMD Radeon, you cannot use the GPU render function because Blender does not render on integrated graphics.

Your GPU rendering selection is grayed out, signifying that you do not have a GPU or a  non-compatible GPU.

If you do have a compatible nVidia or AMD GPU, enable it in the Blender Preferences.


Help converting from tessface in old addon in Blender 2.8

Got the faces with one line

def make_mesh(verteces, faces, normals, uvs, global_matrix):
mesh = bpy.data.meshes.new('name')

mesh.from_pydata(verteces,[],faces)

obj = bpy.data.objects.new('name', mesh)
# apply transformation matrix
obj.matrix_world = global_matrix
bpy.context.collection.objects.link(obj)  # link object to collection
```


How can I decrease x-ray alpha in 3D view?

Sure there is.
Just use the X-Ray slider in the Viewport Shader menu


Save ik bones after bake action for backup

Thanks to @SergeL's answer, we can duplicate another copy of armature and bake it, then reassign it the newly created action to the armature.

In my case, I need to remove the ik contraint in bones for making another new animation, so I keep a backup of original armature and continue work on duplicated copy of armature after done baking action. At this point, we still can select which armature we wanna apply onto your 3D object, like this:

Here's the steps to work on new action without deleting your ik bones:

Duplicate selected armature to new copy.
Bake action using the duplicated armature (pose menu > animation > Bake action... under pose mode)
It should automatically assign the action to current duplicated armature.
Remove all ik contraints in duplicated armature.
Select your 3D object and goto its modifier. Select the duplicated armature in "Object" field under its armature modifier.
And now, you can work on new animation in a new action, without the ik bones constraints while keeping it as backup.


How do you make a armature and connect it to a mesh?

If you have an armature ready to go, then in Object mode, select the mesh and then shift select the armature. Then press Cmd+P/Ctrl+P and parent it with automatic weights.
Now you can select the armature and move the individual bones in Pose mode and the mesh should move with it. If certain bones have too much/too little influence on the mesh, you can alter it by selecting the mesh, going to Weight Paint mode, and select the bone that you want to edit in the Object Data Properties tab under Vertex Groups.
It might also be useful to apply some inverse kinematics to your armature to make animation easier and more realistic. Blender has a good video tutorial on how to do that here and this one is also useful.
As mentioned previously, this YouTube playlist is a really helpful resource that walks through almost every aspect of adding and editing armatures.


Using bpy in a standalone python script dies when rendering

Adding
bpy.context.scene.render.engine = 'CYCLES'

Fixed this issue


You have to use a compression like H264. Your 4k Video has also a compression on it and that the reason why it is smaller than your 1080 video.


Blender Game Engine, Falling Through Ground

Set the physics type on your ground to triangle mesh. That should fix it, But if it doesn't not, you can also turn up the margin or extrude the ground down in edit mode.

It is possible that your ground is not calculating the collisions correctly, and changing the collision bounds on the ground should fix it.

If your problem still happens, you can also try changing the collision bounds on your character. If you are still unsure what the problem is, you can activate "Physics Visualization" to show exactly what is or is not working.

Notice the difference between these pictures. The first is using triangle mesh collisions on the ground. The second one is using box collision type.

Although there is normally no problem with box Or triangle mesh, sometimes there is still an error and the collision bounds will not detect properly. In this case it is normally a good idea to try a different type, or increase the margin.


As far as I understand, a constraint defines a range of allowed values and if the value is outside of it, it snaps to the nearest boundary. Unfortunately it doesn't operate on transform properties, where you can have e.g. 1000° rotation, but on matrices using quaternions.

rotation angles differing precisely by the natural period will be encoded into identical quaternions and recovered angles will be limited to { 0 , 2 π } (in radians)

https://en.wikipedia.org/wiki/Quaternions_and_spatial_rotation
This means, that for a constraint, 460° angle is the same as 100° (100°+360° = 460°). You can't therefore constrain an object to some number of rotations, after which it will no longer rotate. So if you set the constraints to -180°..180°, it is not constrained at all, because no matrix can translate to a different value in Euler rotation. If an object is at 181° rotation, it is the same as if it was at -179°. Therefore, if you want to limit your object's rotation to 150°..225° range, you have to use two constraints: 150°..180° (any higher value would also work but would really mean 180°), and then -180°..-135° - the problem is, you can't combine constraints like that, they are applied one after another. So if the rotation is 181°, after converting to quaternions and back, it is now -179°, which is below the lower limit of 150°, so it is clamped to the lower limit, unintuitively snapping from 181° to 150° instead of closer 180°:

When the next constrain is applied, it will now snap this angle to the -180°..-135° range.
The general solution is to rotate the object to exactly half its possible rotation and apply rotation to set it to 0, so that now it can move 180 degrees in either direction. In your case, knowing the constrained range is much smaller, you may feel tempted to apply the rotation at a more elegant position, e.g. -45°, since -225° + 45° is exactly -180°, but then you would run into the mentioned flipping problems when a value below -180° suddenly changes to a value below 180° and is snapped to the wrong boundary of the constrain, so remember to give yourself some safety margin.

If you don't want the flipping:

Then you just have to resign from the constraints and use a driver:


Light reflection and refraction in Blender Internal?

You need to use a ray-tracing render engine. Blender's internal render system has a ray-tracer, but it doesn't have the ability to reflect or refract light beams. You could possibly use Cycles for this.


Running simulations and extracting data from Blender for analysis

This is a very interesting question, and I would love to see what you come up with. I just spent some time trying to figure out A). I've looked before without luck, but today I discovered the object matrix_local contains the current translation matrix of an object. That means you can do this to find out the location, rotation, and scale:
import bpy

C = bpy.context
D = bpy.data

loc, rot, sca =  D.objects['Sphere'].matrix_local.decompose()
print('Location:', loc, '\nRotation:', rot, '\nScale:', sca)

You can find distance from the origin with:
loc.magnitude

And finally:
 (Vector( (1,1,1) ) - loc).magnitude

gives the distance from the point (1,1,1).
See the docs on Blender Matrix and Vector types and this answer on accessing matrix elements


Add Glare to Equirectangular Panorama Without Stitching Issues

As 3pointedit suggested in the comments, you can use the Translate node to make it seamless:

I set the Mix to 1 in the Glare nodes so they output only the glare, which I mix using Lighten.


Why is My Lighting Creating a Triangle on the Ground?

It's your sun lamp near and far Clipping values.

Adjust the Clip Start and Clip End values for the Spot.008 lamp that is acting as sun.


This was a known bug in 2.77a. https://developer.blender.org/T49228

I now installed Blender 2.78a and the issue is resolved by using the new version of Blender. The material is now saved and loaded correctly.


Extrude a mesh by Region using Python script

This should do the trick, and no need to create a bmesh object to extrude all your mesh's faces:

import bpy

# Go to edit mode, face selection mode and select all faces
bpy.ops.object.mode_set( mode   = 'EDIT'   )
bpy.ops.mesh.select_mode( type  = 'FACE'   )
bpy.ops.mesh.select_all( action = 'SELECT' )

bpy.ops.mesh.extrude_region_move(
    TRANSFORM_OT_translate={"value":(0, 0, 3)}
)

bpy.ops.object.mode_set( mode = 'OBJECT' )

Often you can find hints about how to call operators from the info panel, and of course the tooltip. In this case they give contradictory hints but both can get be beneficial:


Two things. 1) Your CPU is probably lagging because cloth simulations take up a lot of processing power. 2) A way to fix this would be to set the playback of the animation to Frame-dropping. You can do this by going to the "playback" tab in the lower left side of Blender, and setting that to Frame-Dropping.


Deleting the insides of model/ hollowing it

You can use the Select Inner Faces operator,  and then delete then. To do this, in 3D view space, go to the header, then Select, then Interior Faces. Then you can press X > Vertices.


Blender game engine importing .obj error

The imported material is set as transparent. The selected transparency method, "Z transparency", give weird results if the object has internal geometry.

To fix this, in the material properties, uncheck "Transparency".


You cant set a different texture for array's duplicates.

However, you can shift their UVs:

As you can see here, I have a texture of 1/3 ratio. Each third has a different pattern.
My array is set to make three different duplicates, and to shift their UVs of a third (1/3= 0,333...) on the V axis.

The result is quite usable.
All you have to do is a texture file containing your different textures aligned on one axis, adapt your UV to one area of the picture, and set your array's number of duplicates and U/V offset accordingly.


From what I understand try just pressing s + x/z/y instead of alt s. Also make sure proportional editing is off


Imported model from Steam version of Fuse has flipped faces when rendered. Flipping normals does not work

The answer was quite simple and if I did a bit more research and watched a video, this would have been simple. All I had to do was to select the model, select materials, scroll down to settings and change "Blend Mode" to "Alpha Hashed." This has to be applied to all textures.


Why is my Array Modifier not curving my mesh like a square mesh?

Try selecting the object that you are modifying with an array, and choosing Object | Apply | Rotation & Scale.  Whenever I have weird effects using an array modifier, it's usually (99% of the time) because I haven't applied the rotation and scale.


How to arrange UV mapping to Square as like attached video?

Your view is taken into account when you choose Unwrap > Cylinder Projection, you need to be in front orthographic view when you unwrap.


Hair dynamics stops working after particle edit

Hair dynamics can use edited particules, something is stopping the normal process.

As you edited the particles, you're probably in particle edit mode.

This mode allows you to edit your particles but does not allow simulation
Go to object mode to start your sim.

Your simulation should be playing correctly with edited particles.


Is there a way to control children hairs so they don't cut through a mesh?

Try using interpolated children instead of simple.

Interpolated children are interpolated across the surface of the mesh between the parents. Simple children, on the other hand, are just placed in space around the parents.

Here is a comparison of simple vs. interpolated (click to enlarge):

The left two planes are using simple children, the right two are using interpolated.  You can see how the simple children are hovering in mid-air, poking through the mesh, and not evenly spaced.  While the interpolated children stay on the surface of the mesh and are more evenly distributed.


Do "make install" on different Linux sytem than the one used for "make bpy"

This is not really an answer, not my knowledge either.
Wanted to add this as a comment, but I don't have enough reputation to do so.
I asked Campbell Barton several years ago about how to build blender so I could share my builds with people that used a different distro than I did, and this is what he replied:

There are a few issues here, First is with general libraries - if the
users doesnt have those exact libraries, blender wont start. To find
the libraries blender depends on do...
objdump -x blender.bin | grep NEEDED
You can do this too, it will show all indirect dependencies too.
ldd blender.bin
There are 2 ways to go about this,
*) statically link all libraries
*) include the libraries and use LD_PRELOAD_PATH to ensure they get found, this requires a wrapper script. to set the environment
variable.
Statically linking libs is best if you can, but for that you will need
".a" files, so not libpython3.2.so --> libpython3.2.a
however not all libraries come with static versions by default... it
can be a hassle to get them all.
There are docs on static linking libs, you can check online for more
info.
Also be sure to static link libgcc_s.so.1 and libstdc++, gcc has some
options for this.
once you have this sorted out the main remaining problem is linking
against libc, since you cant run blender on and older linux distro if
you linked with a newer glibc (normally called libc.so.6).
To workaround this you need to link against an older glibc, This can
be done by setting up a chroot environment that uses an older libc. or
simply by using a VM with an older linux distro installed, both are a
hassle :S.
Try google: linux link against older glibc
It comes up with some useful links.
Note that for our official linux builds we have a chroot with some
older libs installed so blender loads on older linux installs too.

Hope that helps!


A question about the range of influence of the grease pencil sculpt mode

While in sculpt mode, you can press C to circle select only the vertices you want to edit, confirm with right click, then enable this button to limit the sculpt to selected vertices.


The problem is, in your mesh model and as shown in the images, the mesh making up the wing tapers from the fat end to the narrow wing tip.  This makes the lines appear, kind of, parallel but they are just straight lines with various angles at different x,y,z levels, so when you extrude, the extrusion stays at a right angle (normal) to the lines being extruded from; but, while the long(itudinal) edges are mostly parallel, the (latitudinal) edges of the flap or any other part of the wing change in the XY axis.

In other words each line making up the wing and flap have a similar vanishing points (are nearly parallel), to make the streamline wing, but they are not aligned to the extrusion point.  So, it's not possible to extrude along the normal, and end up aligned with the flap or other points on the wing; but, you can edit the verts, or edges you extrude from the surface, to make them align.

Here's how I would do it. Read this first, I have put step by step instructions below this talk through.

While looking (top view) down on the plane, in vertex select mode, select the verts that represent the width of the spoiler you want to make, where you want to start the extrude. (With the instructions below, we're going to end up with single plane aligned the way you want).

Looking at the wing from the side view, extrude the verts at the approximate angle you wish toward the flaps (a combination of X & Y axis). This will give two edges at the angle you want (temporarily) above the Z axis.

You will now have two edges, two verts each; two are part the wing edge, and two at some height above the z-axis at an angle toward the flaps, but not yet what you want.

Go back to the top view. We're still in vertex select mode; but, we want, snap to vertex ON, and select vertex, (the magnet 'snap during transform' or use Shift + Tab, and 'type of element to snap to: vertex' (right next to the magnet, select vertex).

You will first need to select one of the two end verts of one of the two extruded edges, then press key G (grab), then degress of freedom for X & Y axis by Shift + Z [this says, freedom to move in X&Y but not Z axis.] This will allow you to retain your Z-axis (height of that vert above the wing or flap), but will allow you to snap to one of the verts that are part of the wing (or flap), without actually snapping to the wing (or flap)!  So, you have grabbed, and set X & Y axis (not Z), now move to the correct vert, you may have to move your pointer around till you see it snap to the one you want.  Once it has snapped to the vert you want, click to set it.  Now, do the same for the other vert of the 2nd extruded edge.

Turn off snap to: (magnet)

Add a face in the usual manner, select the four verts of the extruded edge, and press F to make face.  You can now edit as you wish.

Note: If you need to adjust the z axis, just select the two verts, press G > Z to only move them along the Z axis to adjust the angle.

Here are the steps and modified blend: http://www.pasteall.org/blend/36162

Top view (ortho), (Vertex select mode) select two verts to extrude for spoiler.
Side view (ortho), extrude in the general directions and angle you want.
Turn on Snap to (magnet) and vertex in the bottom menu.
Top view (ortho), G to grab one of the verts, Shift + Z (select X,Y axis)
Move pointer to vert to snap to: may have to wiggle pointer around to get it to snap to the vert you want.
Use LMB to set vert.
Repeat steps 4-6 for other vert.
Turn off Snap to (magnet)
If you need to adjust angle

Top View (ortho), Shift + RMB the two verts
Side View (ortho)
G to grab, then Z to select Z axis.
Move up or down for correct angle.
Press LMB to set.

Set face by selecting the four (4) verts of the spoiler, pressing F make face.

Of course, you'd have to remove some faces if you want to see through the wing that made the spoiler, and put in some machinery; but, that's another question.


How modify sphere mesh in an animation with shape keys

You could simply use a Displace Modifier and apply it as a shapekey.

First add a Subdivision Surface Modifier followed by the Displace Modifier and then a second Subdivision Surface Modifier.
Your modifier stack should look like the image below:

The texture can be anything grayscale, but for this example I used the below:

Once you are happy with the result of the texture you choose, apply the first Subdivision Surface Modifier, and apply the Displace Modifier as a shape key.

The remaining Subdivision Surface Modifier will not be able to be applied, and shouldn't be anyway.


Orthographic Cam with HDRI in background

The longer the camera lens, the smaller part of HDRI is visible.
Orthographic camera is infinitely long, so it only shows one pixel of your HDRI.

Solution: Use a perspective camera.


Integrating edge loops in grid fill surface

As mentioned in the comments, one of way to create faces in that mesh is to use grid fill. There are other options, such as bridging them.

Using grid fill

Start by selecting two pairs of edge loops and the connecting edges, as shown in the picture below.

Press space and search for "grid f" and choose "Grid Fill".

Repeat that for each pair of ledge loops, and you will have a full mesh.

Using the bridge tool

Start by selecting all the loops except for the edges on the top and bottom.

Now simply press W and choose "Bridge Edge Loops". Change the number of cuts to match the number of vertices in between each selected edge loop (in your and my example mesh it is 3). You can find that in the operator half of the tool shelf.

Now you just have to fill the top and bottom parts. You can quickly do that with the F2 addon (that fastest way), or by any combination of bridging, and grid fill.

Here is an animated gif showing how I did it with bridging and the F2 addon.

Here is the final result:


Can we measure the brightness intensity of a Model(Cube)

A few alternatives:
Use the false colour view transform in the color management.

(from https://sobotka.github.io/filmic-blender/)

False Colour.
This Look is an extremely useful tool for evaluating your image in terms of the dynamic range and latitude. It is a colour coded “heat map” of your image values, according to the following codes:

Or render an image, and you can probe the values for the pixels under the cursor by pressing the right mouse button wile hovering over the image.

The values appear at the bottom of the image editor screen. You can see the coordinates of the pixel, and values before and after the color transforms of the color management.
Or you can measure the brightness of the image using a waveform monitor in the scopes section.
The scale here is 0 for black and 100% for white.

Note that these values are after the color transforms, or display referred values.


How to render cartoon style with completely flat colors?

These are the settings you need to change to set flat toon/cel shading. To get rid of aliasing with constant interpolation, in options panel, turn on Full Oversampling. There are limitations, noted them in the graphic.


Prevent shadow on object/material A, allow for object/material B

Unfortunately, I am pretty sure this is impossible to do in Cycles material nodes.  You will have to do this in the compositor.

First place the object which you do not wish to receive shadows on a separate layer.  Then create two render layers, the second of which excludes all layers except the one where you just put the object.

Everything is on layer 1, except the plane which should not be receiving shadows which is on layer 2.  So I am excluding layer 1 from the second render layer.

Now give the shadowless object a pass index under Object Properties > Relations rollout.

And make sure you have the Object Index pass enabled for the main render layer.

Now head over to the compositor and use the object index pass to mix the second render layer onto the first one.

Here is the final result:


modifier in python works, but not the same as in the gui

Testing your code, it look to works fine with python 2.73, but i was able to reproduce your result with 2.78.

So, first of all, blender boolean are very bad, sometime they fail for no "good" reason caused by overlapping geometry, edges, holes,... In your case the sphere has a ring exactly aligned with the cube face.

A general solution would be so move slightly the sphere, let say positionning it in 2.001 would be enough.

Another solution for Blender 2.78, the boolean now have two solvers, bmesh and Carve. Using carve seems to work better

bpy.context.object.modifiers["Boolean"].solver = 'CARVE'


How to draw text and shapes to a Texture?

Unfortunately I haven't found a way to easily render text using the GreasePencil API nor a way to capture GreasePencil text/lines into a texture (Blender Image).

I ended up using PIL and copying the pixels over to a Blender Image (method described here). Other than the conversion using [:] to access pixels slightly faster the other speed up was using a bitmap font (as opposed to a true type font which was slow to rasterize):

font = ImageFont.load(os.path.join(os.path.dirname(os.path.abspath(__file__)),"fonts","haxor.pil"))


Only a shadow of the 3d object over the background is visible in the render

You are multiplying the image on top of the background.

Use alpha over to place the render layer over the background.

  Use this node to layer images on top of one another. This node takes two images as input, combines them with a factor, and outputs the image. Connect the Background image to the top input, and the foreground image to the lower input. Where the foreground image pixels have an alpha greater than 0 (namely, have some visibility), the background image will be overlaid.

Please read the manual: https://www.blender.org/manual/compositing/types/color/alpha_over.html?highlight=alpha%20over


The Particle Edit Mode could be quiet handy for this. The settings can be found in the left menu (shortcut T). Also there is the option to just edit the tips (see bottom toolbar).
For "real" interaction you probably need to use Hair dynamics and add a Collision component to the heart


How To Make V-key Toggle Between Vertex Paint And Object Mode?

It occurred to me I was trying to mimic the Tab-Key. So I looked that up in the Keymap. Then just did the same thing, but for Vertex Painting instead of Editing.
Preferences > Keymap > 3D View > Object Non-modal > Add New

Set object.mode_set
Assign V-Key binding
Then select option to make it a toggle.

Note: In Vertex Paint mode, V is already bound to 'Vertex Section' mask. I removed the default V-key shortcut from Keymap > 3D View > Vertex Paint.


How to create text input field with Blender Python API?

You would have to register a Panel and as much StringProperties as you like. In order to display your properties on the panel, call layout.prop().
Following demo is based on  How to create a custom UI?
import bpy

from bpy.props import (StringProperty,
                       PointerProperty,
                       )

from bpy.types import (Panel,
                       PropertyGroup,
                       )

# ------------------------------------------------------------------------
#    Scene Properties
# ------------------------------------------------------------------------

class MyProperties(PropertyGroup):

    foo: StringProperty(
        name="Foo",
        description=":",
        default="",
        maxlen=1024,
        )

    bar: StringProperty(
        name="Bar",
        description=":",
        default="",
        maxlen=1024,
        )

# ------------------------------------------------------------------------
#    Panel in Object Mode
# ------------------------------------------------------------------------

class OBJECT_PT_CustomPanel(Panel):
    bl_label = "My Panel"
    bl_idname = "OBJECT_PT_custom_panel"
    bl_space_type = "VIEW_3D"
    bl_region_type = "UI"
    bl_category = "Tools"
    bl_context = "objectmode"

    @classmethod
    def poll(self,context):
        return context.object is not None

    def draw(self, context):
        layout = self.layout
        scene = context.scene
        mytool = scene.my_tool

        layout.prop(mytool, "foo")
        layout.prop(mytool, "bar")
        layout.separator()

# ------------------------------------------------------------------------
#    Registration
# ------------------------------------------------------------------------

classes = (
    MyProperties,
    OBJECT_PT_CustomPanel
)

def register():
    from bpy.utils import register_class
    for cls in classes:
        register_class(cls)

    bpy.types.Scene.my_tool = PointerProperty(type=MyProperties)

def unregister():
    from bpy.utils import unregister_class
    for cls in reversed(classes):
        unregister_class(cls)
    del bpy.types.Scene.my_tool

if __name__ == "__main__":
    register()


Blender EEVEE not rendering smoke simulation

Make sure you add the Principled Volume shader to the Volume not Surface in the Material on the Smoke Domain (not the emitter), that did it for me

If that doesn't work compare your system to the F3->'Quick Smoke' with a cube selected


Creating a custom property with named values

Check this code, this shows you 2 different options:

One is with direct control over the index with a slider with changing labels,
The other one is with the EnumProp like you have it.

import bpy

from bpy.props import EnumProperty

def updateEnumParameter(self, context):
    context.object.my_list_index = int(self.face)
    print(self.face)

class cls_IntFloatString(bpy.types.PropertyGroup):
    face_items =(("0","None","none"),
                 ("1","Smile","smile"),
                 ("2","Content","content"),
                 ("3","Dizzy","dizzy"),
                 ("4","Cat","cat"),
                 ("5","Girl","girl"),
                 ("6","Yuck","yuck"),
                 ("7","Macho","macho"),
                 ("8","Pixel","pixel"),
                 ("9","Charming","charming"),
                 ("10","Cry","cry"),
                 ("11","Ouch","ouch"),
                 ("12","Ultraman","ultraman"))
    face = bpy.props.EnumProperty(items=face_items, update=updateEnumParameter)

bpy.utils.register_class(cls_IntFloatString)

faces = {
    '0': "None",
    '1': "Smile",
    '2': "Content",
    '3': "Dizzy",
    '4': "Cat",
    '5': "Girl",
    '6': "Yuck",
    '7': "Macho",
    '8': "Pixel",
    '9': "Charming",
    '10': "Cry",
    '11': "Ouch",
    '12': "Ultraman"}

# Add these properties to every object in the entire Blender system
bpy.types.Object.my_list_index = bpy.props.IntProperty(min=0, max=len(faces)-1, default=0)
bpy.types.Object.my_list = bpy.props.PointerProperty(type=cls_IntFloatString)

class IntFloatStringPanel(bpy.types.Panel):
    bl_label = "Int Float String"
    bl_idname = "OBJECT_PT_hello"
    bl_space_type = "PROPERTIES"
    bl_region_type = "WINDOW"
    bl_context = "object"

    def draw(self, context):
        layout = self.layout
        box = layout.box()
        row = box.row()
        row.label("Selected Face:")
        row.prop(context.object, 'my_list_index', text=faces[str(context.object.my_list_index)], slider=True)
        box.prop(context.object.my_list, 'face', text='Selected Face')

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

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

if __name__ == "__main__":
    register()


My donut project can no longer render, computer freezes. Cannot fix!

go to your modifiers and delete the subdivision surface modifiers. I even don't know why you had 3 of them...


Make particles slip around objects in Animation Nodes

I will divide the answer into two parts being:

Implementing a simple particle system in Animation Nodes that is adaptable to achieve all the effects we want.
Adapt the particle system to avoid and slip around the sphere as shown in the gif posted.

Particle System

The advantages of giving up on blender's particle system and using Animation Nodes instead are numerous. It is intuitive, easy to use and flexible. However, one of the main issues with implementing such system is losing render engine support, both Cycles and BI have options specific just for rendering particles and we won't have such options if we don't use blender's particle system.

A particle system is an iterative implicit discretized system, meaning we can't evaluate the particles locations at anytime we want, to compute the particles location at a certain frame, we have to know their locations in the previous frame. Subsequently, if we want to get the particles locations at some frame, we have to compute the particle locations at all of the frames before it; because you have to know the previous frame and to know the previous, you have to know its previous and so on.

A particle system has an initial condition, which is the state the system was at the beginning of the time, in our case, the initial condition is the particle locations at the beginning of the time. At the next frame, the particles are moved in a certain direction based on some factor that is either: their location, index or simply a random arbitrary movement. At the frame after that, the particles are also moved based on the new locations computed at previous frame and so on.

Practically, in Animation Nodes, to implement such iterative system, you would need to store the new locations of the particle somewhere where you can access them in the next execution. For instance, lets say we have a particle that has some initial position, we will store that position in memory, at the next execution (frame) we use the stored position to compute the new one, then replace the old positions in memory with it, at next execution, we compute the new position based on that in memory and replace the old one with it and so on.

Currently, there is no way to pass data across executions, however, there are ways around it that are easily implemented, the way we will be using is described in my answer here. Make sure to read this answer carefully before continuing.

The first step is to create the initial condition of the system. In our case, it will be a grid of random vectors included in the xy plane, I will generate random vectors such that they belong to the visible part of the xy plane, there will be a good portion of the point lying outside of the view, but since our implementation won't be expensive we can safely ignore them:

And then I am going to use that as the initial condition for our particle system. I will define the velocity vector field as a constant vector going to the positive y direction. By adding the vector field to the particles, we observe them as they start to move:

Notice that the first expression node has the expression:

initial if bpy.data.scenes[0].frame_current == 1 else animation_nodes.particles

Which basically says, if this is frame one, return the input "initial", if not, return whatever is stored at animation_nodes.particles. The data is stored using the second expression node using the expression:

setattr(animation_nodes, "particles", data)

So, at the first frame, the current particles are viewed (Initial) and the particle locations of the next frame (second frame) is computed and stored in animation_nodes.particles, at the second frame, the particles that are stored at animation_nodes.particles are viewed (The ones we computed before) and the particle locations for the next frame (third frame) are computed, and stored in animation_nodes.particles (Replaces the old data) and so on.

We notice that the particles will keep moving to infinity leaving empty space behind, so, what I am going to do is reset their $y$ location after they exceed their maximum location (Maximum value of the random y value), the reset is easily done using a modulo operator:

We notice that in the gif, the grid is not strictly uniform in its randomness, in other words, there are certain areas that are low in density and others that are high in density, and we can see that the density is almost constant along the y axis. A possible way to achieve such areas of rarefactions is by moving the particles by an amount equal to a smooth low frequency perlin noise, though I believe moving based on the magnitude of its gradient might return better results, but I shall not cover this. Number Wiggle Node can be used to get the values of the perlin noise where the evolution parameter is the x location of the particles, that is, the x random value:

We can add another offset based on a y location based perlin noise creating some nice randomness as the particles move in the y direction:

Now that there is noise involved in computing the initial condition, we should probably cache the result (The initial condition will only be used at frame 1 and it doesn't really change, so we can safely cache it), caching will reduce the execution time from 40ms to just 2ms:

I think this conclude our work on the main part of the particle system, we may come back later to adjust some settings, but for now, we will move on to the second part of the answer, which is adapting this system to avoid obstacles like the sphere we placed in there.

Boundary Conditions

Currently, the particles have no regards to each other or to objects in the scene (Like the sphere we put in there, they are penetrating it like it is not there). So what exactly tells the particles where to move or how to behave? It is of course the velocity field which we defined as constant vector going in the positive $y$ direction. A vector field associates a vector with each point in space, in our case, that vector represents the velocity of the particle, that is, the direction it should move in. And as we said before, the field so far is constant for all points in space. If we want to make the particles avoid the sphere, we have to edit that field such that the particles slip instead of penetrate the sphere.

Now, I want you to open a new blend file to try somethings out. If we want to visualize the velocity field we have, we can create splines from edges that points in the direction of the velocity as follows:

We notice that they all point in the positive $y$ direction and that is indeed that's what our field is doing, that is, move the particle in that direction. We could edit the velocity field such that it points away from the origin simply by normalizing the particle locations:

We could rotate the velocities by 90 degrees obtaining this radial field that will rotate the particles around the origin like a tornado:

Now, I could mix between my original constant vector field and this vector field we just created using a linear combination where the distance from the surface of the sphere is the coefficient:

The vector distance node computes the distance between the particles and the origin, the subtract node is used to compute the distance between the particles and the nearest surface point of the sphere (Check my answer here to see why this work). The rest is the linear combination between both vector fields (Check my answer here to see how this works for Eulers which you can easily translate to vectors). Now imagine some particles moving along this field from bottom to top, if the particle is at the left side of the sphere, it will start moving upward and at some point start moving along the surface of the sphere tangentially as if it was slipping, isn't that exactly what we want?! As for the right side of the sphere, it is a bit of a mess and rather incomprehensible, but since we already have a working left side, lets mirror it. Mirroring can be done by inverting the vectors on the right side of the sphere, in other words, multiplying them by negative one. To get a scalar field with negative one on the right side and one on the other side, we copy the sign to one from the inverse of the $x$ location:

And we can start to see that this is actually the path of the particles, but we are not quite done yet. We will do a spline visualization for the paths of the particle so that we can tune the field even more intuitively. A loop is created to move the particles along the field, append their locations to a list, reassign the particles locations to the new locations and so on some number of times. Then another loop is created to create splines from the appended points and the splines are output:

It is not crucial that you understand this and I know it is not easy to understand, so I shall not explain it further, if you want to know why it works, I will provide more details. Let us now see how the particles move in the current field:

We can see that it is close to how the particles in the reference gif behave around the object, however, there still some work that need to done. The area at which the particles start moving tangentially is rather large, the particles--in the reference gif-- starts to move tangentially when they get pretty close to the surface, so we should reduce it. Reduction can be done by changing the rate at which the distance changes, in other words, multiplying the distance by some scalar:

Now I think it matches the vector field used in the reference gif. So lets go ahead and implement that in our original blend file! The only difference is that we are going to subtract the location of the sphere from the particles locations because in our study, we assumed it was at the center.

One thing we need to take care of is to make sure no particle were inside the sphere in the initial condition, this is easily done by some simple distance based masking:

And finally, we can see in the reference gif that the particles don't move tangentially after they pass the sphere along the $y$ axis, so I am just going to make sure all points with a positive $y$ have a zero coefficient in our linear combination, that is, they have the value of the original constant vector field. To avoid using loops or overly complicated node trees, I am going to use this simple list comprehension:

[factor if Y < 0 else 1 for y,factor in zip(Ys, factors)]

Had we had a vectorized compare and switch nodes, we could have just used them. This produces:

Which when applied on our node tree produces:

We now need to fill the spaces that are left in front of the sphere which appears to be appearing from inside the sphere itself. We will do this by implementing a secondary particle system for this. The secondary is quite trivial to make, if you understood how our main particle system work, then you can do the secondary one on your own. This secondary particle system concludes our work producing a final result:

If rendered with motion blur, it will look something like this:

All you have to do now is tune in the settings to achieved the exact result of the reference gif.

Blend file:


Change Base Shapekey without changing the other shapekeys

If you edit the basis then it will change all the following shapekeys but to change the other ones without it editing the basis you have to so it in edit mode


How to draw line between intersecting meshes in Freestyle?

As of 2.76, blender freestyle still does not detect edges at intersections, see docs:

  No edges at face intersection are detected yet.

A workaround is to create some extra edge (small face, invisible in the final render) on top of the actual intersection. It's not clean, but it somehow works. (note that the edge in the image below is a bit exaggerated. It can be much more subtle.)

Depends on what you want to achieve.

Another idea is to use the internal edge capability of Blender via Render->Post Processing->Edge. If you're rendering out a still image, you can then mask out areas with edges you don't want in the compositor, later.


Letting the camera move along different paths

No need to use multiple curves:

Add a circle (ShiftA> Curve > Circle)
Switch to edit mode (Tab) and set the handles to vector (V> Vector)
Delete one segment by selecting two of the control vertices on one side and pressing Delete> Segments.

To align the curve to the axes, rotate it 45° on the Z (RZ 45).


Is there a way to "turn off" a modifier when passing through an Empty?

Comment answer echo:
Attach a sphere to the empty with parenting, then hide that sphere from the render. Use a Boolean modifier on the array and the sphere as a target.


2.82 Where is the "save this image" button in compositing

I'm guessing this is saving from the viewer node in the compositor?  Open up the image editor, switch to the 'Viewer Node' for the image, and then go to the header -> Image -> Save as...

I guess they added that button for convenience, but the feature has always been there :)


It is in the Interface> View Manipulation section:


The main problem which causes this unexpected result is normals splitted in a wrong way.

In Edit mode with all selected access Specials menu with W and choose Remove Doubles.
With all still selected press Ctrl+N to recalculate normals.
Then in order to get rid of ugly artifacts caused by smooth shading normals should be splitted (see How to smooth shade an object while retaining hard edges?). In Properties Editor > Object data tab in Normals rollout you can see that Autosmooth option is turned on but angle setting is greyed out. See What does it mean when my Angle setting under Auto Smooth greyed out ?.

In the same tab open Geometry Data rollout; button Clear Custom Split Normals Data is active, so data is  present.

You can use 2 ways: clear custom split normals and set up either Autosmooth angle or Edge Split modifier, or leave custom split normals as they are (e.g. if they should be preserved) and uncheck Autosmooth option.

See also:

Shading in object mode differ from sculpting mode?
Editing custom split normals using Normal Edit modifier.


The pose bones can be found at bpy.data.objects['Armature'].pose.bones with each bone having a length property bones['Bone'].length which represents the visible length in pose mode.

The bbone size that you change when using "Scale BBone" is two properties of the armatures bones which can be accessed through bones['Bone'].bone.bbone_x and bones['Bone'].bone.bbone_z

import bpy

ratio = 0.3
pose_bones = bpy.date.objects['Armature'].pose.bones
b = pose_bones['Bone']

b.bone.bbone_x = 1 / b.length * ratio
b.bone.bbone_z = 1 / b.length * ratio


How to round multiple faces in Edit Mode

@JohnEason pointed it out. With the Looptool Addons it is possible.

enable Loop Tool Plugin in User preferences
Select faces
use Circle ub the editor tab


How can I change the size of a modal operator popup dialog box?

Just pass a custom width (integer) when calling invoke_props_dialog(operator, width=300) or invoke_popup(operator, width=300). The height is determined dynamically by the size of elements placed onto the props_dialog and there is no option to set it. From the docs:

Parameters

operator (Operator) – Operator to call
width (int in [0, inf], (optional)) – Width of the popup

Demo based on the code of How to call a confirmation dialog box?

import bpy

class SimplePropConfirmOperator(bpy.types.Operator):
    bl_idname = "my_category.custom_confirm_dialog"
    bl_label = "Do you really want to do that?"

    prop1: bpy.props.BoolProperty()
    prop2: bpy.props.BoolProperty()

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

    def invoke(self, context, event):
        return context.window_manager.invoke_props_dialog(self, width=750)

    def draw(self, context):
        row = self.layout
        row.prop(self, "prop1", text="Property A")
        row.prop(self, "prop2", text="Property B")

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

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

if __name__ == "__main__":
    register()

    # test call
    bpy.ops.my_category.custom_confirm_dialog('INVOKE_DEFAULT')


Is there anything like Arnold's Clip Geo in Cycles?

Apparently, it's doable only with a boolean? I think I saw a node setup once which was quite close but I can't find it anymore.
There's also Blender BIM which now I'm going to test.
But if anyone has a better idea, please, let me know.


Unable to attach bones to 3D model or create vertex groups

Have you tried linking your model to the rig using automatic weights? (i.e. By selecting your model first and then your rig, then pressing control+P, and then choosing: With Automatic Weights)
You could then vertex paint the weight of each bone individually by hand to your liking.


Wave texture change values by python code

You can access a node input sockets by either their name or their rank using their inputs property:
distortion_socket = wave_texture.inputs['Distortion']

or
distortion_socket = wave_texture.inputs[2]

Then you can set the value using default_value (the value not given by a link):
distortion_socket.default_value = 2


Managing/Reducing noise in a night scene

Scenes with many light sources (like this one) tend to be noisy because by default cycles randomly picks one light source to sample for every ray.

In such scenes a decent improvement can be gained by sampling all lights at once for every sample, by using the branched path integrator:

Note that I rendered at 50% resolution

I also:

Enabled clamping, which does a bit of what combining multiple renders with different seeds does (at least when you use a format like png). Note that direct clamping can cause some rather visible dimming of light sources, so see if you can get away with just indirect clamping.
Turned down the number of bounces to gain some speed.
Turned off reflective caustics to mitigate fireflies cast by glossy surfaces.

Here are some other things which may help:

See if you can reduce the number of light sources. For example, the street lamps have a mesh light and a point lamp. Try using just one or the other. For example you might make the mesh light only visible to the camera, and let the point lamp do all the illuminating:

Try and favor lamps over mesh lights where reasonable. Lamps can be sampled in a more optimized fashion. Don't feel like you have to replace every mesh light though, some places mesh lights are just there for a reason ;)
Enable multiple importance sampling on bright lamps/mesh lights or large surfaces which reflect a lot of light. I.e. relatively large contributors to the overall ambient illumination.
Disable multiple importance sampling on surfaces which contribute relatively little to the ambient illumination.
Make bump mapping only visible to the camera, to avoid slowing down sampling on indirect bounces where bump mapping makes very little visible difference.
See if you can get away with only using the environment texture for reflections:

The first frame shows the render with the environment map (visible in the preview), the second shows it without (world appears a solid color to the camera), and the third shows it with the environment map only affecting the glossy shader (solid color again).


Removing facets inside another object when they intersect (pictures included)

For anyone trying to do the same thing as I am here is my hacky way of solving it.  I first did a difference as quiliup suggested, and then did a union with the original small cube, and finally removed duplicates.  If anyone knows a more concise way to do this though I'd be happy to approve your answer.


Utilising the same one value for different variables

Add a custom property in your scene or your world, and use it to drive your transforms with the "Copy as new driver" and "Paste Driver" operators.

You can then edit the way the property is used by right clicking in the driven field choose "Edit Driver", and then "Scripted expression". You can use standard python expressions. Here we multiply the property by 2 :


Set the graphic card, before the first blender start. (Virtual Linux System)

Could it be, that the issue is caused, because blender required some sound card?
No, it is probably cause by an indirect rendering setting for the graphic card driver similar as mentioned here. The warning ALSA lib confmisc.c:767:(parse_card) cannot find card '0' is probably caused by a missing sound device, but can suppressed by ./blender -noaudio.


Exporting modular objects to Substance Painter for baking

It did work, when I moved all the UVs of the assembled asset by 1 to the right.


How can I get HDRI shadows in an Eevee scene?

First, the reason for the lighting difference is that in the scene you provided, everything is lit by a World HDRI only. Eevee by default can only produce shadows from Light objects, so even if you turn the respectable options on, there won't be any indirect shadows visible. This is a technical limitation. Duarte in the linked answer elaborates on this, so there's no need to re-iterate everything here.

However, there is a quick solution to at least get a lot closer to the Cycles render: Adding an Irradiance Volume Light Probe allows you to bake the lighting solution into the scene dynamically.

To do that, in the 3D Viewport use Shift + A -> Light Probe -> Irradiance Volume.

Scale it up to encompass the areas of your scene which are visible through the camera. After that, in the Render Settings, use Indirect Lighting -> Bake Indirect Lighting. The scene will jitter a bit while the solution is baked. Afterwards, it should look something like this:


Problem with legs and meshes in vrm model (bones)

One possible issue is that the meshes may possibly be linked to each other, so when you move/alter the mesh of one, the mesh of the other is moved an altered as well. You can try separating the meshes/objects.

Select the boot
Go to Object-->relations-->make single user-->Object & data

The other issue is that you may have somehow linked both boots to the same bone/armature.. You may have to unattach them and reattach them separately after making sure that only the materials/texture is linked, and not the meshes.


How to enable Intel denoiser using python?

I don't think the problem is with the setting not taking effect.  I think the node is there, you just need to reference it by name instead of index since the numbers you are using aren't working.
This should fix it:
link = links.new(render.outputs['Denoising Normal'], denoise_node.inputs[1]) # Denoising Normal
link = links.new(render.outputs['Denoising Albedo'], denoise_node.inputs[2]) # Denoising Albedo

There is a plugin on GitHub that does this: blender_instant_denoise. That's where I found the answer.


getting problem in point weighting in blender

This is caused by the "curve" parameter of the brush (in Photoshop is called "hardness").

In my example I've used 3 different curves, maybe you're looking for the second one (wich is the last preset on the right).

In the curve editor x axis is the distance from the center of the brush, y axis is the strenght of the stroke.


As one comment pointed out there seems to be a subsurface modifier active on the mesh making up the wood part of your house.

As you can filter if and how many iterations the modifier should apply, depending on whether it is a render or just the viewport, you should check in the modifier panel while having the wood mesh selected if any of this holds true.

The camera icon in the header means this modifier is active in the final render and the eye icon means that this modifier is active in the viewport.

In the example screenshot from the modifier the subdivisions are set to one (1) for the viewport and two (2) for the final render.


In the image above you see Particle Edit Mode offered. Weight Painting is also offered.  The yellow arrow points to

Textures Panel associated with a Particle System while the Cycles Render is offered. Blender has

Vertex Groups can control density and length as an abbreviated explanation
Textures can control density and length as an abbreviated explanation
Textures can have higher control Density than a low poly mesh
Weight Painting a Vertex Group. So weights can be [0.0 to 1.0 floating point],  .55 or .77 for example. This can be searched here at BSE. Again a video probably offers the best introduction to weight painting.

There are many BSE answers related to weight painting.  Weight painting will seem quite ordinary to you once you see 33 free minutes of training video on noonoob. What follows is some collection of ideas you may find useful after you see one of the many discussion and videos of weight painting in Blender.

Image above show Brush Panel in Particle Edit mode.  Comb Brush is selected.

Blender has a Particle Edit Mode for Hair particles.  So you may

Create a Particle Edit .. Particle Cache is the result of Particle Edit mode work. Videos are the dominant way of learning about this for many people.
Place hair anywhere by using Brush panel .. metaphor Hair painting ... using different brushes with strokes
Shorten and lengthen hair and Remove the entire Strand
Comb hair in a direction
Other Attributes can add Hair Children, Spirals
Distinct Meshes
Users often create separate well fitted meshes to limit placement of hair.

For plant life such as grass and the simple human hair crew cut, we can easily state vertex groups and textures are very useful. Such contexts are of low intensity inspection.  Casual, Quick and Dirty.

For highly styled human hair those two items may be less useful.  Particle Edit mode for hair is more precise. This tool is useful when we are in high intensity inspection contexts. I suggest you see a video on some famous website that rhymes with noonoob because hair styling can be quite complex.  I think video will be best once you know what search keywords are best.  This will need a few days to sink into the subconscious mind.

Suggested Keywords ... Hair Styling in Blender.

In the image above we see the Active Data of type Texture associated with a Particle System.

I am avoiding any tutorial content.  This is just perhaps a quick discussion for further research by the reader in the form of text and videos. Videos have an advantage for precise hair manipulation.


How to prevent 2 seperate meshes that have soft-body modifiers from clipping into each other and glitching, even if collision is turned on?

As with all simulations, start by ensuring you have ‘applied scale’ on each mesh and that the Normals are pointing in the correct direction.
Next, check the ‘cloth and soft body’ settings on each collision modifier - turn the Inner and Outer right down. If you still get intersections, turn the Inner up slightly until it is resolved (but not too high).
Also, you should avoid starting the simulation with intersecting meshes since this can cause very large forces at the start of the simulation.


How to remove easily the white areas which appears during texturing a surface with uv maps

Those white faces appear because they are not linked to the same texture as the rest of the model. This can happen if you for example add new faces after the rest of the model has been linked to the texture. Fixing:

Make sure the faces which are visible as white are actually unwrapped
Hit A to select all faces
In UV / Image Editor hit A to select all faces
In the bottom of the UV / Image Editor click the Select image icon next to either new/open buttons or the texture name, and select the image you want to use. (even if the field shows the image already, it might not be applied to all faces)


I had the same problem, and somehow fixed it by checking "Use Modifier Stack" under the "Emissions" tab in the particles menu.

Alternatively, this was also solved when I went to the object modifiers menu and moved my particle system above my subsurf modifier.

(I know this is an old question but I came across it when I googled the same problem, so hopefully this helps someone else!)


Dividing square columns into triangular prisms

Easiest way is to go back a little and erase part of what you have done f you really want them as separate prisms.

Erase all but the bottom faces, search for the operator Poke Faces Alt+P and it will automatically break them into triangles.

If you need each triangle extruded as a separate prism you need an additional step before extrusion.

Select all diagonals, using the Select Similar Shift+G operator > Direction option and then rip the edges with the Rip operator V. Do the same for the opposite direction and the square subdivisions if you had not done so before yet.

Then just extrude them back up to create the prisms


Metadata should give the following:

Time gives timecode as HH:MM:SS.FF (This will depend on the framerate you set in the render settings.)
Date gives the system date and time.
RenderTime gives the time taken to render the frame.
Frame gives the frame number.

You could affect the timecode by sliding your scene to the desired timepoint in the VSE and render from there.


Why is rendered viewport faster than rendering individual frames?

It is possible to make the final render almost as fast as the viewport render, but you might not want to. The viewport render sacrifices a lot of features in order to make it update quickly. Firstly, it uses Direct Illumination only, which means that it basically only ever calculates 2 bounces. It also has a lot to do with whatever modifiers you're using. If you have a subsurf modifier that is set to 1 subdivisions for view and 4 subdivisions for render, then your final render has to deal with x^4 more polygons than the viewport does, which is obviously going to take longer.

There's also a little overhead in writing the frame to a file and then loading the next frame to start rendering, which the viewport doesn't have to do.

Lastly, the BVH acceleration structure (selected in the render settings) can make a critical difference in render speeds. IIRC, the viewport ONLY uses Dynamic BVH which spends a lot less time calculating the BVH (because things might move around), but each sample takes longer.

Details:
There are two parts to the render: setup and sampling. The right setup can make sampling faster, but if you have to do some complicated setup for every frame, that might actually take longer than the time you save on sampling. The part of the setup that matters is the Acceleration Structure, called a Bounding Volume Hierarchy (BVH). This is basically a way of organizing things so that they're easy to find. You can either have a Static BVH or a Dynamic BVH. A Static BVH takes longer to build, but makes sampling more efficient. The Dynamic BVH doesn't take as long to build, but it doesn't make sampling quite as efficient as Static. The other important difference is that with a Static BVH, nothing can move*. If anything moves, it has to be totally rebuilt. Whereas with a Dynamic BVH, if something moves from one frame to the next, the BVH can be updated much more quickly than with a Static BVH.

IIRC, there are also some features that aren't rendered at all for the viewport. I want to say that SSS, AO, and caustics aren't (or weren't) calculated at all for the viewport render. But I'm not sure what they are.

*To be honest, I'm not quite sure what "nothing can move" means, I just get this from the tooltip. You'd do well to do some research or experimentation. It's possible that a Static BVH can be reused even if objects translate, so long as the mesh doesn't deform. It's also possible that any change of any object from one frame to the next requires a complete Static BVH rebuild. I'm not sure.

I hope that helps!


Cant render black sphere, it always appears to be grey

You don't need a black sphere around your scene, the world settings do the exact same thing.

Then it is not the color on the material of the object, but the environment that you need to change.

By default blender will have the environment set to a gray tone, preventing dark shadows (think of it like trying to get dark shadows on an overcast day, the light of the environment will make the shadows less dense).

Making the Environment completely black will mean that only the lights in the scene will illuminate the objects, there will be no ambient light.

But why are you not seeing the black sphere but the gray world as background? is really the question.

When the camera is looking at areas that have no objects you will see the gray environment as background for the scene.

Most likely the sphere is at a distance that is farther than the clip distance of the camera, so it is being ignored, and what you see instead is the color of the background set in the world settings.

To understand clip distance read: How do I increase the render distance?


Parts of my model are a different color to the rest

okay i already got it  by extruding the mesh it with e (like duplicating).
notice that you should mark all faces, if you have the same problem.
llink to discription: Why are some faces in my mesh darker?


All you need to do is change the origin by pressing Ctrl+Alt+Shift+C > Origin to Center of Mass.

What is happening is the physical representation of the mesh is confused by the non-symmetrical mesh, it instead calculates it as if half of the mesh is below the origin, making it very bottom heavy.


Icecream close-up - What nodes am I missing?

I tried to get closer to your reference, but checking real shots it seems to me I just multiplied wrong interpretation of reality. Of course it has hundreds of possible looks, but version in your reference looks weird to me ;) Anyway ...

Wave texture can't create a zebra strips, that is what I see as bigger breaks on surface.
For that I based material on Gabor texture, it's OSL texture (so only CPU and Cycles shader). Gabor texture is part of Templates in Blender's Text Editor.

Later I will add blend file to test it. If you need more details let me know.


How can I cut an edge at the mathematical middle?

Subdivide the edge

Subdivide the edge by clicking Subdivide on the Tools Panel (T key) or by searching the Subdivide operator in the Operator Search (space key)

The edge is cut in 2

Now the edge is cut in 2 by its middle - a new vertex is added.

How have more cuts?

If you want to have more vertices equally distributed, simply change the Number of Cuts in the Subdivide properties


I can't add or subtract weight paint from some parts of the mesh

Just tried your scene: apply the mirror modifier on the mesh so the right leg becomes 'actual' geometry...
Cheers!


Clothing modifier is pulling clothing up instead of down

There are two things that might be going on.  One is the collision size of the mesh collider:

Here my mesh collider's "outer" setting is so high that my cloth floats above it.  If that's too high, your cloth won't ever cling to your body.

The other thing is that your dress is too small.  It's about as wide as the cross section of the model, but just like a circle has to be pi times bigger than its diameter to wrap around, so does your cloth have to be about pi times bigger than your body to wrap around.  Your dress tries to minimize the size of the sewing lines, and to do that, it scrunches up at the waist, pulling the rest of the dress with it.


White balance / color matching between video/render for vfx shots

Trying to match the placement, intensity and quality of the light sources is a good start. As for the color temperature, if the white balance was compensated in the camera for the original footage, then the white point for the scene is already in a different place, so you no longer need the original color temperature. Your light sources in blender should be achromatic (without color, or "neutral").

The crucial piece of information you need is: What color space is the original footage using? How is the scene encoded (Log, Linear? Is there a gamma correction baked into the footage?)

Blender generates scene referred data, so your video sources should be converted to the same kind of information. Make sure that you are converting the source from display referred data to the proper scene referred values to be used in blender's compositor.. In other words you need to make sure you are not mixing apples and oranges.

Once the data is in linear, scene referred values, you can use the CDL node in the compositor to match color, brightness, etc.

I would advise to stay away from curves in the color management section. It will open a new can of worms that might distort the results.


Delete selected particles and their trajectories

As far as I know, there is no way of deleting individual particles.

BUT - possible workaround:
In particle edit mode, deselect "Keep Root", hover your mouse over a strand, press L to select the whole strand (you'll have to repeat this for every single strand) and move them somewhere else. They'll still be in the scene, but out of the way at least.


In Blender 2.8 how do I render the world once for all view layers?

You can get precisely what you want by creating a dedicated, empty background render layer with an environment pass.
1.) Under "Render properties" on the "Film" panel select "Transparent". All of your current layers will now render a transparent world background.
2.) Create a new layer and disable ALL collections in the Outliner. In the "View Layer Properties", enable an environment pass.
3.) Now in the compositor, use an "Alpha Over" node to put everything above the "Env" channel of the background layer we just created.


You can have multiple curve modifiers per object and control what each of them deforms with Vertex Groups.

Join all your meshes into a single object (preferably the arrow at the center of the scene).

Then create one Vertex Group for each deforming curve you wish to have. Assign the desired vertex of the mesh part to each Vertex Group corresponding to a curve.

Then proceed to add one curve modifier for each curve, limiting its effect to each one of the previously created Vertex Group.

Afterwards add the curve objects one by one making sure you align their centers with the mesh object so they match perfectly; and aligning them to each part of the mesh they will be deforming, so they don't deform the in unexpected ways. Assign each curve to one of the Curve Deform modifiers.

You can also connect the faces, and remove the top vertex from the vertex groups in such way that deformations wont affect them, but it is then up to you to control the curves sensibly, otherwise extreme deformations may lead to weird results

One way you could do the 45 degree connection would be by using the Knife Project operator, then pressing C to activate Angle Constraints and snap to 45 Degree increments. From there just cut the relevant geometry and proceed to delete all surplus faces and rebuild from the remaining vertex.


When a real human arm moves up, this is in this way :

Not in this way :

I think this is the main problem here.


Bisect tool has the Plane Normal option in its settings. It consists of 3 sliders for each axis with values between -1 and 1 which allow to control the orientation of the cutting plane.

The values below or above 0 will make the custom plane to be oriented towards that axis, while values of 0 or around mean that the plane will be oriented along that axis.

In your case enter 0 value for the Z axis:


Animate a travelling wave - graph view like an oscilloscope

UV Warp modifier (first approach) shifts, scales or rotates the UV map of an object depending of the relative positions, scales or rotations of 2 other objects (generally, you can use empties for these two objects).

So here, if we move one empty, the UV map shifts and so the texture of the plane looks like it was moving.

Here is the setup :

Create two empties : place one of them on X=0 (that will be easier later) and the second one elsewhere
Add the UV Warp modifier to you plane, like this :

And here is the setup of the plane material :

UV unwrap the plane and adjust the UV map to the sinusoid shape on the texture
Use this texture to mix two shaders : one for the red line and the other one for transparency

The transparency is need to show some grid behind the curve when rendered :

At this step, you can move one of the empty and see that the curve seems to move on the plane.

Now the red dot :

Create the dot (a plain circle for instance)
Place it on the border of the plane
Add a driver to its Y position
The driver need to be dependent on the X position of the empty, and to follow a sinus function

As the UV map is 0 to 1, the UV map shifts of 1 when the empty moves of 1 unit. So we need to multiply the X value by 2 PI.

The setup is the following (can be seen in the graph editor, in drivers editing context) :

Edit : another approach
You can also set up Cycles nodes to draw the curve directly. The main interest here, there is no need of a "static" texture.

Here is an example, made rapidly and so to enhance (using more calculation via drivers, instead of doing it with nodes, surely).

The principle is the following (quickly described) :

Add a keyframe to an input value (to define the speed of the curve)
Use it in the node editor to calculate where the sinus is depending on this value
Use the result on a mix shader node to output red or white, and so draw the curve

Here is this second blend file :

This is to enhance : more calculations need to be done outside of the nodes (using drivers probably), so that math expressions are more accurate and the nodes setup simplified.


Blender 2.8 Less Saturated Colors in Material

If you want the render to show exactly the color of it, you will need to directly connect an RGB node to the surface socket of output node to avoid any other calculation of final color.

And if my memory is correct, default view transform calculation behavior is changed in 2.80 Cycles. Did you accidentally change it away from default setting?

If some of these value is not as same as the screen shot, then it will cause the color picker not able to retrieve the original color.


Why is Eevee giving low res animation output?

Set your video quality to high or lossless. A Bloom effect with dark and redbackground is really bad for image compressing method. Which tend to output a bad resolution or the image if the size of the file did not change.

If you want to make video like a professional artist, you might want to check out how image are stored in each format like jpeg, png, bmp, gif, h.264, h.265 and so on. (Notice that I did not mention mkv and mpeg(mp4) because they are container which work as a directory.)

And you might want to save your video in "Image" format to preserve the best quality while editing video sequence.


Use masks as part of materials in cycles

No, the MCE or UV/Image editor's masks will not translate upwards to the 3D view.

They occur in the post phase of Blenders sequence of operations. Also I am told that its to hard to make a rasteriser for arbitrary material parameters. I guess they would have to operate at screen space?
You can see a more thorough breakdown of this at my blog.

The work around is to use Curve objects edited to an appropriate shape. You can use the tracker to map Hook objects in the camera view, these can be used to distort the curve object. Then project your texture onto the object as required.

Use an empty to control all dimensions.

You might notice that you cannot have a feathered edge for the same non rasterising reason. You can place a beveled glass object above then use its transmission ray to to fake a falloff, but you will be stuck with the shape of that object not your mask.


Custom Properties in space_data or region3d

See this answer for a listing of classes which support custom properties.
Neither Space nor RegionView3D derive from ID and are not treated special and can not have custom properties.
Screen does inherit and might be a candidate. You might identify an area by its index or its hash.
The former should work with loading/saving the screen from/to the *.blend file.
The latter might persist during changes to the screen layout at runtime.


A set of edges must fulfill some prerequisites to work as an edge loop. To simplify: they all must be connected in a row, part of a surface, and surrounded by quads.


Execute operators from Python at start up

Background Info...

Blender intentionally prevents you from manipulating the scene at startup, this is because it is rarely useful and you end up running into issues - like loading a blend file immediately overwrite any changes you have made.

Other data such as the user preferences can be manipulated since this persists across different blend files.

1. Explicit Execution

So, if you want to do this, you can use a command line argument to run a text block in your startup.blend:

blender --python-text lamp.py

Or you can reference a path directly:

blender --python /path/to/lamp.py

This way you can control if the script runs before or after loading a blend file.

# add the lamp to any blend you open
blender example.blend --python-text lamp.py

# add the lamp, then overwrite it (not useful in this case)
blender --python-text lamp.py example.blend

The main drawback for this is it needs to be added to some startup script or launcher, or manually entered into the commandline each time you start blender.

2. Using Callbacks

Heres an example of a script you can place in startup/ which adds a handler that can manipulate the scene how you like.

import bpy

def load_handler(dummy):
    bpy.ops.object.lamp_add(type='POINT', view_align=False, location=(0.0, 0.0, 0.0), rotation=(0.0, 0.0, 0.0), layers=(True, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))

bpy.app.handlers.load_post.append(load_handler)

This is another example which keeps the handler active but only executes on new files.

import bpy
from bpy.app.handlers import persistent

@persistent
def load_handler(dummy):

    # only apply to startup
    if not bpy.data.filepath:
        return

    bpy.ops.object.lamp_add(type='POINT', view_align=False, location=(0.0, 0.0, 0.0), rotation=(0.0, 0.0, 0.0), layers=(True, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))

bpy.app.handlers.load_post.append(load_handler)

This may seem overkill for such a simple task, but when you consider it gives you the ability to execute code on any newly loaded file, its quite flexible.


Yes, I actually had two spheres in the project, I had the wrong one selected. Thanks!