How to enable CUDA rendering without running as root?

Unfortunately I don't have nvidia/cuda on my system, but I happened to notice information that most likely will solve your problem.
See this link first about information how to install nvidia drivers and enable cuda just to check that you're setup is fine.
And then have a look this forum post where
Nusaman is using blender with out root (forum post #12).

To recap:

make sure that you have latest drivers installed. (Nusaman used: cuda-5.5.22-1 and nvidia-334.21-2, but he's using archlinux)
Start blender or some other cuda program (like cudaminer) as root.
Then close that program (could be that firts render something with blender+cude as root)
Start blender as normal user

What I gathered from multiple sources is that nvidia cuda drivers need to be loaded and for some reason initialison of cuda needs root, but will work with normal user after that.

Please note that you might need extra dkms and dev packages also, to get this working.


Why are cuts made with BoxCutter appearing as objects in an Octane render?

Are you applying the modifier from the cut before rendering?

It looks like Octane is rendering the shape created by Boxcutter, which exists in non-destructive model until you click Apply.


Hide an object from reflecting in the ocean modifier

You could use the Compositor or try this kind of node setup for your grid material: Use the Input > Light Path > Is Reflection Ray as a factor between the original material and a Transparent node (you'll need to give your material a Settings > Blend Mode > Alpha Blend):


Why when I'm inserting a key frame it's adding only 1 but in the tutorial it's adding 4 ? How can I make it to insert 4 keys like in the tutorial?

So the answer is: You only need the one key frame to achieve the desired result. : )
But I looked at your file and here are some tips to help make this work:

After you insert a keyframe on the Offset value 0 of the Follow Path constraint, you might also want to insert a keyframe on the Offset value 100 at another frame in the Timeline.  Here it means 100% of the path is traveled, so The difference between the Timeline frames will determine the length of one cycle ( how long it takes for the light to go around the curve once)

Press Numpad 7 before you change the shape of the curve, otherwise you might also move its vertices in the z axis (and change their height), which could change things in an unwanted way.

Before you add the light (and also the curve actually) to the scene, press Shift + C to move the 3D Cursor to the center of the scene. Then the light will be in the will be better aligned with the curve and the "moving in a very small area" will be reduced

Alternatively you can move the light close tho the curve and check the box next to Follow Curve in the Follow Path constraint. This will allow the light move either around or inside the curve depending on the distance between the light and the curve. (If you have the box checked next to Relationship Lines in the Viewport Overlays menu, you can see a dotted line between the light and the curve indicating this distance.)

Hope that helps : )
Edit:
I also realized the answer to the actual initial question : ) Why does it sometimes look like more keyframes are added? If you extent the panel on the left in the Timeline window (by clicking the tiny ">" icon) it will show a Summary of used keyframes. If you extend this summary, more diamond icons will be shown but they are the same key frames by a different name or UI location. If the summary is extended and the panel is hidden, it can give the illusion more keyframes are added.


I am the author the addon.  I will update the google site to point to the github repository.  The addon has not been "abandoned" but it is certainly not actively maintained or developed heavily.

https://github.com/patmo141/odc_public

Thanks,
Patrick


Why is the texture scale changing randomly between frames in my animation?

It has to do with the Motion Blur's Shutter value, it is set to 0.5, if you choose 0.4 or 0.6 it works, I can't tell exactly why though  ;)


How to model the needle/spiral of a badge/button?

You can use a Circle and a Screw modifier :

Note that the object origin will be used as the screw axis, that's why I offseted it in my picture. But you can also use an Empty as an axis, just use the AxisObject field for that.


The Blam Image BackGround Not Showing in 3D View

You must manually add the image.
press N to spaw the view properties menu in the 3D View - Object Mode. In there, locate a check box that reads, Background Images ( It's around the bottom). Drop it down and enable it. Click on add images, locate the photo you used in BLAM and you should have the image visible from the camera view.


Principled BSDF + Substance Painter: change metallic colour

It works fine for me when I export textures with these settings.

The main difference between the textures I exported and those you provided is the base_color.

In the textures you shared

When I exported


Certain editing operations that add new vertices can change vertex order in the model, which breaks certain things (shapekeys, baked physics sims, combed hair).

There should be an option under particle settings to clear the particle edit (i.e. the combing) from the hair so you can do it again.

In general, you shouldn't add hair until you are satisfied with the mesh and don't intend to add to it. Another way of handling this is to duplicate and separate the parts of the mesh that you wish to add hair too, and add the hair on them rather than the original model. You can then make it so only the hair and not the new mesh sections get rendered in the particle settings.


Animate restriction of viewport visibility/rendering of a group of objects

Drivers are actually not much different to using keyframes. As you know, keyframes allow you to specify the value of some property at specific frames of the animation and blender fills in the values on the inbetween frames by a method of interpolation. Drivers effectively do the same job but rather than specifying specific fixed points along the animation (as you do with keyframes) you, instead, define the rules for how that property varies. This allows you to do much more than you could do with keyframes such as make one property directly dependent on another. For example, you could vary the scale of one object based on how close another object is to it - simply by defining the rule (eg, scale = distance / 10). You can also add modifiers to the driver output - for example, you could use the frame number as the basis of a driver and apply a sine wave to it to vary some property over time - very useful for getting something to pulsate, which would be extremely cumbersome via keyframes alone.

To create your first driver simply start a new blend file (with the default cube), click into the X location property field of the cube and enter #frame (the # is a shortcut for creating a driver and 'frame' is simply a reference to the current frame number). If you now step through the frames you should see the cube shoot off along the x-axis. (If you don't then you probably got a warning at the top of the screen that "auto-run" is disabled - this is a safeguard to prevent scripts being run when you don't want them to - go into File/User Preferences and select the File tab and enable the Auto Run Python Scripts checkbox to enable scripts)

Once you have created the driver you can configure it via the Graph Editor window by changing the 'Content' in the toolbar (at the bottom of the graph editor window) from 'F-curves' to 'Drivers'. Press N to see the properties panel and details of the driver are shown. The driver has a 'value' shown in the Drivers panel and you'll see that vary as you change the frame. An f-curve is applied to that value to allow you to more easily vary how it affects the actual property. If you scroll down to the Modifiers panel you can add a Built-in Function - try a Sine wave to get your cube oscillating.

Of course, this doesn't directly address your original problem. However, once you've got a grasp of drivers you can hopefully apply that knowledge to manipulate the any other properties (such as visibility) as you require.

EDIT : I believe I've managed to achieve what you're after as follows :

Start a new blend file.
Select the default cube.
Right-click on the Restrict View icon in the outliner and select 'Add Driver'
Add a new object to the scene - this will be the 'controller' object and will be used to hold the properties you'll manipulate later.
On its Object settings, add a Custom Property.
Edit the property and set its value to 'True' and its name to 'CubeVisibility'.
Select the cube.
Open a Graph Editor window.
Change the mode to 'Drivers'
Select the driver on the cube.
Open the Properties panel by pressing 'N'.
Scroll down to Variables - there should already be one named 'var'. Change it to 'Single Property' (leave the name as 'var').
Set the object field to the 'controller' object you created earlier (you can use the dropper to select it from the 3D view)
Set the Path to '["CubeVisibility"] (the custom property you created earlier)
Scroll up to the Drivers section and ensure it's set to 'Scripted Expression' and Expr set to 'var' (as an alternative, use Average Value in place ofScripted Expression and then you don't need the Autorun Python Scripts property enable in the user preferences)

That should be it. Now go back to the 3D scene and select the 'controller' object and scroll down to its Custom Properties. Changing CubeVisibility between 1 and 0 (True and False) should cause the Cube to show and hide.

To apply the same to multiple objects, right-click the Restrict View icon of the cube in the outliner and select 'Copy Driver'. Right-click on another object's Restrict View icon and select Paste Driver and the driver will be replicated on the other object. If it doesn't work immediately you might need to select the driver in the Graph Editor and click 'Update Dependencies' for it to pick up the changes - although saving the blend file and re-opening it should also update all drivers automatically.

Hope this helps.


Trying to copy objects across scenes but it duplicates my scenes instead (BGE)

"L" means the data is linked. Typically it is linked from another file.

I never used ctrl+c and ctrl+v. Maybe because i usually do not copy objects between different scenes (but move them). I tried it and it worked as expected. So I cannot confirm the behavior you describe.

Another way to copy an object:

To get objects from one scene to another I suggest:

select the objects
link to the target scene ctrl+L Objects to Scene .../target scene
switch to the target scene
make single user U (Attention: the name will change)


How do I stretch my object from one point to the other?

I think you can solve this with snapping and transforms with cursor as pivot. I tried to rebuild a situation similar to what I see in your picture, so that the truss is of different size and rotation than the other shape:

First of all, switch to top view, and activate vertex snapping like below:

Then, translate the truss towards the other shape, and snap a corner vertex as below:

Then, go into edit mode (of the truss) and select one corner vertex, then snap the 3D cursor to it.

Now you can activate cursor pivoting, and rotate the truss

...until its upper vertex snaps to the other shape, perfectly:

Now the different angle is gone, and you can switch to front view, to stretch (scaling) the truss until it matches (snapping) the other shape perfectly:

Does this solve your issue?


I suspect you've selected another pivot mode:


Add camera shake to a camera with track to mod

Create an empty, set it child of the moving object, set the camera track to constraint to the empty, then add some noise to the Z loc of the empty.
To do this set a starting loc keyframe, then in the graph editor select the Z loc channel of the empty and add a graph noise modifier.


Blender + Captivate - Transparent Flash Video

You cannot render with alpha straight from blender.

Follow the steps:

• Render the frames to PNG with alpha RGBA;

• Open the images with Adobe Flash or any software that you can import the sequence of images (Handbrake,VirtualDub-1.9.11, Quicktime Pro) ;

• Use the option inside flash:

• Save to MOV with compression type like PNG;

• Encode the MOV with Adobe Media Encoder mark the encode alpha channel;

• Import the FLV generated inside Captivate, naturally your output must be SWF not HTML5.

You cannot export sound of course cause your rendering images, that´s the only solution for now!

When I use videos inside CP and my output is HTML5 I usually use the same background on the motion graphic and the CP background to make the course seamless. Like this screenshot:

And this is are a few FLV´s done using the workflow above and published as SWF (Steve Jobs moves on the grave when the word is pronounced hahaha).


Why do I get weird rotations in exported FBX?

When exporting, different formats have different space formats. Usually it's just a case of the axis getting mixed up.

