One way is by using drivers. Drivers allow you to calculate a value to use, this may be from other values in the same object, or from other objects. This answer provides examples. Also consider that drivers may be disabled by the user.

Another way is to setup a handler function. You could choose between using frame_change_post or a render_pre. You simply define your function and then append it to the handler list, then remove it when it is no longer needed.

def my_handler(scene):
    val = scene.objects['Cube'].location.x
    scene.objects['Sphere'].location.y = val + 1.6

def register():
    bpy.app.handlers.frame_change_post.append(my_handler)

def unregister():
    bpy.app.handlers.frame_change_post.remove(my_handler)


this effect can be achieved using the dynamic paint as in the following setup :

select the boat and add dynamic_paint in properties->physics and click add brush  ( you may want to use a simple invisible cube instead of the real boat )

select the sea and add dynamic paint  and click add canvas with the following settings :

this the modifiers used for the sea :

bake the simulation ,
this is the result :


Why does lighten change the color of the dark part in mix rgb?

Lighten = pick the highest value color
As shown in the manual:

Blender is using the transformations as described in the Gimp specifications:

Lighten only mode compares each component of each pixel in the upper
layer with the corresponding one in the lower layer and uses the
larger value in the resulting image. Completely black layers have no
effect on the final image and completely white layers result in a
white image.

So it's basically using the highest value color, thet's why it's more probable to affect the darker areas as your shadows
https://docs.gimp.org/en/gimp-concepts-layer-modes.html


constraint one object within another & then rigid body

Push -
Not entirely clear how a hollow square can be a cylinder so I've done this as per your diagram.
All are 3D pieces and all are 'Rigid Bodies'.

The T-piece is suspended from a "Rgid Body Constraint" set to "FIXED".  That's positioned well above.
I see now I'm back online that your T-piece isn't moving, but hinged.  That is just a matter of lowering the constraint Empty down close to the T.  You could also try with the constraint set to "Hinge".
The red outer container (Cylinder/box/whatever) is a passive rigid body.

The brown 'Pusher' is also passive but ticked as 'Animated' and keyframed to move left to right.
Addendum  8th March, 2021
A 2nd Blend file has been added below, this one without the Rigid Body Constraint.  That allows the T-piece to sit on the box/cylinder and react to surfaces it comes into contact with.  In an extreme case where the pusher moves excessively, it will, as in the real world,  actually force the T up far enough to get underneath it.
With a normal stroke and without the RB Constraint to hinge the T piece, it is able to react with collision surfaces in the manner you're seeking and still in similar fashion to the movie clip above.
You'll notice the T-piece's physics 'Shape' has been changed to mesh and it's Collision Margin changed to .01 .
1st Blend file -

2nd Blend file -