There's some help here, but generally I'd suggest skipping exports if possible.


What values should I use for light paths?

There is no works-for-everybody setting. Basically it's a trade-off between render speed and image realism.

I would suggest to turn down each number of bounces to 0, just so you see what happens then. Then start increasing one of the numbers, and see how it affects your image. The aim is to keep the numbers as low as possible (to get a fast render) while keeping them high enough so that the image looks the way you want it to.


How do I fix a defect in the freestyle render if there are no apparent causes?

To fix this problem in Blender, I added my claw, which was the cause of this issue, into a separate collection by pressing M in the viewport and selecting New Collection. After this, I renamed the layer where all my objects were then, I created two additional layers. Then, I went to each layer and hid the object that I didn't want in that layer  by right-clicking that collection and going to Layer and clicking disable from View Layer. I went to each layer's properties and checked Use for Rendering under View Layer. I added a new freestyle line set for the two new layers and clicked on the box that said collection, then I marked the collection that I wanted to have the freestyle lines on, which was the object visible in that layer. Afterward, I went to the composite tab, added an additional render layer, and plugged both layers into an Alpha Difference node. I hit render and turned the images into a sprite sheet in another software. Here is evidence that the problem was fixed:

BTW this is in Blender 2.92, so to create a new layer, you must go to the very top of the window, and right next to the Scene selection buttons, there is a set of layer management buttons. All you have to do is press the button that looks like two papers stacked on each other to make a new layer.


When using keyframe_insert() you want to use it on the object that contains the value you wish to keyframe.

By "object" I am referring to python objects (as in "object" oriented programming) that are defined in a python class, not the visible 3d objects. In your example the object that has the value to be keyed is the modifier.

So to keyframe the count value in the array modifier you want to use -

obj.modifiers['Array'].keyframe_insert('count')

You might also think of it as the class containing the property to be keyframed is the one that gets told to insert the keyframe.

As mentioned by pink vertex you can also go through the parent by using

obj.keyframe_insert('modifiers["Array"].count')

Note the quotes " must be inside ' - swapping them around doesn't work.


Is there any way to erase very thin lines in blender 2d?

Select an erase brush of type Soft/Hard.
Adjust brush settings.
Click and hold LMB or use the Pen tip to delete strokes on the viewport.


Overview:

The thing you are struggling here is a Pivot center for rotating/scaling.

In your situation as you stated that model isn't yours we will need to manually place 3D Cursor at the desired spot and then switch to Pivot center: 3D Cursor and we are good to go. Normally when you are creating such shape it is (mostly) in the center of the scene so the first steps wouldn't be necessary.

Steps:

Grab two vertices on the inside of the mesh like in the gif.
Press F to make an edge and connect them.
Press W > Subdivide to create vertex in the middle of created edge.
Turn on Vertex Snapping.
Press G > Y and hover mouse over the bottom most Vertex. Repeat with X Axis.
Shift+S > Cursor to Selected to place 3D Cursor where we've moved our vertex.
Delete this vertex, it's no use now.
Select Pivot center to 3D cursor.
Select inner/outer edge loop and Extrude/Scale or both.
Optionally go to Object Mode and set Origin Point to the 3D Cursor, it should help later on. Do this by pressing Ctrl+Alt+Shift+C.


Did you put your graphic card in your blender’s settings ?
Putting it in your render settings won’t make it use the graphic card unless you’ve specified the card in blender settings :

In system tab, change the computing device to CUDA and select your graphic card.
Don’t forget to save the settings :)


There is no support for gestures.
The one thing you can do is go to edit -> preferences -> input and turn on Emulate 3 button mouse to hold alt leftclick instead of mouse3. But still, no gesture support for pinch to zoom etc.
If you have a stylus I'd recommend binding mouse 3 to one of your pen buttons.


Creating a door: scale vertex group independently

Although it depends on what you make it for, it may be easier to use shape keys instead and control them via drivers.


You have to join the objects together and then apply the modifier and then you can separate by loose parts.
Or

Add the modifier to one object.
Select all the other objects and then the one with modifier last.
Then Ctrl+L to copy modifiers to all selected objects.


Texture not applying correctly in Blender

If I understand your requirement correctly you want to map the face image onto one face of your object, and color the rest with a simple color where the image is transparent?
It can be done with simple UV Mapping, and using the Alpha channel to drive the mixing factor.


I can't move, rotate or scale in blender 2.8 object mode

It appear you have accidentally selected to move the Object origins. This is only available in Object mode, hence the difference. Unless you are wanting to move the origins, turn it off.


why Imported fbx tga from UE4 look black?

You are having this issue because texture parameters in the materials are set wrong, instead of using the texture as diffuse color it is used as normal value.

To fix that, in each texture enable Color influence and disable Normal influence on the Geometry


Alrighty, lets jump into it.

First of all, those weird spots in the render were perfectly normal. If you zoom in, you'll see that they're actually triangles- this from the fact that all n-gons are actually sets of tris. You can solve this by adding a subdivision-surface modifier.

Now you don't have those triangles, but you get a different effect: looks like quicksilver.

Now, this is mostly just a modeling error because two sides of the blade converge momentarily in the center, the area of the sword commonly called the bloodlet. This creates a zooky effect that is the combo of z-fighting and bad unwrapping.

To fix, I changed the subsurf mod from catmull-clark to simple.

You still get a bit of whack, so go into modeling and put some air between the inside edges of the bloodlet, rather than allowing it to be 2D. Then unwrap the model. This should fix everything. It needed to be unwrapped because your texture was repeating to much in the bloodlet because there were more vertices then around the rest of the blade.


How to undo  in Object Mode? Green color selection

Ctrl+G adds selected objects to a new Group

Objects belonging to a group show up in green.

Shift+Alt+G removes active objects from a group.

If more than one object is selected and when you press Shift+Alt+G but only one of them is removed from all groups, then afterwards press Ctrl+L > Groups to remove all selected objects from all groups.


Subdivision surface modifier displays strange results

Add a face inset once more to get the flat top. See this image.


This is a new feature in v2.70. It looks like someone missed to add it to the release notes despite this being a pretty noticeable change.

Proposal / discussion:
https://developer.blender.org/T37761

Commit:
https://developer.blender.org/rBdde5e5ce2581ffd544b442c58d6eefbc1ff61772

AFAIK there is no option to change it other than compiling without this pragma def: USE_NUMBUTS_LR_ALIGN (see above commit).


Each pair of bones need to have the same name with the suffix .L for the left side and .R for the right side. E.g. UpperArm.L and UpperArm.R. In the weighting Options of the tool panel turn on "X Mirror".


Is there a way to duplicate objects betwenn two objects?

If you only want to do a single object between two existing objects, you can use 3D cursor snapping. In object mode, that is respective to the object origins.

So you'd pick the two objects you'd want to place the new object in between. Then snap cursor to selected. (This places the 3D cursor at the average position of both object origins.) Then pick and duplicate an object. Then snap it to the 3D cursor location.

By the way, the default menu option for 3D cursor snapping (2.7x) is Shift+S.

Alternately you may want to look into the Oscuart Tools add-on. It allows distribution of objects. That may function more closely to what you're wanting. I'm not exactly familiar with the workflow involved there, but it'd be worth looking into.


How to maintain multiple cameras with different resolutions

This kind of situation is best handled with Python in my opinion since it's so simple to tweak and you can keep working on just one scene.

This simple script would change scene resolution, change camera (perspective/orthographic views are set within the camera), and start the render:

import bpy

bpy.context.scene.render.resolution_y = 1110
bpy.context.scene.render.resolution_x = 870

bpy.context.scene.camera = bpy.data.objects['camera1']
bpy.data.scenes['Scene'].render.filepath = "C:/Test/"+"orthographic"
bpy.ops.render.render(animation=False, write_still=True, use_viewport=False)

bpy.context.scene.render.resolution_y = 220
bpy.context.scene.render.resolution_x = 360

bpy.context.scene.camera = bpy.data.objects['camera2']
bpy.data.scenes['Scene'].render.filepath = "C:/Test/"+"perspective"
bpy.ops.render.render(animation=False, write_still=True, use_viewport=False)

To use make sure you change the resolution numbers, match the camera object names, change camera object to perspective or orthographic, match the 'Scene' to the name of your scene, change the filepath C:/Test/ to wherever you want to render.


Using TinyCAD XALL feature while keeping faces and their assigned materials

Materials are specifically assigned to faces and faces only, edges can't hold any information about material slots.

If all faces are removed and no renderable geometry is left behind then all material slot assignments will invariably be lost, there is no way to recover material information from edges alone.

This is not a problem specific of TinyCAD or any other addon for that mater, it is just intrinsic to how the data structures work in Blender.

As far as I know there is really no way around this.

You may alternatively try with varying degrees of success using Edit Mode Boolean operations to try and find intersections without loosing the faces; or use tiny cad on a duplicated copy of those edges instead of the original ones attached to faces.


Create a vertical plane, the pivot point have to be on the side of it.
Add a screw modifier
Select the first frame what you want on the timeline, type in 0 for angle, stay the mouse above the "Angle" box then hit "I"
Select the final frame on the timeline type in 360 for angle, stay the mouse above the "Angle" box then hit "I"

Fill the ends:

Duplicate the plane twice, delete the modifier from the new ones and add the same values on the same frames for the Z rotation as the screw modifier has, like you did it in the 3. and 4. steps.


Detect if characters are selected in text editor

The selection spans from line current_line_index beginning at current_character to select_line ending at select_end_character.

If these coincide, there is no character selected.

So given you know the line and column of your character you can check yourself.

However current_character and select_end_character are byte offsets.
Python uses unicode points. So unless you are using pure ASCII you need to convert the char position to byte offset.

See https://en.wikipedia.org/wiki/UTF-8

The conversion is a bit cumbersome. Something like

from itertools import islice

txt_line = "\u03A0\u2764\u2600\u2602This is a Test"
col = 9
print(txt_line)

ubounds = [0x80, 0x800, 0x10000, 0x110000]
offset = 0

#char is actually an immutable newly created string...
for char in islice(txt_line, 0, col):
    code_point = ord(char)
    for size, ub in enumerate(ubounds):
        if code_point < ub:
            offset += size + 1
            break

print(
    "byte at %d: %d - char: %d" % (
        offset,
        bytes(txt_line, 'utf-8')[offset],
        ord(txt_line[col])
    )
)


Imho, just seeing how many answers and comments you got, should say something about why more detail are needed :) but, since currently the blender manual seems to be somehow missing examples and more details, let's see if this helps:

You can split ANY strip in the Blender Video Editor (VSE), when the cursor (current frame) is over it, but in two different ways: "hard cut" and "soft cut". This also applies to video (movie) strips.

"hard cut" means that the the strip will be separated in the cursor point in two smaller clips, that became then independent, and each has only the strip frames that the cut left to it, depending on the cursor position.

Then, you can move each strip even to other channels, but if you try to extend (dragging the side triangle handle) the smaller strips toward the "now missing" part of the movie, while possible, will show nothing more, of course, since the missing frames are now gone, and the strip background will be accordingly drawn transparent:

(using the transparent part in your edit will render a "frame freezing" effect - showing last possible frame from that side of strip - on the left side it will bethe first possible frame, on the right side it will be the last possible frame)

"soft cut" means that the the strip will be still separated in the cursor point in two smaller clips, that became then independent, and they will appear identical to the "hard cut"...

...BUT, while each will appear trimmed to only the strip frames that the cut left to it, depending on the cursor position, as in the "hard" cut, they will instead "keep" also the "missing" frames, just hidden (the strip has really been duplicated and both copies trimmed to show just what was expected by the cut position).

And when you drag their ends towards the "missing" part,

The "missing" frame are still there, and they reappear! So, in a sense is a less definitive cut, and you can still change your mind later, or use the same portion of the original video in boths strips, if you need.

(of course if you extend beyond original length, you will get the usual effect of frame frezing from then on, as in the "hard" cut)

I hope this answers your question :)


You may use a texture node in your materials
Are you using Cycles render ?

Cycles render - Solution:
You may follow the following steps

Add two materials on eye, one for eye base and one for the eye ball

Modify the eye ball material as shown below

Then un wrap the faces ( by pressing U key) as shown below


By UV-unwrapping them correctly.

Without UVmap the textured object appears all made of one color (a sort of average color of the texture)

By unwrapping the geometry in proper way (in this simple case, just a basic unwrap is enough) you'll be able to se the texture cover the plane as expected.

Notice that the Uvmap in the uv/image editor has the two triangles located in a way that reflect the faces topology.

Resetting the UVmap brings all the faces to cover the whole texture..so the triangles are both in the same location, overlapped. So each faces show the same part of the mesh, leading to the behavior you step onto.

Notice how the vertex order of the faces determines an unexpected rotation of the textures on the geometry. This brings a discontinuty in the textures which now don't follow anymore the mesh. Every face has it's own UV.

You have to re-unwrap them.


Subdivision Surface Modifier partly closes holes

Subdivision Surface will virtually move your edges and create intermediate ones in order to smooth the whole shape. The part you show is only made of one big face with a hole in its center. In its try to smooth it, some vertices will be created in the hole area, which will give bad result. Here is what it gives with a simplified version (without and with the modifier):

If you cut your face the thing won't happen any more:

In your case you could fix it with this kind of topology:


One way is to enable Quad View.

From the 3D Editor: View menu > Area > Toggle Quad View.

Key board short toggle = Ctrl Alt Q


As others also said, yes, and more: there here are two 32bit windows versions: a .msi (installer) and a .zip (archive). You could detail more what is "not working" for you, and any error messages you get, that would help understand what is causing your Blender to not work.

As an advice, since installing .msi can have issues sometimes, try the .zip version, it should work out of the box, just unzip it anywhere ad launch the blender.exe inside. If that blender works, it's just the .msi install process having issues of some kind...


In the current development of my own Blender AMV, I answered a similar question in another post. Have a look and see if this helps.

Tips for creating an animated music video?

Read through it before continuing to read this answer.

Once you map out your song with the drum beat and place it in Blender, you can scrub through your drum track and manually animate the lights. I know that you can keyframe their values, meaning you won't spend as much time animating each light.

And an idea to go with that is to copy and paste keyframes in the dope sheet. That will save you some time instead of manually keying each value.

Be aware that your framerate must match the beats per minute of your song, otherwise syncing will be off and you'll end up with a headache. To avoid this problem, determine the BPM of your song here. https://getsongbpm.com/tools/audio

Once you have the BPM, calculate the frames per beat here. https://www.vjamm.com/support_av_bpm.php%3Flang=en.html
Adjust the value of the framerate until the frames per beat is a whole number. Then you can adjust your framerate in Blender to match with the one shown when you determined your frames per beat.

From there, start animating!

Hope this helps!


Clipping options for the 3D view are here :

These values are different from the camera options (you may need it also) :


If I understood you correctly, You want this :

I would do the following :

Start from your "curved planes gird" :

Make sure every "curved plane" is merged with his neighbors by selecting everything with A → open the "Specials" menu with W and clicking "Remove Doubles".

Then, hold Alt and click on an border edge of the "gird" in order to select the whole contour :

Extrude down this edge loop by pressing E and Z to constraint the extrusion on the Z axis. Click to confirm the action.

Make the extruded loop perfectly plane via a "zero scale" on z-axis: S + Z + Numpad 0 and click to confirm.

Then fill the bottom face, either via F, or via CtrlF → Gird Fill which may allow you to make a correct topology.

In addition, I would make a shade smooth, then turn on the "Auto Smooth" in the Object Data area :

This will make the whole object look smooth while keeping the sharp edges like they're supposed to look like.


How to convert a linked object into an individual object?

It's just vocabulary, but your question is ambiguous.