Link provided by Duarte Farrajota Ramos is great place to find topology tips (I'm using it by myself) but sometimes you can't find technical aspects of how to create particular topology.

Before I start I want to encourage you to look for good topology without focusing on specific app. Good topology is good, no matter which software was used.

You can achieve it in several ways, I'll show you the quickest one I've found, possible with LoopTools addon (you can find it in User Preferences) wich is shipped with Blender.

Final result:

Quick method:

Press W > Subdivide to subdivide a Plane.
Delete center Vertex.
Select Edge Loop.
E to Extrude then S to Scale it.
W > LoopTools > Circle.
Add Subdivision Modifier.
(Optional as needed) Use Bevel or Mean Crease on edges.

In my example I've used Bevel with 3 segments on inner circle edge and corner edges of shape, also I've used Mirror modifier. Everything was made from simple Plane.

Extension (technique without addon):

I've thought that maybe for some reason you don't want to use any addons so here is a method without it.

  1-4 steps are the same as in first method.

Press Alt+M > At Center.
Press Ctrl+Shift+B to Bevel only Vertex and scale it as needed.
X > Only Faces to delete central face.


How to save Animation Nodes cache without baking to mesh?

There is currently no built-in way to save cache persistently. However, for simple data types, you can store your cache in ID properties in objects. For instance, if you have a vector list vecs that you wish to save, you can save it in an object obj using the expression:

obj["frame_1"] = vecs

And retrieve the data using the expression obj["frame_1"]. You can change the key frame_1 to anything to cache multiple data, per frame maybe. For example, if you wish to save the locations of vertices along frames, you could use the following node tree:

If you now reopen your blend file and use the following node tree, you will get the data you saved:


Using compositor you can easily output passes you want.


Missing OpenAL32.dll After installing 2.79

Solved I have downloaded the .zip version of blender. Opening the folder I found an OpenAL32.dll Copy and pasted into the blenderfoundation/Blender folder (where the blender.exe file is) Now clicking the exe icon runs the program Only problem is that it doesn't know the user preferences or start file Found those in the old Blender version folder in Configs Copied and pasted UserPref and Startup to the config folder of new version All seems okay now


How to get sharp red to blue in weight paint from vertex group

The values are correct - the sub-division represents it with gradient.


A single object in Blender = multiple objects in Pepakura

Assuming that you are using .obj file exange format, Pepakura will import the object exported from Blender as a single object if in blender you join all the geometry in a single object.

Pepakura is an unfolding software. Starting from the given geometry,it caluculates the angles and suggest where to put seams, add labels... but all rely on the initial geometry. If you give it two disconnected pieces, even if they are "the same object" they will be considered disconnected, so their boundaries will obiuvsly be seams.

Notice in the images above how pepakura ignores the fact that the cubes are intersected and cosider them as two disjoined cubes (as they are also in Blender, evon though they are stored in the same object).

You should work on your geometry and make all the pieces that you want be connected a whole.

You can use:

Boolean operations
Bridge edge loops, or add faces manually or with F2 add-on if the borders are distant
Remove doubles, if border are almost in the same place
etc...


How to project an image, and bake it so to speak, on an angled plane

You can use the "Project from view" option from the unwrap menu. That will project the uvs of your object to match the dimensions of your camera.
Create a plane an subdivide it a number of times. Place a camera so that it faces the plane at an angle and there is no empty space within the render frame.

Remember to set your render dimensions to the same ones of your reference image. Example 350 * 350

While in edit mode, press  u or click on "UV" on the topbar and choose "Project from view".

Create a new material and assign it to your plane. Now add an "Image texture" node and plug it into the color of your shader. Select your image. Set it to "Clip" so that it doesn't repeat outside the camera view.

Result from the camera view Numpad 0:

And from top view Numpad 7 :


Remove vertex mid of edge, Function like Cinema 4d's Optimize

Use Limited dissolve

Mode: Edit Mode

Menu: Mesh ‣ Delete ‣ Limited Dissolve

This tool can simplify your mesh by dissolving vertices and edges separating flat regions.

Max Angle

Reduces detail on planar faces and linear edges with an adjustable angle threshold.

All Boundaries

Always dissolve vertices that have two edge users at boundaries.

Delimit

Prevent faces from joining when they don’t share certain properties (material for e.g.).

From:
https://docs.blender.org/manual/en/dev/modeling/meshes/editing/mesh/delete.html


How to select all keyframes from left or right having current frame as pivot?

Right click the key frame that should be the first of those you need selected and the hold Ctrl and either click the [ key for all keyframes on the left or the ] for all on the right (while Ctrl is held).


In the particle panel, click on advanced, then in the velocity section, lower the normal strength and grow the Z strength :


Indirect Only filter for Collections not supported in EEVEE?

Yes this is a feature that works only in Cycles.

  Indirect Only (collection only)

  Objects in these collections only contribute to indirect light – Cycles only.


How would I procedurally texture a marble tile floor without the texture spreading across every tile?

One way of doing this would be:

Separate all your tiles as a single object so you can use the Object info node random output in order the create a tile black and white mask:

You can then create another wave texture and combine it with the one you already have using the tile mask as factor:

You obviously need to change the texture coordinate of the second wave to create variation. Put a color ramp node and play with its value to have stronger difference:

http://pasteall.org/blend/index.php?id=50740

As @robin betts points out in the comments, if you need to keep the array modifier you can duplicate the object, do the same process, and bake the mask into a file image. Or if you want to keep a "semi" procedural creation use dupliface instead of the array.


I just found out that this is what outflows are for.


How do you move a bone in the Blender game engine?

I was missing an update call: armature.update()

More precisely, bge.logic.getCurrentController().owner.update() needs to be called after any updates to the armature in order for it to update in the game engine.


Rendering Environment pass without Combined pass in Cycles

You can't use both volume scatter and a background in the world settings at the same time (read this post).

The workaround is creating a "domain" object around the area where you need the volume scattering. In order to be transparent, the domain will have no surface and only volume scattering.

Your HDRi world texture can then be used normally (Keep in mind that volume scatter will make things a bit darker so you might need to make your light sources and environment texture brighter).

(HDRi by Giant Cow Films)


The GTX 970 and GTX 980 seem to have massive VRAM leaks in Blender 2.77.
The problem is greatly reduced in the 2.78 Test Build.

https://wiki.blender.org/index.php/Dev:Ref/Release_Notes/2.78


What is the recommended object format for exporting to substance painter 2?

From experience it's highly recommended to use .Fbx formats due to it being the standard for Autodesk software. It's also natively supported in a majority of game engines as well as third party software such as those developed by algorithmic.


Set initial position and rotation of a bone (python)

Thanks to batFINGER I've solved the issue.

bpy.ops.object.mode_set(mode='EDIT')
for h in range(boneCount):
    name        = f[h * 3 + 1][:-1]
    parent      = int(f[h * 3 + 2])
    coords      = f[h * 3 + 3][:-1].split(" ")
    # Converting quaternions values to matrix 4x4
    quat        = mathutils.Quaternion([float(coords[6]), float(coords[3]), float(coords[4]), float(coords[5])]).to_matrix().to_4x4()
    # Converting location values to matrix 4x4
    pos         = mathutils.Matrix.Translation([float(coords[0]), float(coords[1]), float(coords[2])])
    bone        = skl.data.edit_bones.new(name)
    bone.head   = mathutils.Vector([float(coords[0]), float(coords[1]), float(coords[2])])
    # To establish a length of bone
    bone.tail   = mathutils.Vector([float(coords[0]), float(coords[1])+0.001, float(coords[2])])
    # To apply the rotations
    bone.matrix = pos @ quat

With this script I'm able to load the original bones rotations in matrix. After bone declaration, must set the bone.head in order to place the bone. bone.tail is useful for boen size, else the bone will be larger. Now, in order to set the desired rotations without altering the object structure, you must set bone.matrix. Is better to use mathutils for creating correct matrix.
This is how it looks like
As you can see, bones are well rotated looking at the axes.


How is convergance plane distance used in side-by-side stereo 3D?

From what I know now, the convergence plane distance is the distance between the projector and the image being projected as written in blender. In fact for the anaglyph preview you can change it by clicking on the window tab/3d view and select side-by-side.

This setting seems to be used if you have some headset display. If you type the N key and go to Stereoscopy you can choose Left/Right or 3D that shows both. Now the interocular distance is the actual distance between the cameras as shown in the print screen.

Blue and red represents both cameras and the darker rectangle is the convergence plane distance

A setting that Blender suggest is the convergence plane distance/30 for the interocular distance.

Source: http://blender.org/manual/fr/render/workflows/multiview/usage.html


Dynamaic Paint Not Spreading Blender 2.79b

No answers posted to my question.  To fix the problem, I started from scratch.  Then I added more points where the brush touched the canvas (letters), in order to get the paint to spread to the letters.  I did remove all previously baked images, but after I was done, I did see a physics file I did not remove.

While it got the job done, I'm sure this is not the best way to correct the problem nor does it explain why the paint would not spread to all the letters


Finished Render looks different from Preview

It appears that you have Motion Blur enabled in the Render Settings. Motion blur is not currently supported in viewport renders, hence the confetti looking different in the final F12 render.

To disable, simply un-check the box in the Render Settings tab:


Different screenshot would be useful in your question, specifically screenshots with an expanded properties shelf (T key) in each version. My starting guess is that the models shown in the two versions may not have identical rotation settings to start with, in which case applying the rotation might resolve this issue.


Press C while in knife mode to enable Angle Constrain.
Note that it snaps to angles relative to the view. For cuts on faces which are not aligned to any axis, you can:

Press ShiftNumpad 7 to align the view to the face

Press K to enter knife mode, then C to enable Angle Constrain:


How to get out of the mode with many strands

I'm not exactly sure what you're asking but from what i understand what you want is to turn off the SubSurf modifier in edit mode, go to the modifiers tab and press the button showed here :


How to copy animations to a rig with different bones?

Delete the bones from the model you want to duplicate your animated bones to. Then copy and paste the bones from the original armature and move it into the model. Then do the ctrl p and combine the two. After that if you play the animation you will see if it rotates that the rotation is much more major the farther away it is from the original armature not only will you need to delete the rotation but also the position. For it will move exactly in the spot of the original armature. The only thing that would work is scale keyframes. The others would simply not work when copied. The only possible way I believe is if you could re-calculate the x and y position to make it from go to x 30 to + 30 x. If that makes sense.


Problem with the size of object in the blender interface after changing to a bigger monitor

In order to enlarge the cursor size, font size and the overall windows, you can always go to User Preferences by pressing CTRL+ALT+U or by navigating through File drop-down menu. You will find many options there. Two such options are depicted below. Scale your blender Windows accordingly and check on Large Cursors. Navigate through other options and you will eventually get a good view of the cursor and Windows. Alternatively, you can also use Windows Magnifier to see Whats there on the screen from a fairly far distance. Don't forget to Save changes.


name : bpy.props.FloatProperty( name = name )

is assigning bpy.props.FloatProperty( name = name ) to the variable called name ( the name before the : )
Then you try to assign a value to so.custom_prop_gr.fl_prop which does not exist, because you used the variable name to create the custom property.
Then in your print command at the end:
print( "dina prop (fl_prop): ", so.custom_prop_gr.fl_prop )

is also trying to call so.custom_prop_gr.fl_prop which does not exist.
Change:
so.custom_prop_gr.fl_prop         = 90.5
print( "dina prop (fl_prop): ", so.custom_prop_gr.fl_prop )

to:
so.custom_prop_gr.name         = 90.5
print( "dina prop (fl_prop): ", so.custom_prop_gr.name )


How to control user interface (panels) across Addons

The common way in Blender is to append or prepend draw functions via the panel "class":

bpy.types.CATEGORY_PT_panel_name.append(draw_func)

Registered bpy classes are globally available, you can check for a certain one with hasattr(bpy.types, "CATEGORY_PT_panel_name"):

import bpy

# Change this to some type that doesn't exist and re-run
panel_type = "VIEW3D_PT_tools_transform"

def draw_func(self, context):
    layout = self.layout

    obj = context.object

    row = layout.row()
    row.label(text="Hello world!", icon='WORLD_DATA')

    row = layout.row()
    row.label(text="Active object is: " + obj.name)
    row = layout.row()
    row.prop(obj, "name")

    row = layout.row()
    row.operator("mesh.primitive_cube_add")

class HelloWorldPanel(bpy.types.Panel):
    """Creates a Panel in the Object properties window"""
    bl_label = "Hello World Panel"
    bl_idname = "OBJECT_PT_hello"
    bl_space_type = 'VIEW_3D'
    bl_region_type = 'TOOLS'
    #bl_context = "object"
    bl_category = "Tools"

    # re-use draw functions
    draw = draw_func

def register():
    if hasattr(bpy.types, panel_type):
        getattr(bpy.types, panel_type).append(draw_func)
    else:
        bpy.utils.register_class(HelloWorldPanel)

def unregister():
    if hasattr(bpy.types, panel_type):
        getattr(bpy.types, panel_type).remove(draw_func)
    else:
        bpy.utils.unregister_class(HelloWorldPanel)

if __name__ == "__main__":
    register()

The draw functions are internally stored in Panel.draw._draw_funcs

You can remove them like you add them, the method is just called remove.


Shadow Terminator Offset
you can find this setting in
Properties ‣ Object Properties ‣ Shading
increase it to 0.15 which is really enough
Note: this is a new feature came in blender 2.90 so you need to update blender to some newer version

Note
This property artificially alters the scene’s lighting and is not
energy conserving and consequently not physically accurate.

Got from the blender Manual: https://docs.blender.org/manual/en/2.90/render/cycles/object_settings/object_data.html#shading


You could do it this way:

Create a spiral with shift A > Curve > Curve Spirals > Archemedian (maybe it needs the Extra Objects addon?).
Play with the parameters on the bottom of the T panel (left of the 3D View), give it a Height value.
Put the origin of the spiral on its bottom. Check the direction so that it goes up.
Keep the spiral selected and in the Properties panel > Data > Shape > Twisting dropdown menu > choose Z-up, so that the text will stand up.
Create your text with shift A > Text and type what you want in Edit mode.
Convert your text to mesh with alt C > Mesh From Curve.
Put the text at the same point as the spiral origin.
Give your text an Array modifier.
Give your text a Curve modifier with the Spiral as Object.
Now play with the Array Count, with the Array Relative Offset, with the Curve Deformation Axis, and with the text object rotation, until the text correctly follows the spiral.
Maybe your text mesh will need some work and additional edge loops so that it bends correctly.


Nearly this answer.
For all modifiers you can run this script that will apply them all:
import bpy

for ob in bpy.context.selected_objects:
    bpy.context.view_layer.objects.active = ob
    for name in [m.name for m in ob.modifiers]:
        bpy.ops.object.modifier_apply( modifier = name )

To run the script:
open a text editor, create a new text, paste the code above, select the wanted objects, and use the button indicated in the picture below:

If you want to apply modifier that are visible in viewport only, use this:
import bpy

for ob in bpy.context.selected_objects:
    bpy.context.view_layer.objects.active = ob
    for name in [m.name for m in ob.modifiers]:
        modifier = ob.modifiers[name]
        if modifier.show_viewport:
            bpy.ops.object.modifier_apply( modifier = name )


This is called Muting a node.  You can mute or unmute a node by selecting it and pressing M.  Muting a node will connect the inputs directly to the outputs according to datatype in the same way as Delete With Reconnect (Ctrl+X).

When muted the header of a node will turn red and it will display red wires showing which inputs are connected to which outputs.


Go to the object(s) in the collection. Go to edit mode (for each one if you have more objects) select the bottom two vertices, then hit SHIFT + S and choose Cursor to selected. Then go out of edit mode, hit CTRL + SHIFT + ALT + C (yes all at once) and choose origin to 3D cursor. Now the objects should be positioned on top of the plane in your particle system.


Scaling a cylinder along both X and Y axis

You can exclude an axis by pressing ShiftX/Y/Z. So to scale on the X and Y you would press S, ShiftZ and then drag the cursor.

With a mirror modifier:


After changing the pose in Pose Mode, do Ctrl+A and Apply Pose as Rest Pose


How do I access the faces of the Subsurf modifier?

I needed to hit Apply in the modifier settings in order to get faces of the subdivided cube editable in Edit mode.


why does it in texture paint mode paint on each face at the same time?

I just found out, that I had my UV map scaled way too much. It didn't paint on faces, but only replicated itself to fit the UV.


First of all: using CPU or GPU would not make any difference on the characteristics of the rendered image, other than rendering faster or slower.

I see three possible reasons why you have a black and white image:

You set up materials in blender internal and didn't create materials for cycles.

When no materials are present cycles will render everything with the default material, which is gray.

Cycles and Blender internal's materials are not compatible or interchangeable. you need to create new ones them using material nodes.

Maybe you did set materials but you set the output to render as B&W. Set it to RGB or RGBA (Red, Green, Blue, Alpha)

Maybe you did set the materials correctly and the output to RGB (or RGBA),
but you set the render layer to use only one material, overriding all of the other materials for the scene:


Place a 3D building instead of real building

You can use Camera Tracking to do that, here is a YouTube tutorial (Blender Guru)

That explains how to do it in detail:
https://www.youtube.com/watch?v=CVPcT0dJmoY


How can I view a Displacement texture on a model

It's pretty much the same as in Cycles.

Add a light to your scene (a sun, for example)
Tab into edit mode, unwrap your plane
Add a material with a texture to your plane
switch 3D view to "Rendered"


TypeError: Element-wise multiplication: not supported between 'Matrix' and 'Vector'

Blender 2.8+ Matrix multiplication

The question code method was in place for Blender <=2.79.9. Blender has since adjusted its mathutils module, replacing the asterisk * with the at symbol @, aka the PEP 465 binary operator, for multiplying matrices with vectors.

>>> M = Matrix()
>>> v = Vector()
>>> M @ v
Vector((0.0, 0.0, 0.0))

>>> v @ v
0.0

>>> M @ M
Matrix(((1.0, 0.0, 0.0, 0.0),
        (0.0, 1.0, 0.0, 0.0),
        (0.0, 0.0, 1.0, 0.0),
        (0.0, 0.0, 0.0, 1.0)))

Note using @ will throw the "same type of error"  in <= 2.79.9 Replace with * as in question code.

>>> M = Matrix()
>>> M @ M
Traceback (most recent call last):
  File "<blender_console>", line 1, in <module>
TypeError: unsupported operand type(s) for @: 'Matrix' and 'Matrix'


Is it possible to change material overtime by keyframes in swipe effect?

Using a simple gradient and color ramp will allow you to control two different materials for the same object:

Then is just a matter of animating the value for the mapping.


The object's axis is probably not aligned with the world's axis any more, you must apply the rotation: CtrlA > Rotation


Use the Image Texture Node for the material applied to the screen portion of the phone. The Image Texture Node accepts videos as well.

Remember to UV unwrap your object.


Blender isn't importing mtl correctly with obj?

You need to have your viewport shading set to Textured to see any textures or materials on the imported model. Press AltZ to switch to textured view or alternatively, open the properties panel with N and under Shading, tick Textured Solid.

(Click the images for a higher res.)


It's because the 3 meshes' faces are overlapping. Move the faces of 2 of your 3 objects a tiny bit away (along normals or X/Y/Z).


Missing Noise Texture Node in Material View

You need to press A (Add) to have access to the node Search option, not Spacebar. Anyway, to create a Noise Texture, press A > Texture > Noise Texture.


Make the IK bone only rotate on the x-axis

You cannot use other constraints in conjunction with IK. You need to use the built-in IK limits. They are in the Bone Data buttons, in the section marked Inverse Kinematics in The Inverse Kinematics section in the properties > Bone panel

http://wiki.blender.org/index.php/Do...#Bone_IK_Panel


Classic case of gimbal lock.
If you rotate the middle axis 90 degrees, the two other axes will be aligned thus reducing the degrees of freedom to two.

To fix the problem, you can either change the rotation order or use quaternions.


The yellow dot is the origin of the object.
To move it, select your mesh in object mode and then:
right click or object menu up there--> set origin--> "geometry to origin" or
"origin to geometry" as you want to do


How can I 'lock' the position of an object when applying curve displacement?

I recommend using the [Wave Modifier] for various reasons including

The Wave Modifier is often used for this purpose.  Its purpose is very clear.
Your curve above may not be long enough for longer repetitive motion and the endpoints tangents could affect the final result.
The difficulty you are already experiencing
The Wave Modifier has a [falloff] to keep the flag attached to the pole.  No Pun Intended. The selected empty serves this purpose in the image above.
As an alternative that you can create a vertex group to limit the vertex movement on the flag mesh near the pole, to zero.
As a [Not Recommended] alternative you could animate the curve rather than moving it.


The easiest way to fix this problem is to select the object, and go to properties editor -> object data properties -> normals and enable auto-smooth with an angle of 30 degrees or more:
.


Middle verts snapping to other side of the model

It looks like there were active X Mirror in edid mode, after dissabling it everything works just fine.

I never even imagined it could do weird stuff like that...


How to get distance of vertices from an arbitrary plane in Python?

You can use the dedicated function :mathutils.geometry.distance_point_to_plane(pt, plane_co, plane_no) were you supply the plane normal and one point from it, and the point you want to calculate the distance to as in the following example :

import bpy
import mathutils

plane = bpy.context.scene.objects['Plane']
p1 = plane.matrix_world*plane.data.vertices[0].co
p2 = plane.matrix_world*plane.data.vertices[1].co
p3 = plane.matrix_world*plane.data.vertices[2].co
plane_no = mathutils.geometry.normal([p1, p2, p3])

obj = bpy.context.object
mat = obj.matrix_world

for v in obj.data.vertices:
    pt = mat*v.co
    d = mathutils.geometry.distance_point_to_plane(pt, p1, plane_no)
    print(round(d, 4))


You have only 1 UV on each character and your UVs intersect.


How can one do rendering with Cycles using an NVIDIA RTX GPU?

Update as of July 29th 2019: NVIDIA RTX GPUs are now officially supported and can be used to accelerate renderings in Cycles using the raytracing cores of RTX cards. You can read more about this from the Blender Developers blog here.

In the past, RTX GPUs were not supported even for normal use cases unless you compile Blender from source code yourself or download a pre-compiled version of Blender 2.79 (link below)  for Linux. However, if you want the latest features/bug fixes you need to compile Blender from source still. People have compiled Blender this way and submitted their results to Blender OpenData too. As shown on Blender OpenData website, RTX 2080 Ti is currently the best GPU for rendering scenes with Cycles as of now.

If you're using Windows you can follow these instructions to compile Blender yourself:

Install Development Tools

Subversion, Git, CMake and Visual Studio must all be installed.

Install Visual Studio 2017 Community Edition (free)
Install Subversion for Windows (SlikSVN)
Install Git for Windows

In the installer, choose to add Git to your PATH to ensure the Git version is in the splash screen.

Install CMake

In the installer set the system path option to Add CMake to the system PATH for all users.

Install CUDA 10 for CUDA support in Cycles.

Download Sources and Libraries

Create a folder to store your copy of the Blender source code. This guide will assume your chosen folder is C:\blender-git.

Then open the command prompt window by hitting Windows+R, and then typing cmd, or by searching for it in the start menu. Then type the following commands.

For 64-bit Windows, check out the precompiled libraries with Subversion like this:

cd C:\blender-git
svn checkout https://svn.blender.org/svnroot/bf-blender/trunk/lib/win64_vc14  lib/win64_vc14

For 32-bit Windows, use this command instead:

cd C:\blender-git
svn checkout https://svn.blender.org/svnroot/bf-blender/trunk/lib/windows_vc14  lib/windows_vc14

Download the Blender source code:

cd C:\blender-git
git clone git://git.blender.org/blender.git
cd blender
git submodule update --init --recursive
git submodule foreach git checkout master
git submodule foreach git pull --rebase origin master

Compile Blender

cd C:\blender-git\blender
make full

Source for the things above. In case you follow these steps and you still cannot get Cycles render anything using your RTX card, you need to follow the steps at the end of my post to rebuild/recompile Blender.

For Linux:

If you're on a Unix-based OS you can follow the instructions written here; Make sure you have installed CUDA 10 already. If you don't want to compile Blender yourself, you can instead download a version of Blender 2.79 compiled against CUDA 10 from here.

Update as of Dec 3rd 2018:

As of today, the master branch of Blender natively supports NVIDIA RTX cards. So you don't have to follow the steps below anymore.

In case you follow the above steps and still cannot render anything using your RTX card, you need to do the followings to recompile Blender. This step works for Windows, Linux and Mac:

Open CMakeCache.txt
Look for CYCLES_CUDA_BINARIES_ARCH
Add sm_75 to that list
Rebuild/Recompile Blender


Making an object move along a path:

Blend file:

First up place your 3D cursor where the center point of the path is to be.

Add a "Curve-->Path" at that point.

Select the curve and goto edit mode.  The path's direction of travel will be indicated by the (feather) arrows.  Go back to Object mode and rotate the path in the Z axis to it's desired direction of travel.

(Remember you're currently at the proposed route's mid point)

Return to Edit mode and at far right in the curve's properties panel, click on the Geometry icon. (a letter C drawn back to front)

Select the "2D" button.  This will ensure there will be no variation in height from ground level to make the route a lot easier ro set up.  Later it's height can be varied like a roller coaster if required.

Further down open the "Path Animation" tab, set the "Frames" slot to the maximum frames the object will be taking to travel the entire route.  The higher the frame number, the slower it will travel.

Place this same frame figure into the "Evaluation Time" slot immediately below.

This is a good time to set your timeline's max frames as well.  Give it more frames than the path's maximum unless there is a specific need not to.

With the path still highlited, get back into Edit mode.  You'll see that there are 4 vertices. (waypoints)  You can have as many of these as you wish, but for now we'll stick to just four.

Drag one of the end vertices to where the path is to end.  If it distorts the curve too much, just move it to some convenient holding point.  We can place it properly later.  Just make sure it's been moved to somewhere so it will be travelling in the right direction.

Do the same with the other end vertice.

Now move each of the inner 2 vertices to intermediate points, then the end vertices again until you end up with a roughly circular shape.

With the route laid out, it's time to setup the 2 keyframes that will force an object to move along the path.

Make sure you're in Object Mode.  Press SHIFT-C to center the 3D cursor to location 0,0,0 ((x,y,z)

Add a cube or whatever but don't place it on the path, leave it where it is for now.

It's important that the cube and curve both share the same Origin point, so with the cube selected, press T to get the "Tools" panel up at left. Open the "Tools" tab at top left and select "Origin-->to 3D cursor"

Now select the curve and do the same.

Select the cube again, and in it's properties at right, click on the Constraint icon. (looks like two links of a chain)

Select "Follw Path". (in rightmost list)

Click on the cube icon (Target) to see your curve listed there.  Select that.

The cube in the 3D window should jump to the starting point of your curve.

Also tick the "Follow Curve" box when you want the object to be facing forward and always aligned to the path as it travels.

Select the path curve again and drag the timeline cursor to frame 1. Make sure the path's evaluation slot is showing 0. (Zero)

Place the Mouse cursor into the Evaluation slot and press letter I (i).

This will INSERT a keyframe in the path's strip in the Dope sheet.

Now move the timeline's cursor to the frame where the object is to reach the path's end point. (destination)

Check that both the Frames and Evaluation slots are both showing the same (end point) frame numbers.

With the mouse cursor still in the Evaluation slot, press letter I again to create the destination keyframe.

Your cube should have jumped to the curve's destination waypoint in the 3D window.

The path is now setup, your cube ready to take passengers and fares!

Drag the timeline cursor (or press CTL-A) to see the cube moving along the path.

If wanting to set a camera moving along the path, you might like to take a peek at this Camera "Jitter" When circling around object if the camera is a nervous passenger and gets the "jitters", literally!

Adjustments to the path's length, speed of travel, intermediate starting and stopping points are all possible.  If needing help with these, new questions would be best.  This post is already too large.


Wrong behavior when I try to apply the UV grid texture to my object

In the first screenshot, it seems that the penguin has no material, unlike in the last screenshot where the penguin has 3 materials assigned (and there it shows the texture)..?

Could it be just this?

Edit:
Following you request in comments/chat, I did a test:

1.I  downloaded your file, saved on my desktop

I created a new default file in blender
I appended just the penguin mesh from your file (I found it's named "untitled" in your file, under "mesh" folder.
Then I selected my default cube object, and switched to the "object data" in its properties panel
From the "browse mesh data to be linked" selection tool, I selected the previously imported penguin mesh, named "untitled".
Now my "cube" object has a penguin shape. Your UV grid also gets imported.
Setting viewport shading to "textured" shows the textured penguin!

So, I think the object in your file was corrupted, but the mesh is fine.

You can correct your file in this way, I think.

Btw, your mesh has arms normals inverted, select all mesh vertices, and fix them (CTRLN).

This is my file:

Hth.


How to make a window brighter without changing light of other objects in the room?

You can control the brightness of the HDR with the slider for the World>Surface>Strength.

See:

How can I create a silhouette using HDR in cycles?

To use two different light intensities in the same image used for the background, one to light the scene and one that is only seen by the camera you can use a light path and use "is camera ray" to control the mix of two different background nodes

Read:  Increase brightness of HDR to light the scene, but keeping the background at a lower exposure


The Ambient Occlusion shader can look unrealistic because unlike most other cycles shaders, it is not based on how light interacts with materials in the real world.

Instead, the lightness of shadows depends on how far other objects are. If it "sees" an object close by, it assumes that part of the mesh should bee in complete darkness. Otherwise, it produces a lighter color. If the ray tracer reaches no objects at all and reaches the sky, it produces very bright colors.

While unrealistic, AO has it's uses. It will usually give you less noise than the diffuse shader, whose behavior it very loosely imitates. This means that you can sometimes get away with fewer samples (and hence a smaller render time) by using AO.

However, this will not give you a realistic rendering. If you are willing to use more samples and want a photorealistic picture, use the Diffuse shader instead.

You can compensate between realism and quick rendering by mixing AO and Diffuse using the Mix node:

AO only

50% AO, 50% Diffuse

Diffuse only

Notice that mixing the AO with diffuse, you can reduce some of the unnatural brightness resulting from AO.


Editing a material without assigning it to the active object

Presently there is no experimental area to create materials before assigning them to an object. This leads to workarounds, and they may be obvious. Ways that come to mind are:

script it, and assign it.
or, create a dummy object like a suzanne (because it's shapely) and create the new material for that and tweak it until satisfied. Then assign the material to the object(s) that you do want to use it with.
or, start a second instance of blender, create suzanne, create a material for it (give it a good name), then save the blend. Then in the original blend go to File > Append > (select file with the material) > Materials > (select the named material) Append . This will append the material to your current .blend file. Assign the new material to the desired object.

Remember, Giving a fake user (the F button) to a material tells blender not to delete that material if it isn't assigned to any objects, when the .blend is saved.

ps. I don't like to use bold letters often, but good names are very handy.


Here's my base for how I control my carbon fiber material.

This particular result is stylized for the purpose of indicating the primary color's that I change, to get what I want.

And Below is my node setup:

As time allows, I will circle back around on this, and add the text step-by-step to get this node setup for completeness, however lacking this the images should suffice for now.


Trackpad behaviour - acting like mouse (OS X Macbook)

Sorry—answered own question. Turns out to be related with the OS, not to do with Blender.

For any one else experiencing this problem, just sleep and wake the computer then relaunch Blender. Blender should now recognise trackpad input how it should. Hooray!


Directly from Blender only using python can be done via pypotrace. This is a python package that binds to potrace. potrace is also used by InkScape for converting images to Paths. You will need to include potrace and pypotrace in your add-on.

The result of the trace is a path. You will need to develop to you likings how to convert this to an SVG. But as SVG is just an XML file that will not be that hard.


Turns out it is something that the Hardops add-on is adding. Mystery solved.


Game engines are real-time engines.  And culling the backside of a polygon helps the engine to render things faster.  There are no settings in Blender you can turn on or off to control how it is displayed in a game engine.  You have to either "solidify" your model in Blender, or find out how to show models double-sided in those game engines.


Changing IOR for Subsurface Scattering in Cycles

Well, I'm really happy that you asked this question.  I decide to try using the Fresnel Input Node to modulate the various Input sockets of the SSS shader and the results are interesting.  Using Fresnel for the radius adds depth, but it does dampen the SSS effect for the front facing poly's, so maybe it would be better to mix this setup with a stock SSS node.  Using 3 Fresnel Nodes with different IOR values and a Combine node for the Radius not only adds depth but adds a tone gradient which makes the SSS results interesting I think.

Here is a basic setup which uses a model that I recently rebuilt for someone so it can be used with Cycles bake.

There is an Environment Texture set to a value of 3 and a front facing overhead sun light at about 11:00.

The model on the Left uses a stock SSS shader with radius values of 0.9, 1.5, 0.7. for the hair.  The values are 2.0, 1.45, 0.35 for the face.

The model in the center uses a Fresnel node plugged directly into the Radius of an SSS node so all 3 values have the same input.

The model on the right uses 3 separate Fresnel nodes to control the 3 values of Radius for the SSS node.  The Fresnel values are the same as the radius values for the model on the left.

It's subtle and mostly just visible at the edges the way I did it here, but if you put some effort into it you may get somewhere with this.


How do I use the "Proportional Falloff Tool" to create doughnut frosting as per youtube tutorial?

Just change the proportional size with the mouse wheel or with PageUp or set it using the operator result:


Rendered view different than camera view in Viewport

it seems that you have a keyframe on the timeline on frame 2, maybe on that keyframe you staged the camera in a different way than frame 0 or 1. Try to remove all keyframes from the timeline, then go to frame 1 adjust the camera in the way you want and render (be sure you are at frame 1)


BT.709 is an HDTV color standard, hence different options list. The user mentioned may use such a device. It'd be good if his device had a VGA input either. See color.org site for more info on the subject.


Automatic weights not working with rigify (auto- python checked)

so i figured it out but to be honest it raises more questions than it answers.

so...
how i got it to work:the symbol on his chest is part of the same object but is a different mesh. after deleting that it seemed to work.

however the collection of strange things:
Note: in the following when i say automatic weight didnt work i mean that it created empty vertex groups with no weighting.

1: even though i it was mirrored, when i applied the mirror there was an error saying that the mirror may act unexpectedly, this stopped automatic weights from being applied..at all.

2: i had made my own rig prior to attempting rigify, before deleting the chest symbol, if i removed the armature modifier of "my rig" but kept the vertex groups then automatic weights would apply to the new meta rig except for the fingers, and would not apply to the rig ( that is created from rigify) at all.

3: after i deleted the vertex groups of "my rig" the mesh would not apply automatic weights to either the meta rig or rig.


Complex mesh deform with array for baking (necklace around the neck)

I'm not sure there's any easy way, except using the fantastic Wrapping Tools addon by Rich Colburn (which by the way allows you to create an unwrap version of any object).
You could do it with a cylinder used by the necklace as a Surface Deform object that would shrinkwrap around the neck, but when the shape begins to be complicated, this addon seems much more convenient.

Once you've installed the addon, duplicate the neck. Select an edge as if you were going to mark seam, and rip it (V).

In the N panel > External Tools tab, press Create UV Shape. It creates a new shapekey for the object.

The panel is automatically refreshed, a Shape Control appears which acts like the Shapekey value. Tweak it to 1, the object flattens like a UV unwrap.

Select your necklace, put it just over the neck object, in Edit mode make it follow the shape of the neck.

Back to Object mode, select the necklace, shift select the neck, press Bind to Surface, then Scene Update.

Move the Shape Control value back to 0, the necklace is now around the neck. For the necklace as well it has created a second shapekey, you can delete the basis shapekey if you want.


I am having the same exact issues with completely normal Theora+Vorbis ogv files that had always been accepted by Blender 2.48. Something is broken in Blender 2.49a, both in the release candidate and the definitive version.

I have (temporarily) solved the issue by installing Blender 2.78a, i.e. the most recent previous version to 2.79. In my case it is easy because 2.78a is simply the version you get at present in the Debian Stretch repositories, but depending on your OS you may want to have a look at https://www.blender.org/download/previous-versions/

Remark

Because of comments stating that this should be a comment, not an answer and such, I think I should rephrase my answer as direct answer to your questions, for the ease of readers who might have difficulties with the text I have written so far:

Your direct question number 1:

  is there a addon that needs to be selected?

Direct answer: No, it is a bug in version 2.79a

Your direct question number 2:

  or how to correct this error

Direct answer: Install the most recent previous version, i.e. Blender 2.78a, to be able to import your .wmv files while hopefully retaining most of the functionality you need in Blender 2.79a.


Try looking at your normals in edit mode. Go into edit mode with the object selected, and show the normals (overlays drop-down, shows you the wee blue lines from the centre of each face).
I'm guessing all the faces that won't take your paint stroke are facing the wrong way- inside the mesh.


UDIM tiles not importing properly image texture shader

It turns out it was an issue from the creator's end. I will post more details about what went wrong when I find out, in case this happens to anyone else.


How can I add a panel to the properties area of the file browser?

You would have to add a draw() method along with a pass statement to the operator in order to skip drawing and declare a Panel class, get the actual operator from that class in order to draw it's properties. Demo based on the Operator Export template that comes with Blender:

import bpy

# ExportHelper is a helper class, defines filename and
# invoke() function which calls the file selector.
from bpy_extras.io_utils import ExportHelper
from bpy.props import StringProperty, BoolProperty, EnumProperty
from bpy.types import Operator, Panel

class ExportSomeData(Operator, ExportHelper):
    """This appears in the tooltip of the operator and in the generated docs"""
    bl_idname = "export_test.some_data"  # important since its how bpy.ops.import_test.some_data is constructed
    bl_label = "Export Some Data"

    # ExportHelper mixin class uses this
    filename_ext = ".txt"

    filter_glob: StringProperty(
        default="*.txt",
        options={'HIDDEN'},
        maxlen=255,  # Max internal buffer length, longer would be clamped.
    )

    # List of operator properties, the attributes will be assigned
    # to the class instance from the operator settings before calling.
    use_setting: BoolProperty(
        name="Example Boolean",
        description="Example Tooltip",
        default=True,
    )

    type: EnumProperty(
        name="Example Enum",
        description="Choose between two items",
        items=(
            ('OPT_A', "First Option", "Description one"),
            ('OPT_B', "Second Option", "Description two"),
        ),
        default='OPT_A',
    )

    def execute(self, context):
        return {'FINISHED'}

    def draw(self, context):
        pass

class CUSTOM_PT_export_settings(Panel):
    bl_space_type = 'FILE_BROWSER'
    bl_region_type = 'TOOL_PROPS'
    bl_label = "Settings Panel"
    bl_options = {'DEFAULT_CLOSED'}

    @classmethod
    def poll(cls, context):
        sfile = context.space_data
        operator = sfile.active_operator
        return operator.bl_idname == "EXPORT_TEST_OT_some_data"

    def draw(self, context):
        layout = self.layout
        layout.use_property_split = True
        layout.use_property_decorate = False  # No animation.

        sfile = context.space_data
        operator = sfile.active_operator

        layout.prop(operator, 'type')
        layout.prop(operator, 'use_setting')

# Only needed if you want to add into a dynamic menu
def menu_func_export(self, context):
    self.layout.operator(ExportSomeData.bl_idname, text="Text Export Operator")

def register():
    bpy.utils.register_class(ExportSomeData)
    bpy.utils.register_class(CUSTOM_PT_export_settings)
    bpy.types.TOPBAR_MT_file_export.append(menu_func_export)

def unregister():
    bpy.utils.unregister_class(CUSTOM_PT_export_settings)
    bpy.utils.unregister_class(ExportSomeData)
    bpy.types.TOPBAR_MT_file_export.remove(menu_func_export)

if __name__ == "__main__":
    register()

    # test call
    bpy.ops.export_test.some_data('INVOKE_DEFAULT')

Make sure to add a poll() method to the panel, testing for the actual bl_idname of the operator otherwise the panel will appear for all other export operators as well.
@classmethod
def poll(cls, context):
    sfile = context.space_data
    operator = sfile.active_operator
    return operator.bl_idname == "EXPORT_TEST_OT_some_data"

Note: Once the export operator is registered you can use the python console and call its idname() method getting the proper bl_idname:
>>> bpy.ops.export_test.some_data.idname()
'EXPORT_TEST_OT_some_data'

Just for the sake, adding sub panels is possible as well:

import bpy

# ExportHelper is a helper class, defines filename and
# invoke() function which calls the file selector.
from bpy_extras.io_utils import ExportHelper
from bpy.props import StringProperty, BoolProperty, EnumProperty
from bpy.types import Operator, Panel

class ExportSomeData(Operator, ExportHelper):
    """This appears in the tooltip of the operator and in the generated docs"""
    bl_idname = "export_test.some_data"  # important since its how bpy.ops.import_test.some_data is constructed
    bl_label = "Export Some Data"
    bl_options = {'PRESET', 'UNDO'}

    # ExportHelper mixin class uses this
    filename_ext = ".txt"

    filter_glob: StringProperty(
        default="*.txt",
        options={'HIDDEN'},
        maxlen=255,  # Max internal buffer length, longer would be clamped.
    )

    # List of operator properties, the attributes will be assigned
    # to the class instance from the operator settings before calling.
    use_setting: BoolProperty(
        name="Example Boolean",
        description="Example Tooltip",
        default=True,
    )

    type: EnumProperty(
        name="Example Enum",
        description="Choose between two items",
        items=(
            ('OPT_A', "First Option", "Description one"),
            ('OPT_B', "Second Option", "Description two"),
        ),
        default='OPT_A',
    )

    def execute(self, context):
        return {'FINISHED'}

    def draw(self, context):
        self.layout.label(text="Hello World")
        #self.layout.prop(self, 'type')
        #pass

class EXAMPLE_PT_panel_1(Panel):
    bl_space_type = 'FILE_BROWSER'
    bl_region_type = 'TOOL_PROPS'
    bl_label = "Settings Panel 1"
    #bl_parent_id = "FILE_PT_operator" # Optional

    @classmethod
    def poll(cls, context):
        sfile = context.space_data
        operator = sfile.active_operator
        return operator.bl_idname == "EXPORT_TEST_OT_some_data"

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

        sfile = context.space_data
        operator = sfile.active_operator

        layout.label(text="This is the first Panel")
        layout.prop(operator, 'type')
        layout.prop(operator, 'use_setting')

class EXAMPLE_PT_panel_2(Panel):
    bl_space_type = 'FILE_BROWSER'
    bl_region_type = 'TOOL_PROPS'
    bl_label = "Settings Panel 2"
    bl_parent_id = "EXAMPLE_PT_panel_1"
    bl_options = {'DEFAULT_CLOSED'}

    @classmethod
    def poll(cls, context):
        sfile = context.space_data
        operator = sfile.active_operator
        return operator.bl_idname == "EXPORT_TEST_OT_some_data"

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

        sfile = context.space_data
        operator = sfile.active_operator

        layout.label(text="This is the second Panel")
        layout.prop(operator, 'type')

# Only needed if you want to add into a dynamic menu
def menu_func_export(self, context):
    self.layout.operator(ExportSomeData.bl_idname, text="Text Export Operator")

def register():
    bpy.utils.register_class(ExportSomeData)
    bpy.utils.register_class(EXAMPLE_PT_panel_1)
    bpy.utils.register_class(EXAMPLE_PT_panel_2)
    bpy.types.TOPBAR_MT_file_export.append(menu_func_export)

def unregister():
    bpy.utils.unregister_class(EXAMPLE_PT_panel_2)
    bpy.utils.unregister_class(EXAMPLE_PT_panel_1)
    bpy.utils.unregister_class(ExportSomeData)
    bpy.types.TOPBAR_MT_file_export.remove(menu_func_export)

if __name__ == "__main__":
    register()

    # test call
    bpy.ops.export_test.some_data('INVOKE_DEFAULT')

Related: How do a create a foldout UI panel?

If you'd like to add a checkbox to one of the panel headers, declare a BoolProperty in your operator (alternatively use the scope of the window manager):
class ExportSomeData(Operator, ExportHelper):
    ...
    bake = BoolProperty(default=False)
    ...

And call Layout.prop() in the dedicated draw_header() method of the panel:
def draw_header(self, context):
    sfile = context.space_data
    operator = sfile.active_operator

    self.layout.prop(operator, "bake", text="")

Related: How to add a checkbox to a panel header?


Removing overlapping objects, made with particles

go to emit from tab in particle system settings (you have to have the advanced checked), there you should have selected faces by default (if you didn't change it), then select one in particles/face.
Before:

After:

Faces:

If this doesn't work for you (you have too small faces or something) you can convert the particle system (mdifiers - particle system - convert) and then delete the overlapping bricks.


You're on the right track with your setup. What you want to avoid, is the overshoot you get when turning. This can be controlled with the linear ("Translation") and angular ("Rotation") damping:

Once you increase those values, as in this screenshot, you'll get much closer to the behaviour you're looking for. You probably also need to increase the velocities in your logic bricks, to compensate for the loss in speed due to the damping.


Can Blender render pngs with the background transparent?

Yes this is possible.

To save rendered images with transparent background (PNG format for instance), the settings are as follows for "Cycles" and  "Blender Render" rendering engines.

Cycles

Properties Editor > Render Context > Output Panel

Choose RGBA so that the alpha from the renderer is saved in the png

Properties Editor > Render Context > Film Panel

Check Film>Transparent so that the World background is transparent.

Blender Render

Properties Editor > Render Context > Output Panel

Choose RGBA so that the alpha from the renderer is saved in the png

Properties Editor > Render Context > Shading Panel

Choose Transparent Alpha type.

EEVEE (Blender 2.8)

Properties Editor > Render Context > Film Panel

Choose Transparent Alpha type.


Python variable is not persistent/ changes from unrelated bpy.ops line

obj.rotation_euler is a reference to the rotation object which is affected by bpy.ops.object.transform_apply. In order to store the old rotation in a variable you can use:

rot = obj.rotation_euler.copy()


Boolean Problem with not generating new Difference faces

I had created a simple box with an inset and internal "extrusion" with a bevel. Then I duplicated it and "joined" the two boxes. Then continued to have internal hidden surfaces that were overlapping with curves due to bevels. When I attempted to apply a "difference" boolean operation using Bool Tools, it didn't generate the new faces.

I stepped backward and instead did the following:

I create the initial inset and extruded and beveled boxes, and overlapped them like before.
This time I applied a union boolean operation to the two cubes instead of just joining them, which removed the hidden faces
Finally I created the cutter and used bool tools to difference the cutter on the unionized boxes.

It created the faces, but it also applied the earlier boolean union on the boxes at the same time. I was hoping it would be completely non-destructive, but it wasn't. So maybe the lesson is: duplicate and hide shapes that are unioned non-destructively before adding a cutter using a difference boolean, so you can roll back if needed.


texture painting one object also paints another & vise versa

I'll ignore the symmetry you have active for now, as the UV problem i see should not be affected by it. Still, symmetry while painting on bad UV's can give headaches too, but more to that below.

From the picture, which is all i have to base my answer on, it looks like the UV's of all objects are on the same texture (one material for the entire X-Wing) and while they are unwrapped, not all faces belonging to a surface are together in islands. Some faces seem to be switched around. It's not possible to see in this picture, but i would guess that some of the UV's may be lying on top of each other and thus painting there paints on the underlying UV's, thus the object it belongs to as well.

I would suggest make a backup of the file and then generate new UV's, be it by doing it from the scratch, or by selecting already ok islands and moving them aside first to find the broken up ones and fixing them.

I'd go through the objects and select the surfaces in question, when the UV's show up highlighted, grab them and move them outside the texture frame, if you find UV's that are lying on top of another you found the problem. By re-positioning them so they do not overlap, you can fix the problem. Some UV's as i mentioned seem to be broken up and could be fixed as well. For that just select all the corresponding UV-faces and unwrap them again (you need to know how though, as UV unwrapping is a bit too much to explain here) You could try "Smart UV project", but mainly the overlapping UV's are to be re-positioned, as long as all UV's are packed anew and have some space around them, painting in the 3D-View should work fine. Having the faces of a surface in one island though makes for a cleaner picture and avoids some texturing problems in the long run.

Once all UV's are spread out and none are overlapping anymore, you can select them all and first "UV->Average Islands Scale" and then "UV->Pack Islands". That will bring the sizes of the UV's to an average in relation to the size of the faces on the object and then pack them on the texture frame.

Now you can paint to your hearts content.
Happy blending.


How to add keyframes for multiple objects at once

Assuming you're talking about actual objects (not a mix of objects and armature bones), the easiest thing would be to select all of the objects and, from within the 3D View, press I and choose LocRot. That will insert a key for location and rotation on all selected objects.

If your needs are more nuanced, you may want to consider building a custom keying set. In that, you can specify any number of different properties from any number of objects (and non-objects... like World properties) and key them all at the same time. If you're interested in taking that route, then Getting to Grips with Keying Sets is a good start.


Model appears to have visible polygons rather than being smooth?

If you subdivide an object, it won't automatically appear rounder. It can create angles and ugly surfaces. For example if I have a sphere and decide to W > Subdivide it, as it will create edge loops in the strict middle of existing edges, it will tend to create flat surfaces.

If I W > Subdivide Smooth, though, I won't have this problem as it will try to respect the existing shape.

That said, you don't always get benefit from subdividing an object, except if you need to export for games or other 3D softwares I guess, can't you leave it as it is, keep a simple mesh and don't apply your Subsurf?


try this.. I think u accidentally press some shortcut keys ;)


What are the not so obvious features of Rigify?

Let me start by saying that I think that the finger curl trick might have mislead you a bit. As complicated and advanced a mechanism as Rigify is, it's nothing really 'unique' in terms of rigging in Blender and rigging in general and as Fweeb says above..

...for people who have been using rigs in Blender for a long time, scale controls on the
fingers are a long-standing convention that doesn't feel alien at all.

Apart from the finger curl when scaled, there isn't really anything much left to 'discover' per se, it is just a nice collection of common operations etc. and control interfaces to give animators more control and allow people to skip most of the arduous work when rigging as it can be expanded on if needed.
You might know most if not all of these already.. and I won't attempt to explain Rigify in full detail, that would be very difficult to do and is beyond the scope of this question. — However, as a future reference for beginners…

The top (n) or so things that are not so obvious at first glance about Rigify are:
1. This is not the rig you are looking for…

The very first thing is that Rigify is not really the default armature you get when you add it to a scene. To get the full rig, you go to the Armature: Object Data panel and under Rigify Buttons hit Generate. After that, you can just move the default meta-rig to another layer to keep it out of your way.

2. Now you see me, now you don't

Rigify is a complicated mechanism and often times might get in the way of what you are doing, to hide different parts of the rig as they are needed, you can open the Rig Layers group in the Properties panel and toggle the visibility of each layer of controls as needed.

3. FK or IK?

The rig comes ready to be used in any way you want to animate. It has sliders to change between Forward Kinematics and Inverse Kinematics or give you a blend of both and more depending on how you adjust the slider(s) under Properties and or Rig Main Properties as they are presented or made avilable in the Properties panel.

4. Those aren't really bones..

The custom handles you see aren't really bones per se, they are bones with custom shapes and are actually objects that you can modify and by default they are placed on the last layer (layer 20).

These can also be changed using the Custom Shape input box under Display in the Bones panel but it is worth noting that modifying these can lead to problems with your rig later on so be careful.

5. Bits and pieces

You can encode the meta-rig to python code so that you can generate select parts of the rig as needed. Look in the toolshelf under Rigify Dev Tools and experiment with this.

6. Wait.. who's driving?

This is out of the scope of the question but might be useful if you're planning to build your own rig. Rigify makes extensive use of drivers to automate and make certain operations more 'smooth' etc.

At any time, you can poke around and select a bone and if any of the transform panels turn purple (the default color if you haven't changed it) this means that a driver is acting on it. To dig into this, just open the graph editor and open the Drivers view.

It is also worth noting that since Rigify is glued together by scripts and not manually put together for the most part, a lot of these features will be hard to trace and pull apart etc. but can serve as good reference nonetheless.

Most of these explanations are a bit vague and short, it is a bit more indepth than this but this is enough to get someone new to the rig at least a bit more familiar with it… and so as a last note, I would suggest reading up on Bone Constraints, Drivers and Properties.
Also related.. Armature FK/IK toggles


Scaling cubes with individual origins in python api

Avoid ops for easy operations.

IMO many ops are a bridge between the user and the UI. For simple operations it is often simpler to set property values directly.

After the op cube has context. cube = context.object  .

bpy.ops.mesh.primitive_cube_add()
cube = context.object

To uniformly scale about the origin

cube.scale *= 1.7718

Alternatively can set size in the operator

bpy.ops.mesh.primitive_cube_add(size=2 * 1.7718)

which will "apply" the scale.

Finally: To have the two cubes only touching use 1.5


How do you use the GPU offscreen render API in 2.8?

The following code shows the essential steps to write the 3D view into a Blender image.

The main caveat is that the currently offscreen.draw_view3d() is called within draw() using bpy.types.SpaceView3D.draw_handler_add.
This has a few consequences:

one must ensure that the 3D view is redrawn, for example by clicking onto some object in the 3D view
the function is called multiple times

When moving offscreen.draw_view3d() outside of draw(), I received  the following error message: TypeError: expected 'SpaceView3D' type found 'SpaceTextEditor' instead. So currently, I'm stuck setting the correct context. Any help would be highly appreciated - I'll update the post correspondingly.

import bpy
import bgl
import gpu
from mathutils import Matrix
from gpu.types import GPUOffScreen

def draw():

    print('draw: bpy.context.area.type',  bpy.context.area.type)
    global write_view_3d

    if write_view_3d:

        # Write the image into the offscreen buffer
        offscreen.draw_view3d(
            scene=scene,
            view_layer=bpy.context.view_layer,
            view3d=bpy.context.space_data,
            region=bpy.context.region,
            view_matrix=view_matrix,
            projection_matrix=projection_matrix)

        buffer = bgl.Buffer(bgl.GL_BYTE, width * height * 4)
        bgl.glReadPixels(0, 0, width, height, bgl.GL_RGBA, bgl.GL_UNSIGNED_BYTE, buffer)

        if(image_name not in bpy.data.images):
            bpy.data.images.new(image_name, width, height)
        image = bpy.data.images[image_name]
        image.pixels = [v / 255 for v in buffer]

        print('write_view_3d', write_view_3d)
        write_view_3d = False
    else:
        print('write_view_3d', write_view_3d)

image_name = "Result"
scene = bpy.context.scene
render = bpy.context.scene.render
width = bpy.context.region.width
height = bpy.context.region.height

offscreen = gpu.types.GPUOffScreen(width, height)
view_matrix = scene.camera.matrix_world.inverted()
projection_matrix = scene.camera.calc_matrix_camera(
    bpy.context.evaluated_depsgraph_get(),
    x=width,
    y=height)

write_view_3d = True
current_draw_handler = bpy.types.SpaceView3D.draw_handler_add(
    draw, (), 'WINDOW', 'POST_PIXEL')


you need to select an object that can have modifiers applyed onto it, and then on the right on the properties panel under the wrench tab.


How to properly connect the Denoise node in Compositor?

When in doubt, use the Image pass.
Image

provides unmodified render result
output also comes denoised by the Internal denoiser if it's enabled

Noisy Image

provides a Despeckled image (useful when render has fireflies)
may cause bad shadow artifacts for low sample counts

Further Reading:
Denoise node in Blender Manual
How to use Intel denoiser in Blender
Blenderartists.org discussion from Aug 2019
intel openimage denoise


Deleting islands (lose parts) of mesh with Python

Use the Separate into Loose Parts Operator.

Possibly the quickest and simplest way to do this is to run the bpy.ops.mesh.separate(type='LOOSE') operator to split the single mesh into loose parts.  Then remove all but the object with the most vertices.

import bpy

context = bpy.context
# edit mode
bpy.ops.object.mode_set(mode='EDIT')
# split into loose parts
bpy.ops.mesh.separate(type='LOOSE')
# object mode
bpy.ops.object.mode_set(mode='OBJECT')

parts = context.selected_objects
# sort by number of verts (last has most)
parts.sort(key=lambda o: len(o.data.vertices))
# print
for part in parts:
    print(part.name, len(part.data.vertices))
# pop off the last
parts.pop()
# remove the rest
for o in parts:
    bpy.data.objects.remove(o)

There are a number of methods for doing this without the operator in answers to  How to find the number of loose parts with Python? including my answer which returns a list of verts for each island in selection which would be ideal for making an interactive tool to do this per selection, to clean "splatter-cake" verts.


This appears to be a form of z-fighting - where two faces exactly coincide. Presumably the bottom face of the Smoke Domain rests exactly on the plane. This causes Blender to have trouble in determining exactly which surface has been hit by a ray and, despite the edge of the Smoke Domain being 100% transparent, this can result in the shadow.

In order to demonstrate this effect, here's the default cube, moved 1 blender-unit up so that it's bottom face rests on the Z=0 plane with a plane added also at Z=0. The Cube has been assigned a 100% transparent shader.

And here is the render - note the square shadow of the face of the cube that should not be present :

The solution is to slightly move the Cube or the Plane so as to separate those faces - only a very slight movement is required - moving the cube only 0.00001BU up was sufficient to avoid the issue.


How do I check for floating vertices non connected edges?

Try this. It removes disconnected vertices and edges.


Problem with fluid simulation, cannot get fluid to move up a thin pipe

There are several options which make fluid simulator fail while finding correct paths for fluid in this case.

Most objects in this scene have scale / rotation unapplied, so just select them all and use options from Ctrl+A menu. In case of fluid simulation, Fluid Sim modifier will not know that the scale of the object was changed if it wasn't applied to the object data. This may lead to unexpected results (same for rotation).
For more info on why is it important to apply them, see Why is it important to apply transformation to an objects data?.
There is internal face inside of your pipe mesh (assumed to water the big vessel with fluid). The face will effectively prevent fluid from going through the mesh, so delete it.

There are also several double vertices in the mesh, remove them with W > Remove Doubles.
The pipe, assumed to water the top vessel, consists of several objects; the main pipe has holes where they should connect. This will prevent fluid from coming all the way up to the top vessel because of that hole just in the middle of the main pipe:

Smaller part of the pipe was hidden

To achieve expected results of animation, join these meshes and make them manifold in the place of joint:

Topology is horrible, however at least they are joined and closed. This can be easily done by closing the gap in the main pipe, and using Boolean Union option to join objects effectively.

The joint between this joined small pipe and big vessel can be left as is - it will only depend on the resolution of the fluid.
The final result will really depend on the bake resolution. If quite low values are used (as 80 or 100), then make sure to scale the pipe a bit up, because otherwise baked fluid will be too fat to flow into it and will just splash in the bottom vessel. You can scale the pipe along normals for that.
Fluid baked on higher values should deal with that (although I don't know how much those values should be as I didn't tested it).


How do I use Proxies in the VSE correctly?

This is a great question and actually has a simple answer. Both steps are equally necessary and have their respective purpose:

a) Sequencer: Generating Proxies

The first step is to generate proxies at one or more resolutions. In the sequencer, select the sequence in question, scroll down in the properties pane to the right to the Proxy / Timecode section.

Tick the box in front of the title Proxy / Timecode to enable the sequencer to use any available proxy that may exist for this clip. This doesn't do anything other than telling the sequencer "hey, if there's a proxy on disk at the resolution requested and enabled below, please use it!". At this stage no proxy resolution has been enabled, only the conceptual usage of a proxy if it was enabled on this clip (and the corresponding proxy sequence found on disk).
Ignore the next two boxes (Proxy Custom Directory and Proxy Custom File), they're there to override the default location of proxies, which is, relative to the location of the original sequence on disk, always set to BL_proxy/images/<res>, where res is the resolution of the specific proxy. Blender offers to render at 25%, 50%, 75% and 100% respectively.
The next four check-boxes enable the concrete version(s) of proxies to render as well as to use, if available. Select the resolution you wish to generate.[*]
Rendering the proxy: In the Video Sequence Editor select Strip -> Rebuild Proxy and Timecode Indices while you still have your sequence/clip selected. To the right in the menu bar of the VSE you should now see a progress indicator showing the state of the proxy generation. If you now look into the folder where you have your original sequence (or movie clip) you should see a folder called BL_proxy appear (see above).

This done, the proxy/all proxies have been generated and are activated for the sequence in its preferences. Note that you can untick the proxy check-boxes in the sequence's properties pane to disable the usage (or (re-)generation) of them temporarily - this will not delete the proxy sequence on disk.

b) Preview Window: Enabling & Choosing the Proxy to Use

With our clip now being equipped with one or more generated proxies we can ask our preview window to use a specific one and it will do so if a proxy for the given resolution exists and is activated for the clip. Note that this setting is preview-window-specific, meaning we can have more than one preview-window with them using different proxies.

To ask a preview window to use a specific proxy, go to the the Properties pane on the right hand side of it and under Proxy render size select the proxy resolution you would like to use from the clip (or any in the timeline as you scrub through). This will tell the preview window to not use the original resolution (clip/image sequence on disk) but the chosen proxy resolution that we generated for the clip.

The order in which you perform the two steps is irrelevant. However, both are necessary to have (a) and use (b) a proxy for a given sequence.

I hope this helps and clarifies how proxies work in Blender!

NB: This is valid for Blender 2.69 - some details might be different or missing in later or earlier versions. Feel free to comment and I'll update.

[*] As of Blender 2.69 there is a minor bug (for me). If I select more than one proxy here and generate them in the next step, the proxies are all rendered at the smallest of all selected resolutions. I.e. if 75 and 25 are selected and then rendered, the 75 proxy will have the physical resolution of 75% of the original image's dimensions but will be pixelated as if the 25% proxy was just upscaled to 75%.

The solution to this is to simply generate the proxies one by one. I.e. selecting only one resolution in the properties of the sequence pane in the sequence editor and then generating it helping Blender in not getting confused when having multiple resolutions selected simultaneously. Important to note here is that, once all desired proxies are generated, they all have to be enabled/ticked again to tell VSE to actually use them.


Why Blender doesn't let me select all aligned vertex edges at all?

Where you have a vertex selected inside the red square, the highlighted edges are the ones connected to the selected vertex. The other edges don't appear selected as there is a second vertex that appears to be in the same position as the one you have selected. If you move the selected vertex you will find it moves away from the other one.

The easiest solution is to select all vertices and Remove Doubles. If that doesn't merge anything you can press F6 and increase the merge distance. Don't go too high or you can merge the entire mesh.

Another option is to select the nearby vertices and manually merge them together with AltM

When you get vertices close together you may find it easier to switch to wireframe display to select the vertices.


How can noodles (the lines that connect nodes) be changed from straight to curved lines?

The option can be found in User Preferences > Themes under Node Editor:
Higher values will increase the curviness of noodles. Setting it to 0 will make them straight line.

For 2.7#

For 2.8#


Nodes in the node editor are different than on tutorial

Just to remove this question from unanswered list.

To have the same settings as in provided tutorial change rander engine from Blender Render to Cycles.


This is a round about way to do it, and will not perfectly randomize the textures, but I used this technique to randomize a drawn animation of grass for a project last year.


There's a bad rigging of the nose, i.e. bones influencing the nose while they are not supposed to.

So what you need to do is select the whole mesh in Edit mode and remove the nose vertices from all groups, then assign them to the good vertex group which is "spine.006" (name of the head bone).

Now when you rotate the head you can see that the nose goes far away, but this time it's because the head is flattened, this is because the head is also bad rigged. So do the same things, and it will work.


The knife tool is an interactive process that relies on the location of the mouse cursor and button clicks to perform it's task. This interactivity would make it hard to control from a python script.

To automatically edit a mesh through python you want to look at the bmesh module which is the underlying foundation to all mesh editing operations.

The issue with incorrect context indicates that the operator only works while the 3dview is active.


Selecting and removing particular objects

This should do the trick, first iterate through everything in your scene, next check if it is as mesh and check if it is a cube (by name using the first 4 chars), then remove it. Also, make sure you are in object mode when running the script.

import bpy

scene = bpy.context.scene

for ob in scene.objects:
    if ob.type == 'MESH' and ob.name.startswith("Cube"):
        ob.select = True
    else:
        ob.select = False

bpy.ops.object.delete()

Unlinking an object from a scene does not remove it entirely.

Condensed version of the same script thanks to CoDEmanX.

import bpy
for ob in bpy.context.scene.objects:
    ob.select = ob.type == 'MESH' and ob.name.startswith("Cube")
bpy.ops.object.delete()


How to read a csv file and use the values as x and y points in blender?

You can use the csv library to read and parse CSVs.
If you have a basic bus object on a different layer (or a sphere called bus), this script will duplicate it and then assign the longitude and latitude values from your CSV as the new object's x and y values, for each row in your CSV.

import bpy, csv

fp = "C:/csvs/buses.csv"

with open( fp ) as csvfile:
    rdr = csv.reader( csvfile )
    for i, row in enumerate( rdr ):
        if i == 0: continue # Skip column titles
        lon, lat = row[3:5]

        # Generate UV sphere at x = lon and y = lat (and z = 0 )
        bpy.ops.mesh.primitive_uv_sphere_add( location = ( float(lon), float(lat), 0 ) )

I used this CSV to test this code:

mode,country/city,ID,lon,lat
bus,CN/Beijing,bus81254,65.98592786,51.75899959
bus,CN/Beijing,bus73859,92.83295925,87.98592343
bus,CN/Beijing,bus52924,88.43513405,88.79596166
bus,CN/Beijing,bus52141,92.68713387,15.49215037
bus,CN/Beijing,bus8170,36.0964094,42.77106261
bus,CN/Beijing,bus46545,84.46655319,43.23791824
bus,CN/Beijing,bus60033,66.14547792,61.71886078
bus,CN/Beijing,bus63664,35.46744528,4.412149752
bus,CN/Beijing,bus62759,89.04704861,93.61280167
bus,CN/Beijing,bus72522,25.00040058,9.672330218
bus,CN/Beijing,bus55786,96.79310251,73.2168682
bus,CN/Beijing,bus55381,44.75153181,23.6187773
bus,CN/Beijing,bus21913,39.26107112,98.37814343
bus,CN/Beijing,bus2981,35.8751682,23.26682901
bus,CN/Beijing,bus52068,56.09661959,97.26439994
bus,CN/Beijing,bus59329,54.47486082,87.98768438
bus,CN/Beijing,bus40450,6.994144595,29.2284396
bus,CN/Beijing,bus51603,95.90526567,26.46823662


Two ways to solve this

1  scale down the space_backdrop sphere so it fits inside the camera clipping bounds

2
Set the viewing mode to shaded (press Z again), and you can clearly see it's not a shadow but a feature of the clipping plane. Modify the Clipping End parameter (In Properties > Camera Settings) to be large enough to fit the whole scene.

it's difficult to see in wireframe mode:

to visualize the clipping plane, you enable 'limits' in the Display panel of the camera. View the scene from the side and zoom out to see how the limits indicator behaves as you adjust the End value


Selecting one side of your mesh

Use inset I to get a border of quads

Repeat for surrounding sides

Select the boundary of the side and add a bevel.

With the faces of one side selected you can use Select Boundary Loop (in the select menu) to get the outer edge loop to bevel.


Making a slanted pane that is more than a simple square with translation

Here's my alternate approach you may try, that uses proportional editing (linear) and some scaling.

Select the very end vertices of the plane, enable the proportional editing (set its mode to Linear) and translate upwards.

With the transform orientation set to Normal select all the faces of the plane and press S and then Z twice (to transform along the normal Z coordinate).

BTW @Duarte Farrajota Ramos 's method involving curves works as well. Just add a curve and set its angle to fit your needs. Then give the plane a Curve Modifier with a curve as a target.


Make sure proportional editing is disabled, then enable Keep UV and edit mode mesh selection in sync and enable Face Selection mode.

Then you can select the faces and rearrange them as you want.


How to replace object with keeping it dimmensions / how to change dimension of an object to scale value

My best try is 3 steps.
Replacing a cube with Suzanne, keeping exact dimensions.

Link Object Data (Ctrl + L > Object Data)
Copy dimensions of the Cube to one Suzanne (it gets slightly distorted)
Select all other monkeys, and copy object scale to them (RMB > Copy all to selected)

Linking Object Data, nothing new here.

Copy exact dimensions from Cube to Suzanne. And then copy the scale to the rest.


How to programmatically register an addon

To answer the specific question, I think you're looking for this: https://www.blender.org/api/blender_python_api_2_57_release/bpy.ops.wm.html#bpy.ops.wm.addon_enable

For example:

import bpy
bpy.ops.wm.addon_install(filepath='/home/my-addons/awesome.py')
bpy.ops.wm.addon_enable(module='awesome')

Regarding the part of your posting where you say "when I ship my entire Blender folder to another developer" .. I suggest you make your solution turn-key and provide an install script that points blender to your .py file and registers needed addons. Maybe something along the lines of:

#!/usr/bin/env bash
blender --background --python /path/to/addon-installer.py
echo "Done"


Select FFmpeg video and a panel named Encoding will appear. It may appear at the bottom, so it's possible you'll have to drag it to reorder. To do that, just grab the 8 dots at the far right of the panel caption, and drag it to where you want it.


Use the mist pass. You can enable it by going to the Layer Properties and under "Passes", enable "Mist". Then, in the camera settings, under "Viewport Display", enable "Mist" so you can see where the mist begins and where it ends (the location where an object will be completely invisible, shrouded by mist). This can be adjusted in the World settings.
Now head to the compositor workspace and you will see a "Mist" output. Plug that into a coloramp. There you can adjust values, and clamp the pass as you want. It will make sense once you mix it with the output using a MixRGB set to "Add".
Here is a very quick youtube video I found detailing the parts: https://www.youtube.com/watch?v=uXXYUv-793c


Why does an object with a glossy shader render in black?

What you are missing is proper lighting and an environment to be reflected on the object.
Since this question gets asked a lot I'll try to address some common misunderstandings on dealing with glossy objects in general, this shoudl be helpful not only black shiny objects, but metallic or glass ones
A glossy surface is like a mirror.
When you stand in front of a mirror what do you see?
Yourself and whatever is behind you...
Do you see the surface of the mirror?
Hardly, unless is dirty, fogged or scratched.
If you shine a flashlight into the mirror what happens? Does the mirror get brighter? Or is the light reflected back at you? What should you pay attention to, lighting the mirror or lighting the objects that are being reflected in the mirror?...
Problem #1
Glossy objects render black, glossy material is not working "as expected":

A perfectly glossy object, with no roughness, will reflect all the light perfectly "as expected" If the scene has no environment or other objects, glossy surfaces will reflect... nothing: hence the blackness...
Problem #2
The glossy object is dark or I just see small bright dots
If my glossy objects are dark I can just add lights or make the light in the scene brighter and then my objects will not be dark.
Yes and No.
Adding more lights or making them brighter will not work as well, the tiny spots where the lights are reflected on the object will get brighter but the shape of the object will not be revealed.
Light rays hitting on a glossy surface or mirror like surfaces get reflected from the surface in an equal amount and a the symmetrical angle to the one of incoming light. – in comparison with diffuse reflection – in which the light gets scattered all along the surface of the object in different amounts on other directions, depending on roughness.
As an example:

Image by GianniG46
Light on a diffuse shader gets scattered all over the surface in many directions and reveals the complete shape of the object. All surfaces will reflect some light one way or another.

Light on a glossy shader bounces straight back or out of view, and will only visible in a very small part of the surface of the object: in this example is only a tiny little white spot.

So what that means in plain English is that that the lights, no matter how bright or how many they are in the scene, will only be visible at a certain angle. If they happen to be at the angle in which the light rays get reflected straight into the camera lens they will be visible as bright spots, but they are not really "lighting" the object.
Here's an example with a ridiculous amount of lamps, the more lamps the harder it is to understand the shiny objects.

Problem #3
If I just set the environment to be something else other than black things look odd and flat
Let's set the environment to be gray for example.

Yes! We're finally getting seeing the objects and reflections!... But wait.. it look very strange and flat indeed and I don't want a cartoon look...
Since the environment is irradiating light evenly in every direction it can be be hard to tell the object apart from the background. All surfaces are getting equal amounts of light she shapes are not clear.
In the image above there is some color on the glossy shader... but for other objects with no color, this kind of homogeneous lighting, the object could appear totally camouflaged: where the reflections are all essentially the same color and as bright as the background. To understand shapes we need a variety of values that will help our brain know if the object is straight of curved or if it has any depth.

OK I get it, but how do I see my glossy object properly?
To reveal the surface of a glossy object you need to reflect something on it.
In this case, a few large planes (or area lights) with an emission shader strategically placed at an angle to maximize reflections, will make our object finally look like something!

Start by placing a single very large plane with an emitter in the scene and see how is being reflected on the surface. Move it around the scene, and notice how the placement helps you reveal or not the shape and qualities of your object. Add additional emitters or just planes with a white surface. Find the correct placement for them. Having gaps in between the emitters/reflectors will help you reveal the contours and subtle shapes of the object.
But don't limit yourself to planes or lights, be creative. The challenge is finding something interesting to reflect on the surface of your objects!

Depending on what you are after, using an HDR image as the environment and light source might give you more natural reflections.

Look online for links on "how to photograph reflective objects",  The same techniques apply for 3D rendering.
You will realize that they all do the same: they are not just photographing an object, but mostly focusing on what is being reflected on the surface of the object.
This link might help: http://project52pros.com/2014pros/assignment-thirty-five-photographing-a-very-shiny-object/


How to make assemblies from multiple objects?

Let's start with the hole object and the shaft object (shown below). I've taken the opportunity to rotate the hole from the global XYZ axes just in case that's what you're dealing with.

The first thing you want to do is to add an empty axis along the desired rotational axis of the shaft. If the shaft is symmetrical and aligned with the global axes, select the shaft, use Shift+S > Cursor to Selected to move the 3D Cursor to the shaft origin, and add Shift+A > Empty > Plain Axis. You'll then want to parent the shaft to the Plain Axis.

That step is to allow you to rotate the shaft about its local X, Y or Z-axis. Long story short, if you try to spin an object around an axis that's not the global axis, things get messy. In the case of your shaft not being aligned to any of the XYZ axes, you'll have to first rotate the shaft so that the rotational axis does align with one of them, then press Ctrl+A > Apply Rotation. Then you can add the empty as I showed above.

Next, go to the hole. Select all the vertices/edges that make up the hole, press F to fill it in, then press Ctrl+F > Poke Faces. What this step will do is create a face with a normal that matches the desired rotational axis, and adds a vertex in the middle of it that we can use to snap the Plain Axis to.

Next, enable Vertex Snapping making sure you enable Align Rotation to Target. Grab the Plain Axis, and snap it to the vertex we made in the hole earlier.

Now you can delete the vertex from the hole, and rotate the shaft by rotating the shaft object, leave the Plain Axis alone.

EDIT: from additional info

If you don't need to rotate the shaft, you don't need to use the Plain Axis. Fill in the hole face, and poke it as I showed above. Then, if you grab the shaft using Vertex Snapping, Snap with Active Element and Align Rotation to Target, you can move it onto the hole and it will automatically align itself for you. Then you can delete the extra vertex from poking the face.

From there, if you need the shaft to be further in/out of the whole, use G+Z+Z to slide it in/out.


Is it possible to make the image appear in the order of object number

I thought at first about achieving this using Drivers but it's too difficult to clone the driver to each object visibility without resorting to scripting - so I figured why not just use scripting anyway.
I'll vary by height as it's simpler - but you could tweak the code to change the order of visibility to use some other property (could assign a property to each object or use the position in the list of objects (which will relate to the order of creation).
Start by creating a new Scene custom property named 'Height' and set it to be able to vary over a suitable range - this should be keyframed to reveal the objects.

Next, open a Text Editor window and paste the following code in a new text block named 'hideshow.py' :
#Hide objects above some threshold
import bpy

def frame_change_hideshow_objects(scene):
    height = bpy.context.scene["Height"]
    for obj in bpy.data.objects:
        if obj.location[2] > height:
            if obj.hide_viewport != True:
                obj.hide_viewport = True
                obj.hide_render = True
        else:
            if obj.hide_viewport != False:
                obj.hide_viewport = False
                obj.hide_render = False

bpy.app.handlers.frame_change_pre.append(frame_change_hideshow_objects)

Click the 'Run' button (a 'play' button in the header) to execute the code and it will install a “handler” to run on each frame change. Each time it runs it compares the value of the scene property ‘Height’ with the Z coordinate of each object in turn, flipping the visibility based on the height if it has changed.
Now keyframe the new 'Height' scene property to vary over your range. Play the animation and your objects will show/hide based on whether they are above or below the 'Height' :

In order to use the image id instead of Height, rename the scene property to something appropriate (eg, 'RevealID') and amend the code to compare that with the point in the list of each object (ie, the number of times around the loop) :
#Hide objects above some threshold
import bpy

def frame_change_hideshow_objects(scene):
    revealId = bpy.context.scene["RevealID"]
    objcount = 0
    for obj in bpy.data.objects:
        objcount+=1
        if objcount > revealId:
            if obj.hide_viewport != True:
                obj.hide_viewport = True
                obj.hide_render = True
        else:
            if obj.hide_viewport != False:
                obj.hide_viewport = False
                obj.hide_render = False

bpy.app.handlers.frame_change_pre.append(frame_change_hideshow_objects)

In my example this produced the following result. Note that the objects were created using 'Grid fill' particles so they are created in an uncontrolled sequence (this is why basing on height was simpler!!) :

For better results you would need to take more care in the creation order of the objects than I did - or re-sequence the objects in some way. Alternatively, use a method of revealing the objects that isn't based on the creation order such as by height as described above, by amending the code.


The steps you made should hide the emitter from the final render but I'm guessing you mean whilst you're working in the viewport.
In the Properties panel, with the emitter selected uncheck both viewport and render (as needed) under Instancing > Faces:
Properties Panel > Object Properties > Instancing > Faces > (show instancer) viewport + render


Couldn't get the right coffee color and the thickness of glass cup

I've given a try for the glass material, it's not completely accurate but in my opinion it creates the illusion. I haven't changed the coffee material itself.


So let say you have your shape.

In Edit mode, select an edge and bevel it.

Back to Object mode, create one shapekey (Basis) then a second one.

Keep the second shapekey selected. Back to Edit mode, select the corner and scale it down with SShiftX so that it doesn't scale on the X axis.

Enable the Snap tool, Vertex mode. Move the bevel on the Z axis (GZ), use the snap to align to the right level. Then move the bevel on the Y axis (GZ), use the snap to align to the right level.

Now back to Object mode, when you select the second shapekey and play with the Value, the bevel shrinks to its new radius.


Object Rotation with polar angles python

To avoid any misunderstanding let me reiterate with this illustration.

Click to enlarge.

$\theta$ will control the orientation on the red axis.
$\phi$ will control the orientation on the blue axis.
If $\theta$ is a multiple of $\pi$, $\phi$ won't change the final orientation.

We can construct a quaternion from the $\theta$ and $\phi$ rotation and chain them. The mathutils.Quaternion class provides a rotate(other) function for this purpose.

import bpy
import math
import mathutils

θ = math.pi / 3
ϕ = math.pi / 2

q = mathutils.Quaternion((0, -1, 0), θ)
qϕ = mathutils.Quaternion((0, 0, 1), ϕ)

q.rotate(qϕ)

bpy.context.object.rotation_mode = 'QUATERNION'
bpy.context.object.rotation_quaternion = q

While this works, it doesn't really produce polar coordinates. Certain polar coordinates should be the same, and they currently aren't.

Calculation the spherical position

You can directly calculate the x, y and z values.

$x = \sin{\theta} \cos{\phi}$
$y = \sin{\theta} \sin{\phi}$
$z = \cos{\theta}$

Then you can generate a quaternion pointing to that position with the to_track_quat function.

position = mathutils.Vector((math.sin(θ) * math.cos(ϕ),
                             math.sin(θ) * math.sin(ϕ),
                             math.cos(θ)                ))

q = position.to_track_quat('-Z', 'X')

This will give you good control over which axis is oriented where.