If you want to make an instanced object, (one which shares some aspect of its data (mesh, materials,etc., with other objects,) independent, that's now hidden in Header menu > Object > Relations > Make Single User.
A Subdivision Surface modifier always affects the entire object to which it is assigned. If you want to split part of the mesh off to another object, select that part of the mesh in Edit mode, and P Separate > Selection.


Rendering multi-layer EXR leaves small gaps between layers

This appears to be a problem with a misunderstanding as to how to handle alpha.

When pushing out alpha, raytracing engines use associated alpha, as only associated alpha represents both occlusion and emission.

As a result, the alpha in those subpixel seams must not be composited using the standard compositing operation, but rather one of the alternate over operations. Proper imaging tools such as Nuke offer the correct set of over functionality where anachronistic applications such as Photoshop do not. See for example, disjoint over.

When you have two pieces of geometry that share a subpixel but do not overlap, such as two angled bits of geometry that are perfectly flush with each other, the proper alpha combination amounts to an add. Do not use Photoshop's broken assumptions.

The best news is that this is purely the tip of the iceberg regarding Photoshop mishandling of proper EXR based work. Being display referred by design, it will fail miserably on many fronts including bit depth and proper scene referred data will be a nightmare.

See also this question which has more examples and a fleshed out solution with more depth.


Different color Between Video as plane and the Scene

I assume that you have inserted the video with the add-on "Import images as planes". If not, you can enable this free add-on (menu Edit > Preference > Add-ons. Search for Images and enable the add-on).
When inserting the video, you should choose for "Emit" in the material Settings (see figure 1). That way, the colors of the video are more independent from your lightning setup in the scene. If the colors still loooked a little washed-out, may be you can change the Color Management > View Transform from Filmic to Standard in the Render Properties tab (see figure 2).
About the speed of the video. It's hard to tell without further info. Are the frames per second of the original video and your blend file settings the same?


How to enlarge dynamic paint cache size (Blender 2.8)?

In the Dynamic paint controls you have Frame Start and End.


This problem is nicely solvable with voxel binding that unfortunately blender doesn't have yet.

The problem would be less visible if the polygons would be segmented the same on the torso and the belts, increasing the polycount will help against the artifacts.

A blender solution is to join everything into 1 piece mesh:

with boolean union and clean up the mesh after it
with knife tool to cut slots for the belts in torso and to cut out excess belts inside the torso. Then joining it together.


Applying Logo to Sphere to move to Unity

in Edit mode select all vertices and Unwrap as Cube Projection
go to UV Editor and Scale the UV a bit up
go to Shader Editor and for Image node - change Repeat to Clip

Note: in this case I didn't use Texture Coordinates node since UV is used by default and Mapping node since positioning is controlled by UV Map
Unity
Im not experienced with Unity, so there is probably better way, but looks like

in Blender - Bake material into textures (Color (Albedo), Metalic, Normal, Ambient,  ... etc for PBR material)
export as FBX
in Unity import asset and assign baked texture to Albedo channel

Check documentation https://docs.unity3d.com/Manual/Materials.html
Also search Blender to Unity topic like here https://blender.stackexchange.com/a/132340/2214


Why Grease Pencil will only let me draw a circle around a red dot? - 2.8

Apparently I switched on guides by accident...


How to unset multiple values from Bezier objects?

There is.
Set it for the active object, then right-click the property and select the option Copy to Selected


How can I disable symmetry in sculpting mode?

Press N to enable the properties window. In the tool tab you will find the symmetry options.

Or they can also be found in the properties tool panel on the right.


Align Active Camera to View - Not working in 2.9

The camera was behaving like the Active Camera (possibly because it was the only one in the scene), but technically it was not the Active Camera.
Selecting the camera object and specifying this resolved the issue.


Error with Python script when run using `--background`

The size argument doesn't exist for this operator in Blender 2.79, it's called radius.

Blender 2.79:

import bpy

bpy.ops.mesh.primitive_plane_add(radius=1, location=(0, 0, 0))

Blender 2.80:

import bpy

bpy.ops.mesh.primitive_plane_add(size=1, location=(0, 0, 0))

The following links take you to the documentation of the function in Blender 2.80 and Blender 2.79.


how to remove noise? Sample and Light paths do not change anything!

I found the problem, graphic driver update (AMD CRIMSON 16.6) on Amd 7870 Card

Now i get this when i make a render (gpu) .... (same sword)

Same render with CPU (Fx-8320)


How to discretize a 3D model represented by as .STL

It probably makes more sense to check for volume intersections than the presence of vertices within your matrix, since your entire matrix can be within the ("empty") volume of the mesh you want to discretize, as you pointed out.

If your 3D matrix is cube-like, you can use an actual mesh cube object to represent it, which simplifies this test.

This code tells you whether your cube intersects with the mesh and if its center lies within the mesh or not [EDITED TO ADD COMMENTS AND EXPLANATIONS]. It's based on the ray_cast method, which is nicely explained by @zeffii here.

import bpy, bmesh
from mathutils import Vector

def check_raycast(ray_origin, ray_destination, obj):
    ''' This function casts a virtual ray from "ray_origin" to
        "ray_destination", and finds any intersections along
        the ray's path with the mesh object referenced in the "obj" param.
        If there are any intersections, it will return True, else False.
    '''
    mat = obj.matrix_local.inverted()
    loc, normal, face_idx = obj.ray_cast(mat * ray_origin, mat * ray_destination)

    return face_idx != -1

c = bpy.data.objects['Cube']
o = bpy.data.objects['Suzanne']

# Generate bmesh object from cube mesh data
bm = bmesh.new()
bm.from_mesh( c.data )

bm.edges.ensure_lookup_table() # Generates edge   index table
bm.verts.ensure_lookup_table() # Generates vertex index table

# Check if cube intersects with mesh
''' The intersection algorithm iterates over the cube's edges and uses
    each edge's two vertices as ray casting origin and destination points.
    In other words, a ray is cast from the first --> 2nd vert of each edge.
    If the cube intersects with the object, one of the edges of this cube
    must also intersect with the object, thus the cast ray will bump into
    one of the object's faces.
'''

# Iterate over the cube's edges
for e in bm.edges:
    # Find the global coordinates of each edge's two vertices
    coos = [ c.matrix_world * v.co for v in e.verts ]

    # Set these verts as ray casting origin and destination
    ray_origin, ray_destination = coos

    # Check whether this edge intersects with the object's mesh
    intersectsMesh = check_raycast(ray_origin, ray_destination, o)
    if intersectsMesh: break

# Check if cube center is inside the mesh volume
''' This test sends a ray from the cube's center (location) straight up,
    towards an arbitrary point at XYZ 0,0,1000.
    If the cube's center is within the mesh of the object, the ray will hit
    the engulfing mesh somewhere along its way up, and the function will
    return True.
'''
insideMesh = check_raycast( c.location, Vector( (0,0,1000) ),  o )

print( "Intersects: ", intersectsMesh )
print( "Inside Mesh: ", insideMesh )

If you want to discretize your entire mesh with this code, you can simply move the cube's location (for which bmesh.transform will prove useful) in each iteration until you fill the entire bounding box volume, or fill the volume with cubes then iterate over them (probably less efficient).

You can download the file I tested this script with here.


Image Transparency doesn't work with alpha mode and alpha blend in both eevee and cycles

I was able to accidentally reproduce the problem. I was able to fix it by reloading the image.
First unlink the existing image by pressing the x next to image name.

Next reload the image by pressing Open and search your image.

You should share your blend file if this doesn't work.


Is it a problem to use triangles in a vehicle mesh for a game?

For models that do not undergo deformation (stretching/squishing/bending), it doesn't matter if your model consists only of quads or not. Some nice things about having topology consisting of similarly sized, nearly regular quadrilaterals is that calculations involving adjacent faces are well-behaved, so you won't expect to get weird artifacts during a render, among other things. But this holds for quads and tris.  In general, it is always best to have a model with similarly sized, regular(ish) faces. It is only when you have a model that will deform that you would like to use quads because that allows you to create rings and loops, which enables smooth deformations.


The screenshot shows an object origin at the center of the mesh, with a dotted line to the Orca. If I add an empty to the default scene, and define that empty as a parent of the default cube, I get a dotted line from the empty to the cube much like the line shown in the screenshot. If I select the empty object, the "Set origin" button disappears from the tool shelf. This suggests to me that you don't have the Orca selected, but instead have selected the empty.


Volumetric haze is showing through solid objects when 'stacked'

Haven't had much luck on this site lately! But I kept banging away at it and figured it out on my own.

The three overlapping cone shapes that you can see at the 3D window (bottom right), don't come to a point, the point is chopped off. So they're like cylinders that are skinny at the top and fat at the bottom.

The issue was apparently caused by the fact that my cylinders were open-ended (aka non-manifold). They had no faces at the top or bottom.

So for example in this pic, the first and last cylinders/cones have faces on top. The middle is open. So if I rendered it like this, the middle one would have the problem while the others wouldn't.

So it seems volumetric effects are sensitive to the mesh that contains them. I should have figured that out sooner because I tried making the cones originally with no faces, just 'wireframe' vertices and edges... and the volumetric effect didn't show. They needed faces to contain it. Since the faces have no material, light passes through them ok, so leaving the top of the cones open wasn't necessary.


Add random values to every height to a given object

The print function will go to the blender console window if you run the code from the text editor (but the code has nothing to print currently. See below). Use the blender Edit menu to Toggle System Console.
You can do what this code is trying to do much more easily with the displacement modifier and a noise texture, or with ANT Landscape addon, which has a readymade tool that uses noise textures to generate random terrain. However, if you really want to do it this way...
The python in this is very broken. I will try to explain.
I am assuming you are running this code in the Blender python terminal, but if you are running it from the text editor, you must add...
import bpy

...at the beginning of the script for it to work.
To otherwise fix the code regardless of text editor or terminal running:
First off, the code passes object1 and height as arguments to the function, but then the function itself creates the variable object1, so that is not needed. Python can create and delete variables on the fly, so there is no need to tell it beforehand "I am going to create these variables here." The line should be...
def randomheight(height) :

Which gets passed height as a number.
Secondly, the blender API syntax is incorrect in adding n (a number) to vert.co (a 3D vector). Since the up/down axis is Z, which is the third element of the vector, the line should be...
vert.co[2] = vert.co[2] + n

Or you can use...
vert.co[2] += n

To make things more compact.
Thirdly, the code has nothing to print: the randomheight function does not return any value, so python will just print "None." Also, the code is trying to pass the object name to the function when the function itself looks up whatever the active object is. This should be...
randhomheight(4)

Unless you want to be able to pass the function something so it can work with objects other than the active one, in which case:
You should leave in the object1 argument where you define the function and here where you call it. Then, remove where the function picks the active object and replace it with...
object1 = bpy.data.objects[object1]

...which will look the object up up by the name the function was given.
Sorry about the multiple choice bit at the end, it was just tricky to tell what the code was meant to do.
Hope this helps :-D


Planetary system simulation with real orbital datas

Orbital Eccentricity - Wikipedia
For elliptical orbits, a simple proof shows that arcsin(e)
yields the projection angle of a perfect circle
to an ellipse of eccentricity e. For example, to view the eccentricity
of the planet Mercury (e = 0.2056), one must simply calculate the
inverse sine to find the projection angle of 11.86 degrees. Next, tilt
any circular object (such as a coffee mug viewed from the top) by that
angle and the apparent ellipse projected to your eye will be of that
same eccentricity.

Via the UI, add a primitive circle mesh or curve, rotate about X RX 11.86, then scale in 0 in Z, S Z 0

Result of running test script
Quick test script, creates a circle, rotates by projection angle about X, projects onto XY plane by setting z to 0.
Could use bmesh, or make the projection matrix.
import bpy
import bmesh
from mathutils import Matrix
from math import asin

def elliptic_orbit(name, e, context=bpy.context):
    bpy.ops.mesh.primitive_circle_add()
    R = Matrix.Rotation(asin(e), 4, 'X')
    ob = context.object

    me = context.object.data
    ob.name = me.name = "%s_orbit" % name
    me.transform(R)
    for v in me.vertices:
        v.co.z = 0
    me.update()

elliptic_orbit("Earth", 0.017)
elliptic_orbit("Mercury", 0.2056).scale *= 0.387
elliptic_orbit("Venus", 0.007).scale *= 0.723
elliptic_orbit("Mars", 0.093).scale *= 1.524
elliptic_orbit("Jupiter", 0.048).scale *= 5.203
elliptic_orbit("Saturn", 0.056).scale *= 9.555

Alternatively orbit as a curve. Here I've used a scale matrix to scale z component to zero, could do same in mesh version.
def elliptic_orbit(name, e, context=bpy.context):
    bpy.ops.curve.primitive_nurbs_circle_add()
    S = Matrix.Scale(0, 4, (0, 0, 1))
    R = Matrix.Rotation(asin(e), 4, 'X')
    ob = context.object

    cu = context.object.data
    ob.name = cu.name = "%s_orbit" % name
    cu.transform(R)
    cu.transform(S)

    return ob

For compatability sakes I've applied the transforms sequentially.  For 2.5 K= verson < 2.8  could use cu.transform(R * S) and for 2.8 cu.transform(R @ S)
Ellipse foci

Ellipse - Wikipedia
shape parameters: a: semi-major axis, b: semi-minor axis c: linear eccentricity, p: semi-latus rectum.
By Ag2gaeh - Own work, CC BY-SA 4.0, Link

The semi-major axis will lie on the rotated axis X. c the linear eccentricity can be calculated thus
>>> ob = C.object
>>> ob.name
'Jupiter_orbit'

>>> ob.dimensions.xy.length
0.4994825301958152

The two foci are F1, F2 = (c, 0, 0), (-c, 0, 0)
May find the following post on barycentric orbits of interest.


You may do it using a bumpmap. All you need is to create two textures.

Create a stitch image in photoshop or gimp and transform it into a brush (https://www.youtube.com/watch?v=iGSK3Q0Iy3c). It's color should be from over 50% grey to almost white color.

Export your unwrapped UV Layout.

In photoshop layer it over a 50% grey color layer to see where to put stitches. Use your newly created brush to paint them on the grey color layer.

Use a method as shown here: https://www.youtube.com/watch?v=gbDA3XinISs

Now you have a bumpmap (let's call it BUMP).

You need also to create a black and white texture as pictured below (let's call it MASK). It'll act like a mask for mixing two different materials.

Set up the nodes as pictured below. We'll use a BUMP texture to create a depth to the stitches. Plug it to the Displacement input of the Material Output node. Add a Math-->Multiple node between them to control the bump size. Use a MASK texture to set a border between two materials (in this case jeans material and stitches material). Plug it to the Fac input of the Mix Shader. Now you have a full control over jeans (or leather in your case) and stitches shading within one cycles material using only textures.

Here's how the stitches present in final render. With the proper mix of Diffuse and Glossy shaders they may look quite convincing.


You have a big and ugly n-gon (a polygon of more than 4 vertices) trying to bend as that curve.

You need to subdivide it into more faces.
Here's what you get when you delete that n-gon and do grid fill:

The curvature is better but far from ideal (plus you get terrible topology).

Try to create a curve that has the same number of vertices for both sides (and try to keep the rest of the topology as quads)


In addition to cegaton's useful advice:

If you hold LMB on the top arrow and just drag down, it will turn on all the ones you cross on your way down.

It basically copies the first adjustment you made to all others. Photoshop had that in 2001. I suggested it in 2008, Ton probably forgot and someone else put it in unrelated to my suggestion ( :


Help With Boolean Modifier, Cutting Objects Still Visible

The boolean object is not deleted after applying the Boolean modifier, it is still here, you need to delete it or make it invisible. You say that you've disabled the eye icon but the eye is only for viewport visibility, you need to disable the camera icon if you don't want it in your render, first enable it in the dropdown menu:


How do I uninstall an Addon added by running a Python Script?

I don't think you can uninstall it as you didn't technically install it if you said you 'ran the script'. Best you can do is close and re-open file I think.

Edit:

I found that the script had also been added to my startup file without me having saved it. On windows I navigated to:

C:\Users\USERNAME\AppData\Roaming\Blender Foundation\Blender\2.70\scripts\addons\__pycache__\

I deleted a file with object_creaprim in the file name and reloaded blender and it disappeared.


Can anybody explain to me what collection instance is?

A collection instance is simply a linked copy of another collection. If you change the original collection, all instances will also update to reflect your change. Here's a simple video that demonstrates how it works:
https://youtu.be/Id9IzLV7IDg


You can try to keep only a quarter of it so that you can clean it "by inside" and then apply a mirror in order to obtain the whole shape again.

The blend here : http://www.pasteall.org/blend/42115


Making changes to objects in scene before exporting using custom exporter addon

I thought a little about what @batFINGER mentioned in the comments, and it got me thinking:

class DuplicateScene2():
    _file_stack = []

    def __init__(self):
        if not bpy.data.is_saved:
            raise ValueError("Save .blend file before exporting")
        # Push filepath onto stack
        if len(DuplicateScene2._file_stack) == 0:
            DuplicateScene2._file_stack.append(bpy.data.filepath)
            bpy.ops.wm.save_mainfile(filepath = bpy.data.filepath,
                                     check_existing = False)
        else:
            filepath, fileext = os.path.splitext(bpy.data.filepath)
            DuplicateScene2._file_stack.append("%s.copy.%02i.blend" % (filepath, DuplicateScene2._unique_id))
            DuplicateScene2._unique_id += 1
            # Save file
            filepath = DuplicateScene2._file_stack[-1]
            bpy.ops.wm.save_as_mainfile(filepath = filepath,
                                        check_existing = False,
                                        copy = True)

    def __enter__(self):
        # Return new context override
        context = bpy.context
        window = context.window_manager.windows[0]
        screen = window.screen
        scene = context.scene
        area_view3d = [area for area in screen.areas if area.type == 'VIEW_3D'][0]
        space_view3d = [space for space in area_view3d.spaces if space.type == 'VIEW_3D'][0]
        return {'window': window,
                'screen': screen,
                'area': area_view3d,
                'space': space_view3d,
                'context': context,
                'scene': scene}

    def __exit__(self, type, value, traceback):
        filepath = DuplicateScene2._file_stack.pop()
        bpy.ops.wm.open_mainfile(filepath = filepath,
                                 load_ui = True,
                                 use_scripts = False)
        if len(DuplicateScene2._file_stack) > 0:
            os.remove(filepath)

Using it like so:

try:
    with DuplicateScene2 as override_context:
        ...
except ValueError as e:
    self.report({'ERROR'}, "%s" % (e))
    return {'CANCELLED'}

With this, checking if the file has been saved or not will warn the user about needing to save before exporting. Any exceptions thrown will still allow the file to be reverted.

If there are "cleaner" methods, or suggestions, please do post!

Edit: This doesn't work nested, which is what I realized that I also need.

Edit: Added supported with nesting.


Why can't I view all strips in Blender Sequence?


The problem is that you're using a one-dimensional "Fac" output from the noise texture to produce a scalar displacement.  This is interpreted as a multiple of the vector (1,1,1) and so displaces the cube along the diagonal.  Take the "Color" output of the noise texture to get a three-dimensional noise from (0,0,0) to (1,1,1) and use some Vector Math nodes to center and scale it, like so:

Alternatively, you could take your one dimensional noise and pass it to the "Height" input of a "Displacement" node to get a proper displacement output:


Put the cursor on the center (Shift C), use the cursor as pivot point. Select the mesh in object mode, turn off the armature modifier, press S to scale around the cursor, move your mouse but don't click: in the left bottom corner you will read the amount of scaling according to the mouse movements, read the value when you're satisfied (let's say it's 0.563), press .563 and Enter. Then select the armature, go to edit mode, activate all the armature layers, press A to select all, then press S .563 Enter. Reactivate the armature modifier.


To do this:

import bpy
import math

ob = bpy.data.objects['Armature']
bpy.context.scene.objects.active = ob
bpy.ops.object.mode_set(mode='POSE')
bonename = 'finger_index.01.R'
pb = ob.pose.bones[bonename]
pb.rotation_mode = 'XYZ'
angleX = 5
angleY = 5
angleZ = 5
pb.rotation_euler =
 (math.radians(angleX),math.radians(angleY),math.radians(angleZ))
bpy.ops.object.mode_set(mode='OBJECT')


Are there cases whereby auto weights won't work "no matter what"?

There is non manifold mesh in your model. Go to edit mode, make sure you are in vertex select mode, deselect all, from the menu select->select all by trait->non manifold (shift-ctrl-alt-m). There's a lot of geometry in the head, lips, teeth, nose etc. If the model is not going to have complex facial animation or speech, delete all that wasted geometry inside the head. The other areas you will have to just attack piece by piece. Having selected the non manifold mesh you can ctrl-numpad+ a couple of times to select the surrounding verts, ctrl-i to select inverse and 'h' to hide most of the mesh. This will clear the field for you to work on isolated parts.


How to align 6 cameras fast, 2 on each axis facing each other?

You must make the second camera the active camera and then align it to the view.

You can make a selected camera the active camera by pressing CTRL+0

You can also access this functionality from the 3D view header View menu.

  View -> Cameras -> Set Active Object as Camera


As noted in the comments:

The filetype in the File Browser context can't be changed in the filename area. It has to be set in the dropdown menu in the Save As Image section.


i'm made a rig with empties for controls but they are not appearing in one file

In the particle systems properties, on the right side of the list of particle systems, there is a monitor and camera, these control the particle visibility in the viewport and render.

You have both visibility options turned off for your particle systems, you need to enable the monitor for viewport visibility and the camera for render visibility.


Incorrect transparent texture rendering in cycles

Switch the order for diffuse and transparent


Trouble with Distortion on UV Map of CSS Virginia

I think you should try to increase the level of subdivisions of the Subsurf Modifier.

It may also be the matter of how you've unwrapped your mesh. I'll suggest you the way how to do it.
Add an edge as pictured below, select it and mark a seam (Ctrl+E-->Mark Seam)

Unwrap the mesh using Follow Active Quads method. Select the whole mesh (A), then press U-->Follow Active Quads-->Lenght Average-->OK.

The result of the unwrapping (after you scale the UV island) may be something like this.

Now you have quite even distribution of the texture and there is no distortion.


Python, what is the right context for bpy.ops.transform.delete_orientation() operator

You need to override the context of the operator:

import bpy

name = 'Edge.001' #The orientation to remove

views = [area.spaces.active for area in bpy.context.screen.areas if area.type == 'VIEW_3D']
if views: #Assign the orientation in the view so that it is active and can be removed
    views[0].transform_orientation = name

areas = [area for area in bpy.context.window.screen.areas if area.type == 'VIEW_3D']

if areas: #Give the good override context
    override = {'area' : areas[0]}
    bpy.ops.transform.delete_orientation( override )

Edit: following the comment, some 'novice' explanations

Operator's context can be override. An override is a dictionary with some keywords. Among them you have the 'area' (because we have bpy.context.area). And if you look in the N panel where a custom orientation can be deleted, you see you are in the view3D area.

So... we just need to give a view 3D area to the override context.

Edit again:

What you did in your code is changing your current context (the view itself)... but that does not change the execution context itself (where delete_orientation is called), that is changing only the view.

More information here

Update:
In order not to get a ( Pycontext '' not found ) error in the system console, it's better to write the code this way:

...
if areas: #Give the good override context
    override = bpy.context.copy()
    override['area'] = areas[0]
    bpy.ops.transform.delete_orientation( override )

Reference: here


How to Take different shot's with one camera in different places

One solution: if you want to focus on a single object, use a object constraint (on the camera object).  It will keep the camera rotated to look at the object (your Cube).

result:
Another was @wilks suggestion to not only key in the location of your camera, but also the rotation of your camera (where it points to):

That shows up in the Dope sheet:


How can I smooth an object and keep the edges nicely beveled?

You seem to indicate two problems here.

Fireflies are usually a sign of rendering with too few samples and/or a very tiny light source. They are not directly related to bevel and subdivision modifiers.

To keep sharp edges sharp, you can set a crease value on selected edges (Shift-E) for the subdivision modifier. In the bevel modifier, set "Limit method" to "angle" with a value of 50°-80°.  Or, if you want different bevel widths on different edges, you can use bevel weight ("Weight" in "Limit method", then select edges and modify bevel weight through Ctrl-E.
Note that the order of the bevel and subdivide modifier is also important.

You'll often also need to set smooth shading, and in that case you might want to activate "Auto smooth" in the "Normals" section of the "data" tab (the one marked with an inverted triangle). Here also, set the angle to taste. Or mark some edges as 'sharp'.


Python - Orient light to polygon (face normal as direction)

There's probably a cleaner solution, but for the time being, you can use:

import bpy
from math import radians
from mathutils import Vector, Matrix

obj = bpy.context.active_object
mesh = obj.data

def get_layers():
    """
    return: tuple of 20 booleans. True if layer is active layer,False if not
    Allows the mesh to be created on the active layer. There is only 1 active layer
    """
    active_layer = bpy.context.scene.active_layer
    layers = [False] * 20
    layers[active_layer] = True
    return tuple(layers)

def create_light_at_face():
    """
    layers: tuple. 20 booleans where exaclty one boolen is True
    return: None
    creates an area light the has the same orientation as the normal at the center of each face
    """
    mat_world = obj.matrix_world
    up = Vector((0,0,1))

    for poly in mesh.polygons:
        co = mat_world * Vector(poly.center)

        forward = poly.normal.copy()
        forward.rotate(mat_world)
        right = forward.cross(up).normalized() # Vector.length closer to 1.0
        up = right.cross(forward)

        rot = Matrix((right, up, -forward)).transposed().normalized().to_4x4()
        mat = Matrix.Translation(co) * rot

        bpy.ops.object.lamp_add(type='AREA', view_align=False, location=co, layers=get_layers())
        # scale lamp up a little fo we can see the area
        bpy.context.object.data.size = 3
        bpy.context.object.matrix_world = mat

create_light_at_face()

Also tried eulers, but did not work reliably (some lamps pointing inwards).

As ideasman_42, suggested, to_track_quat() can be used to do the job, too:

        quat = poly.normal.to_track_quat('-Z', 'Y')
        loc = Matrix.Translation(poly.center)
        mat = mat_world * loc * quat.to_matrix().to_4x4()
        bpy.context.object.matrix_world = mat

It's not much code less, but more understandable I hope.

Another variant:

        loc = mat_world * Vector(poly.center)
        # use loc as co for lamp_add operator here
        quat = poly.normal.to_track_quat('-Z', 'Y')
        quat.rotate(mat_world)
        bpy.context.object.matrix_world *= quat.to_matrix().to_4x4()


Can fluid respect soft bodies (or any deformation!) in blender?

In short, no. The fluid sim won't interact with any other simulator. But there is a way around this limitation.

For the obstacle object, selected Export Animated Mesh, this will animate the mesh itself, rather than simulating the mesh. As a "real" mesh, the fluid sim will treat it like any other mesh, and react to it appropriately. However, this will have to be repeated anytime you want to change the physics simulation. Incidentally, this also means that the soft-body cannot react to the fluid sim.


Alpha modifier, or properties, that affect the child of the group "as a single object"

For Cycles, we can use "Transparent depth" and test if it is 1 or more and use it to drive the alpha value.
The disk below is a non transparent sphere behind the planes.

Less than means 1 if no transparency depth else 0.
Multiply that with your wanted alpha value and plug it to the alpha channel of the shader.

If you're using objects that have several layers (for instance replace the planes by Suzanne(s)), don't forget to tune the light path max bounces for transparency in the rendering settings (as if not, some transparent part may be rendered as solid):


How to make each frame represent one second?

Go to the Properties window, then in the Render tab scroll down to the Dimensions section. The Frame Rate is the setting you want to change. From the dropdown choose "Custom" then in the new frame rate field that pops up enter 1.


I'm not sure of what you mean.
Weight painting needs at least two colors no matter what because it has to represent values between 0 and 1. So you will always have at least one color for 0, one color for 1 and it will display in between colors for every value between.

If you want to have only two colors for your weights paint (ie black and white), just set only two colors in your userprefs:

If you want to have as little transition as possible between values, use the "constant" interpolation and decay one of the sliders:


Can Blender be used for high quality industrial design?

Yes, Blender is capable of doing high-quality industrial design, if you are willing to invest the time.

For getting appropriate topology, there is information available like http://www.topologyguides.com

Also, regarding your comment about distortion around holes cut into curved surfaces, Blender has the Shrinkwrap modifier that can you can use to smooth your surface after cutting.  For example, here's a sphere with an odd cutout.  On the left I used Shrinkwrap to mold it to a sphere, and on the right without Shrinkwrap. The reflections on the right sphere are distorted as you would expect with a SubD surface, but the reflections on the left are smooth around the edge of the cutout:

This is a really quick example so it's not perfect, but if you put effort into it you certainly can get great results.

See this link: https://www.blendernation.com/2016/04/14/shrinkwrap-modifier-hard-surface-modellers-best-friend/


Hydraulic Cylinder with Damped Track Constraint not aligning (2.8)

Here are 2 pistons one with with 2 and one with 3 sections

I got the solution from Here after using the track to constraint instead of the damped track which I mistakenly took for a look at constraint from 3ds max.

The Track to constraint has all sorts of issues like spinning mesh the Damped track doesn't seem to.

I realize after 7 months you probably have solved this issue, but someone else might find my research helpful.


How to bake lightmap to a simplified duplicate object?

Limited dissolve with default settings, in most cases can destroy the UV map.
To avoid that you need to enable UVs, in the operator panel in Delimit section.


How do I import 3rd party decal packs into decalMACHINE?

The folder that was referred in that question is the DecalMachine assets folder, which by default is on C:\Users\[username]\AppData\Roaming\Blender Foundation\Blender\[version]\scripts\addons\DECALmachine\assets\Decals\, or the one you've set under Assets on DecalMachine's preferences.
The folders with "uuid" files are your decals. You can either drop them to the "MyDecals" folder or make a separate folder under the path above.
It also took me a while to find this. Hope this helps!


Cycles light ray exiting the back of an object

You can use the Backfacing output of the Geometry node.

The way this works:
The outer material is mixed with a transparent shader based on how much the surface is facing the camera. This is then mixed with the Backfacing output of the geometry node. This output is 1 or 0 based on the normal of any face the ray encounters.
In this case, if goes ray hits the back of a face, it will bounce off of the "inner material" diffuse shader.
You might think we are done at this point, but the shader won't let light inside; rays which go inside the Suzanne from the camera can't get back out to hit light sources, as they are surrounded by diffuse back-faces.
To get around this, we use a final mix shader to make rays directly from the camera (camera rays) use the backface diffuse + fresnel frontface, however rays not directly from the camera will use transparent for the backfaces (allowing rays to exit the Suzanne after hitting a diffuse backface and becoming a diffuse ray). I plugged the inner material diffuse shader into the other slot just because I liked the indirect lighting it cast, but you can do other things too. Here are some examples:
No shadow
Without the mix shader, using just transparency, the Suzanne will not exist for any kind of ray besides camera ray, so this will remove the shadow and indirect lighting:

Fresnel shadow
This uses only the fresnel shader on front faces for other ray types and ignores backfaces.


Initial support for CUDA 8.0 cards has been added to master.
You can download a supported build of blender from the buildbot or any recent version.


First:
 I would apply modifiers before you run simulations, so you could try applying the decimate modifier and re-running the simulation.

Second:
You could subdivide the cloth some more, in edit mode. I'm not sure if you did this, but subdividing the cloth using the SubSurf modifier doesn't increase the resolution of the cloth in the calculations of the simulation.

Third:
Increase the "padding" of the object. By "padding", I mean the distance from the object that the cloth will colide with. I don't know what yours currently are, but hopefully tweaking this will help. The values 'Inner' and 'Outer' are what controlls this.


Can you easily make an edge loop go through a triangle?

In wireframe mode you can select easily all the edges what you want to cut at once.
To create the new loop on them select Edge>>Subdivide.
Now you can adjust the number of cuts on the bottom-left.
If you want to move them, select a loop and double hit "G".
To create more loops after the move, select a loop and choose
Edge>>Bevel Edges.


IK constraint following object goes haywire

Go into the armature in edit mode and bend the knees in the direction they are supposed to bend just a tiny bit.

If the legs are completely straight, the ik constraint might get confused which way to bend the knees.

Or give the IK constraint a pole target.
I made a video on this here:
https://vimeo.com/171279647

If you upload your .blend I can make a .gif on your specific example.
https://blend-exchange.giantcowfilms.com/


How to use modifiers on a metaball animation

The Animation Nodes add-on works on metaballs using the Mesh nodes. So you can do all kinds of things with them. Most of the things the modifiers do, if not all (but much more for sure).
The latest version is here.
There's plenty of resource on Youtube to learn how to use this big and powerful add-on. Even the developer Jacques Lucke has a Youtube channel full of it. The documentation is also very useful.

Actually, even Sverchok works on metaballs, so I guess you're pretty much covered. Sverchok is similar to Animation Nodes but offers other possibilities. And the resources are even more extensive. There's a Documentation too and Jimmy Gunawan made so many videos, any effect you can think of, he's certainly got one for it. Heck, he's got a whole series with Metaballs !

There's a bit of a learning curve for both of these add-ons, but every minute spent on them is worth it. They're arguably among the best free add-ons for Blender and we won't have a built-in "Everything Nodes" anytime soon.

If you're stuck on how to do a specific effect with any of these add-ons you can ask in another question and give a link in a comment below. But first learn the basics.

Good luck !


Why won't my creature parent to its armature

Your armature's shape is extremely different from the creature's shape: so the algorithm that should assign weight automatically can't decide which vertices to assign to which bone.

In this case you should choose the "with empty groups" option: it will create an empty vertex group for every bone of your armature.

Then you will have to weight them manually. Using weight paint; or selecting a vertex group, in edit mode selecting the vertices you want to be moved, and click assign in the vertex group mesh tab of the properties panel.

The corrispondence between bones and vertex groups is made by names.


Everything gets distorted when animating?

The most frequent cause of this problem, in my experience, is multiple Armature modifier on the object. With that setup, the mesh deformed by the first Armature modifier gets further deformed by subsequent modifiers, which results in broken deformation.

Also check that the bones are keyframed using plain Location / Rotation / Scale keying set. Keyframing with Visual Loc/Rot/Scale can ruin certain constrained bone setup. (Just for more complete information. This is unlikely in your rig's case, being not constrained at all.)

EDIT: I've seen the file, and found the rig animatable as expected.

But I notice the hand object is scaled way down to fit the armature. That could be a problem, because it'd ruin the animation if the object's scale is somehow reset or keyframed to a different value. Maybe you've done something inadvertent when keyframing this particular action, that triggers the object scale's change. I suggest to Apply Ctrl-A > Scale the object and redo the animation data.


You seem to have picked a very ambitious modelling project to start with.

To avoid weird glitches, you should model the skirt in a neutral pose. In other words, don't worry about the hair. This logic applies to almost anything that gets animated. For example you should model the hands in a position that is neither completely flat nor clamped into a fist.

Good luck.


rotating an edge without thining the shape

You can use "shear" which is part of the 2.8 new gyzmos:

Note that it works for more complex shapes, and you can do it in the direction you want:

For 2.79, you can use CtrlShiftAltS (yes only that), then choose X or Y axis to do nearly the same.


how to specify active window for a series of screen captures in python

To clear up some misunderstandings:
There are no get and set methods to modify the context, and mostly not for other purposes either. It's simply not the Python way of coding. ob.attr is your getter, and ob.attr = 123 the setter. Magic methods can intercept get and set operations to customize object behavior, but that's advanced stuff.
There's also a programmatic way to get and set any attribute, but you only ever need it if the attribute name is dynamic or not always present: hasattr(ob, "attr"), getattr(ob, "attr"), setattr(ob, "attr", 123).
All immediate members of bpy.context are read-only. You can't modify anything here. You can do something like bpy.context.window.screen = bpy.data.screens["Default"] however. screen is not a direct context attribute and editable. On the other hand, bpy.context.screen is read-only. bpy.context.window_manager.windows[#].screen is editable again.
To run an operator in a custom context means, that you construct a Python dictionary with context member names as keys, and datablock references as values. You do not modify the actual context:
ob = bpy.context.scene.object_bases["Cube"]
ctx = {"selected_bases": [ob]} # dict to store custom context
bpy.ops.object.delete(ctx) # run operator with custom context

Above code deletes the object Cube, even if completely different objects (or rather object bases) are selected without changing the selection temporarily.
It also prints a bunch of PyContext warnings to console, because the delete operator expects a couple more context members. We did not provide them in above code, we only set selected_bases. A nice, although limited trick is to run an operator with an empty context to figure out (some of the) context members:
bpy.ops.object.delete({})

It's sometimes easier to derive the context from the actual context, and only modify the necessary dictionary keys:
ctx = bpy.context.copy()
ctx["selected_bases"] = [bpy.context.scene.object_bases["Cube"]]
bpy.ops.object.delete(ctx)

Above code should not cause any PyContext warnings.
We can apply this to the screenshot operator now:
context = bpy.context
for area in context.screen.areas:
    if area.type == 'VIEW_3D':
        ctx = {
            "window": context.window, # current window, could also copy context
            "area": area, # our 3D View (the first found only actually)
            "region": None # just to suppress PyContext warning, doesn't seem to have any effect
        }
        bpy.ops.screen.screenshot(ctx, filepath="...", full=False)
        break # limit to first 3D View (optional)

Don't ever rely on the area index, it's not a stable property.

If you want an screenshot of a certain region (exactly as seen on screen), you can do the following:
import bpy
import bgl

context = bpy.context

def screenshot_region(region):
    x = region.x
    y = region.y
    width = region.width
    height = region.height

    buf = bgl.Buffer(bgl.GL_FLOAT, width * height * 4)
    bgl.glReadPixels(x, y, width, height, bgl.GL_RGBA, bgl.GL_FLOAT, buf)
    img = bpy.data.images.new("Screenshot", width, height, alpha=True)
    img.pixels[:] = buf

for area in context.screen.areas:
    if area.type == 'VIEW_3D':
        for region in area.regions:
            if region.type == 'WINDOW':
                screenshot_region(region)
                break

It creates an image datablock with the screenshot. You may wanna save it using Image.save_as(), which will use the scene's render settings. Or use struct.pack() to create some sort of bitmap file directly.
If you want to take a series of screenshots, you could do the following:
                scene = context.scene
                frame_orig = scene.frame_current

                for frame in range(scene.frame_start, scene.frame_end + 1):
                    scene.frame_set(frame)
                    bpy.ops.wm.redraw_timer(type='DRAW_WIN_SWAP', iterations=1)
                    screenshot_region(region)

                scene.frame_set(frame_orig)

Also see Can I redraw during the script?.
Here's a more sophisticated example:
import bpy
import bgl

context = bpy.context
scene = context.scene

def screenshot_region(region):
    x = region.x
    y = region.y
    width = region.width
    height = region.height

    view_settings(area.spaces.active)
    bpy.ops.wm.redraw_timer(type='DRAW_WIN_SWAP', iterations=1)

    buf = bgl.Buffer(bgl.GL_FLOAT, width * height * 4)
    bgl.glReadPixels(x, y, width, height, bgl.GL_RGBA, bgl.GL_FLOAT, buf)
    img = bpy.data.images.new("Screenshot", width, height, alpha=True)
    img.pixels[:] = buf

    view_settings(area.spaces.active, True)

def view_settings(view3d, revert=False):
    pref = context.user_preferences.view
    if not revert:
        view_settings.ob_info = pref.show_object_info
        view_settings.view_name = pref.show_view_name
        view_settings.mini_axis = pref.show_mini_axis
        #view_settings.only_render = view3d.show_only_render
        view_settings.manipulator = view3d.show_manipulator

        pref.show_object_info = False
        pref.show_view_name = False
        pref.show_mini_axis = False
        #view3d.show_only_render = False
        view3d.show_manipulator = False
    else:
        pref.show_object_info = view_settings.ob_info
        pref.show_view_name = view_settings.view_name
        pref.show_mini_axis = view_settings.mini_axis
        #view3d.show_only_render = view_settings.only_render
        view3d.show_manipulator = view_settings.manipulator

for area in context.screen.areas:
    if area.type == 'VIEW_3D':
        for region in area.regions:
            if region.type == 'WINDOW':
                for frame in range(scene.frame_start, scene.frame_end + 1):
                    scene.frame_set(frame)
                    screenshot_region(region)
                break

Related reads:

bpy.ops - Keyword and positional arguments / Context Overriding
Blender context
Using Operators / Poll-fail
poll() failed, context incorrect? - Example: bpy.ops.view3d.background_image_add()


Projecting multiple images onto an object with UV Project modifiers

Following the last comments, this is more some guidelines than a real answer.

What you can do/code inside Blender is an addon based on the same principle as UV project modifier. The principles are the following:

Given a camera and its parameters, you can obtain its projection matrix. For instance have a look at this.
You can also use/create an UV map (to be built by the code). In this addon, I image that you could parameter one UV map by camera (that may be needed or not, depending on the way you'll define the materials/textures correspondences).
Now you can loop over your model polygons (faces), test their normals against the concerned cameras axis and so determinate which polygons are best concerned by which camera.
Knowing each polygon/camera pairs, and the previous projection matrix, you can calculate the UVs of the polygons, then associate them to the corresponding UV map.

You are done...

Eventually you can also dynamically test camera's parameters changes (tuned by user to adjust the uv/image mapping) and auto update the UV map (performance to be taken into account).

That should be relatively simple.

But the problem is you will have partially hidden polygons due to the projection (it is true too for orthographic projection) and these polygons will overlap on the UV map.

edit:

A more complete answer in an addon that calculates the UV projections of the mesh, depending of the camera positions.

As indicated above, it uses the same principle as the UV project modifier (in the UI part).

(the blank parts in the gif are parts where no image is given).

For each camera, you need to indicate the corresponding UV map and material slot to use. Then the script calculates the polygons oriented to each camera and for each polygon the projected coordinates to be assigned to the UV map.

The code below is commented for more information:

import bpy
import time
from mathutils import Vector
from operator import itemgetter

#Used to store information related to each camera setting
class UVPPCameraSetting:
    def __init__( self, scene, camera, obj, uvMap, materialSlotIndex ):
        self.camera = camera
        self.uvMap = uvMap
        self.materialSlotIndex = materialSlotIndex
        #Z axis of the camera translate in world (Z axis is opposite to view)
        self.zInWorld = Vector( (0, 0, 1) )
        self.zInWorld.rotate( self.camera.matrix_world.to_euler() )
        #To keep polygons to handle for this setting
        self.polygons = set()
        #Camera parameters
        #Matrix to convert from object coordinate to camera coordinates
        self.toCameraMatrix = camera.matrix_world.inverted() * obj.matrix_world
        #The frame is composed of the coordinates in the camera view
        frame = [v / v.z for v in camera.data.view_frame(scene=scene)]
        #Get the X, Y corners
        self.minX = min( v.x for v in frame )
        self.maxX = max( v.x for v in frame )
        self.minY = min( v.y for v in frame )
        self.maxY = max( v.y for v in frame )
        #Precalculations to avoid to repeat them when applied to the model
        self.deltaX = self.maxX - self.minX
        self.deltaY = self.maxY - self.minY
        self.offsetX = self.minX / self.deltaX
        self.offsetY = self.minY / self.deltaY

    #Calculate the UV coordinateds from the object coordinates
    def CalcUV( self, objCo ):
        #Object in camera view
        camCo = self.toCameraMatrix * objCo
        #Z is "inverted" as camera view is pointing to -Z of the camera
        z = -camCo.z
        try:
            #Translates x and y to UV coordinates
            x = (camCo.x / (self.deltaX * z)) - self.offsetX
            y = (camCo.y / (self.deltaY * z)) - self.offsetY
            return x, y, z
        except:
            #In case Z is zero
            return 0.5, 0.5, 0

def UVPerspectiveProject( scene, obj, camSettingList ):
    print( '------------------------' )
    startTime = time.time()

    matrix_world = obj.matrix_world
    rotation_world = matrix_world.to_euler()

    #Assign polygon to its corresponding camera considering faces most aligned to camera view
    for p in obj.data.polygons:
        normalInWorld = Vector( p.normal )
        normalInWorld.rotate( rotation_world )
        camSetting, maxDot = max( ((c, normalInWorld.dot( c.zInWorld)) for c in camSettingList), key=itemgetter(1) )
        camSetting.polygons.add( p.index )

    print( 'precalculations. elapse in seconds', time.time() - startTime )

    loops = obj.data.loops
    vertices = obj.data.vertices
    #For each setting,
    for cs in camSettingList:
        camera = cs.camera
        uvMap = cs.uvMap
        polygons = cs.polygons
        projectedCo = {} #Storage to avoid multiple calculations of the same world_to_camera_view
        #Go through all polygons
        for p in obj.data.polygons:
            #If the polygon corresponds to the setting
            if p.index in polygons:
                #Assign the material index
                p.material_index = cs.materialSlotIndex
                #Calculate each vertex uv projection
                for i, vi in [(i, loops[i].vertex_index) for i in p.loop_indices]:
                    if vi not in projectedCo: #not already calculated for this cam
                        x, y, z = cs.CalcUV( vertices[vi].co )
                        projectedCo[vi] = (x,y)
                    uvMap.data[i].uv = projectedCo[vi]
            #If not, uv are set to (0,0)
            else:
                for i in p.loop_indices:
                    uvMap.data[i].uv = (0, 0)

    print( 'done. elapse in seconds', time.time() - startTime )

def TargetObjExists( context ):
    try:
        scn = context.scene
        obj = scn.objects[scn.uvPerspectiveProject.object_name]
        return obj.type == 'MESH'
    except:
        pass
    return False

def IsCamera( context, camera_name ):
    try:
        camera = context.scene.objects[camera_name]
        return camera.type == 'CAMERA'
    except:
        pass
    return False

def SettingsAreOK( context ):
    try:
        scn = context.scene
        settings = scn.uvPerspectiveProject
        obj = scn.objects[settings.object_name]
        assert obj.type == 'MESH'

        for item in settings.cameras_settings:
            camera = scn.objects[item.camera_name]
            assert camera.type == 'CAMERA'
            uv_map = obj.data.uv_layers[item.uv_map_name]
            materialSlot = obj.material_slots[item.material_slot_name]

        return True
    except:
        pass
    return False

class UVPerspectiveProjectOperator( bpy.types.Operator ):
    bl_idname = "lemon.uvperspectiveprojectoperator"
    bl_label = "UV perspective project"
    bl_options = {'REGISTER'}

    @classmethod
    def poll(self, context):
        return context.mode == 'OBJECT' and SettingsAreOK( context )

    def invoke(self, context, event):
        scn = context.scene
        settings = scn.uvPerspectiveProject

        #try:
        obj = scn.objects[settings.object_name]
        cameraSettings = [UVPPCameraSetting( scn, scn.objects[item.camera_name], obj, obj.data.uv_layers[item.uv_map_name], obj.material_slots.find( item.material_slot_name ) ) for item in settings.cameras_settings]
        UVPerspectiveProject( scn, obj, cameraSettings )
        #except:
            #pass

        return { 'FINISHED' }

class UVPerspectiveProjectCamSettingsActions( bpy.types.Operator ):
    bl_idname = "lemon.uvperspectiveprojectpanelcamlistactions"
    bl_label = ""

    action = bpy.props.EnumProperty( items = ( ('UP', "Up", ""), ('DOWN', "Down", ""), ('REMOVE', "Remove", ""), ('ADD', "Add", ""), ) )

    def invoke(self, context, event):

        scn = context.scene
        settings = scn.uvPerspectiveProject
        index = settings.camera_setting_index

        if self.action == 'DOWN' and index < len(settings.cameras_settings) - 1:
            settings.cameras_settings.move( index, index + 1 )
            settings.camera_setting_index += 1

        elif self.action == 'UP' and index > 0:
            settings.cameras_settings.move( index, index - 1 )
            settings.camera_setting_index -= 1

        elif self.action == 'REMOVE':
            settings.cameras_settings.remove( settings.camera_setting_index )
            settings.camera_setting_index -= 1

        elif self.action == 'ADD':
            item = settings.cameras_settings.add()
            settings.camera_setting_index = len(settings.cameras_settings) - 1

        return {"FINISHED"}

class UVPerspectiveProjectCamSettingsPanel( bpy.types.UIList ):

    def draw_item(self, context, layout, data, item, icon, active_data, active_propname, index):

        scn = context.scene
        settings = scn.uvPerspectiveProject

        try:
            obj = scn.objects[settings.object_name]
        except:
            pass

        suffix = " (" + str( index + 1 ) + ")"

        row = layout.row()
        col = row.column( align = True )
        col.prop_search( item, "camera_name", scn, "objects", text="Camera" + suffix  )
        col.prop_search( item, "uv_map_name", obj.data, "uv_layers", text="UV map" + suffix )
        col.prop_search( item, "material_slot_name", obj, "material_slots", text="Material" + suffix )

    def invoke(self, context, event):
        pass

class UVPerspectiveProjectPanel( bpy.types.Panel ):
    bl_idname = 'lemon.uvperspectiveprojectpanel'
    bl_space_type = "VIEW_3D"
    bl_region_type = "UI"
    bl_label = "UV perspective project"

    @classmethod
    def poll(self, context):
        return context.mode == 'OBJECT'

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

        settings = scn.uvPerspectiveProject

        layout.row().prop_search( settings, "object_name", scn, "objects", text="Object" )

        if TargetObjExists( context ):
            layout.row().label( text="Cameras settings:" )

            row = layout.row()
            row.template_list( "UVPerspectiveProjectCamSettingsPanel", "", settings, "cameras_settings", settings, "camera_setting_index", rows = 3 )

            col = row.column( align = True )
            col.operator( UVPerspectiveProjectCamSettingsActions.bl_idname, icon='ZOOMIN', text="" ).action = 'ADD'
            col.operator( UVPerspectiveProjectCamSettingsActions.bl_idname, icon='ZOOMOUT', text="" ).action = 'REMOVE'
            col.separator()
            col.operator( UVPerspectiveProjectCamSettingsActions.bl_idname, icon='TRIA_UP', text="" ).action = 'UP'
            col.operator( UVPerspectiveProjectCamSettingsActions.bl_idname, icon='TRIA_DOWN', text="" ).action = 'DOWN'

            layout.row().operator( UVPerspectiveProjectOperator.bl_idname, text="Apply" )

class UVPerspectiveProjectCamSettingsProps( bpy.types.PropertyGroup ):
    camera_name = bpy.props.StringProperty()
    uv_map_name = bpy.props.StringProperty()
    material_slot_name = bpy.props.StringProperty()

class UVPerspectiveProjectProps( bpy.types.PropertyGroup ):
    object_name = bpy.props.StringProperty()
    cameras_settings = bpy.props.CollectionProperty( type = UVPerspectiveProjectCamSettingsProps )
    camera_setting_index = bpy.props.IntProperty()

def register():
    bpy.utils.register_module(__name__)
    bpy.types.Scene.uvPerspectiveProject = bpy.props.PointerProperty( type = UVPerspectiveProjectProps )

def unregister():
    del bpy.types.Scene.uvPerspectiveProject
    bpy.utils.unregister_module(__name__)

if __name__ == "__main__":
    register()


It is indeed annoying when you append materials from your library file and Blender automatically creates duplicates for all node groups with the same name, even when the groups are supposed to be exactly the same.

I have created a script that eliminates these duplicates efficiently for my usage. It searches all existing node groups, materials, worlds and if finds any duplicates (ending with .001, .002, etc), it replaces them with the original group if it is found.

After running the script the eliminated node groups will have 0 users, so after you save and reopen your file, they should disappear and your group list should be clean :)

import bpy

def main():
    print("\nEliminate Node Group Duplicates:")

    #--- Search for duplicates in actual node groups
    node_groups = bpy.data.node_groups

    for group in node_groups:
        for node in group.nodes:
            if node.type == 'GROUP':
                eliminate(node)

    #--- Search for duplicates in materials
    mats = list(bpy.data.materials)
    worlds = list(bpy.data.worlds)

    for mat in mats + worlds:
        if mat.use_nodes:
            for node in mat.node_tree.nodes:
                if node.type == 'GROUP':
                    eliminate(node)

#--- Eliminate the node group duplicate with the original group if found
def eliminate(node):
    node_groups = bpy.data.node_groups

    # Get the node group name as 3-tuple (base, separator, extension)
    (base, sep, ext) = node.node_tree.name.rpartition('.')

    # Replace the numeric duplicate
    if ext.isnumeric():
        if base in node_groups:
            print("  Replace '%s' with '%s'" % (node.node_tree.name, base))
            node.node_tree.use_fake_user = False
            node.node_tree = node_groups.get(base)

#--- Execute main
main()

A variant to eliminate OSL scripts

I never used OSL scripts, but as @IPv6 have asked, I guess this should work to eliminate duplicates of OSL scripts:

import bpy

print("\nEliminate OSL Scripts:")
texts = bpy.data.texts

for mat in bpy.data.materials:
    if mat.use_nodes:
        for node in mat.node_tree.nodes:
            if node.type == 'SCRIPT':
                name = node.script.name
                (base, sep, ext) = name.rpartition('.')

                # Replace the numbered duplicate with the original if found
                if ext.isnumeric():
                    if base in texts:
                        print("  Replace '%s' with '%s'" % (name, base))

                        # Replace the script duplicate for this node
                        node.script = texts.get(base)

                        # Remove the script duplicate from bpy.data.texts ?
                        texts.get(name).user_clear()


Get count of selected vertices in UV pane

If you enable UV syncing, selected UV coordinates will be echoed onto your 3D view, and the header will show you how many you have selected.


Renaming an obj based on a Vertex Group script

Use the active vertex group

import bpy

for ob in context.selected_objects:
    avg = ob.vertex_groups.active
    if avg:
        ob.name = avg.name


Advanced OptiX denoiser settings missing in 2.91

Figured it out. These settings are only for the NLM denoiser, not for OptiX (nor OpenImageDenoise). I somehow misread the docs at https://docs.blender.org/manual/en/latest/render/layers/denoising.html.


Switch on 'Quad View' in the Properties panel (N in the 3D View).

Or press Ctrl+Alt+Q.

By default, Front- Side and Top-View are fixed and a bit different than GMAX. But you can switch off 'lock' and then reassign the roles.

Having the timeline below is just a simple matter of splitting areas.

https://docs.blender.org/manual/en/dev/interface/window_system/areas.html


How to do a lightcast only Layer in Cycles?

I'm quite sure to not have fully understood your question, so before giving you some suggestions I would like to punctualize one aspect (as I have seen you are interested in compositing layers):

No transparency is involved in this scene, dark grey color of the plane/cube in shadow comes first of all from interaction of the plane/cube (diffuse white) with the world background light (which is colored dark grey). All the visible surfaces will produce a white alpha channel area.

You can remove the world influence on the scene by lowering the Background strenght to 0 or even completely remove the shader.

You can set the Max number of bounces of light allowed for each light source in the Lamp panel in the Object Data tab.

You could also tweak the "global" light path bounces, but you'll not have the precise control that the "per lamp" option allows.

By seeing your third edits I would suggest the following (more general) instructions:

Switch all lights off (Background too), except the light source you would like to isolate. All the light present in the scene is it contribution
Set the amount of bounces allowed for the light source (per lamp, or
globally if you are using an emission shader as a per object option
is not currently (2.75a) available)


How to highlight a polygon or a vertex under the pointer in Python?

Look at these templates:
1) Operator Modal View3d Raycast: With this you will find the polygon of a mesh under the mouse cursor.
2) Operator Modal Draw: This contains an example of using BGL for drawing in 3d view. With this you will be able to draw the edges of the polygon you find from raycast.


The fur I'm trying to make isn't looking like real fur. It's coarse and I don't know how to fix it

You seem to have clumping at 100%, which will make it look coarse.

In Particle Properties->Children->Clumping I changed Clump to 0 and in Particle Properties->Children->Roughness I changed Random to 0.5.  Whilst this may not be exactly what you are after, it looks a lot more 'softer'


The issue seems to happen because you have an n-gonal surface (the side of the sword has more than 4 edges). Usually, when renderers encounter faces that have more than three or four edges, they get confused.

To fix this, try to select the face and 'triangulate' (ControlT) it. This will split the faces into triangles, making the shape less ambiguous for the renderer.

If this doesn't work, you'll have to manually cut it up with the knife tool (K) until only quads and triangles remain. If you do this, try to make a uniform pattern (don't just cut randomly).