Is there a way to get linear HSV sliders in colorpicker?

Short answer: No. Not via the GUI widget that is. RGB should be linearized.

Longer answer: If more imagers around Blender begin to understand what an EOTF is, perhaps. The ideal solution is that all UI elements allow an imager to pick the transfer function as required by their current context. Editing normals within a given range? Use a particular linear transform. Manipulating a particular log? Use it. Etc.

Why is the widget nonlinear? Because it has to be corrected for your display output. That is, if the widget were not under a transform, and your reference were different from 709 lights, you would not see the right colour in the wheel.

There is an exhaustive thread located here for anyone interested in the nuances of this.

Until Blender chooses to permit an imager to select the colour transform required on a UI element, this is an impossible situation to solve for all imaging contexts.

Also, as stated many other places, not using a display transform and forcing a power curve is far from ideal and should be avoided at all costs. A better path is to have your voice heard and have Blender fix the broken colour pipe UI paradigm.


Yes, this is possible.

3D view physics:

Animate the Speed value in Properties > Scene > Rigid body world:

You can add keyframes for this value by right clicking and selecting Insert Keyframe, or by pressing I while hovering over the field. See this question for more detail.

Game engine physics:

Change the FPS value in Properties > World > Physics:


How can i copy NLA Tracks from one armature to another?

Here is Python for deep copy. Just replace the names of the source and target armatures. Hope it helps - Sri

import bpy

sourceObj = bpy.data.objects['SOURCE_ARMATURE']
targetObj = bpy.data.objects['TARGET_ARMATURE']

if targetObj.animation_data is not None:
    targetObj.animation_data_clear()

targetObj.animation_data_create()

source_animation_data = sourceObj.animation_data
target_animation_data = targetObj.animation_data

if source_animation_data:
    for source_nla_track in source_animation_data.nla_tracks:
        target_nla_track = target_animation_data.nla_tracks.new()
        target_nla_track.name = source_nla_track.name
        for source_action_strip in source_nla_track.strips:
            target_nla_track.strips.new(source_action_strip.action.name, source_action_strip.frame_start, source_action_strip.action)


I found the solution. I needed to uncheck Compositing under the post-processing tab. This gave me the result I was looking for.

That's solved the headache I've spent the last four days trying to solve...


How do I add a new tab to the 3D Viewport?

Mr batFINGER always has the good stuff, but this should get you started:
import bpy
from bpy.types import Panel

class TestPanel(Panel):
    bl_space_type = "VIEW_3D"
    bl_region_type = "UI"
    bl_label = "Test Panel"
    bl_category = "Test Panel"

    def draw(self, context):
        pass

class TestPanelSub(TestPanel, Panel):
    bl_parent_id = "TestPanel"
    bl_label = "Test Panel Sub Panel"

    def draw(self, context):

        layout = self.layout

bpy.utils.register_class(TestPanel)
bpy.utils.register_class(TestPanelSub)


How do I make animations a steady speed?

Simply go to the Animation Screen Layout:

Now select Channel > Extrapolation Mode > Linear Extrapolation (shortcut Shift + E):

And that should fix it for you.

If you look at the Graph Editor before doing this, you will see:

The beginning and end of the curve are levelled out, this is what gives you the slowing down effect. It is called a Bezier function. When you choose 'Linear Extrapolation' it makes the curve a straight line:

The straight line is extended in both directions giving you continued animation, whereby if you choose Interpolation, Key > Interpolation Mode > Linear (shortcut T):

What starts off as curves...

...results in straight lines between keyframes with no extension beyond:


The solution of your problem is to Fill the empty space , in edit mode select all vertices and do F to fill your space , please try to ignore filling Obtuse angles shapes coz they can cause many topology problem


When working with 3D models, we often work the opposite way to reality, that is we would animate the aerofoil rotating and have the attached parts move to follow its movement. For what you are after you may not need any more than rotating the aerofoil, the interconnecting pieces of a cars rear spoiler may not even be visible.

There are a collection of constraints available that can simplify automated interactions of multiple components.

A piston is composed of two parts, one fitting inside the other and both pieces pointing toward the fixture point of the other. The TrackTo constraint is the easiest way to keep the two piston pieces in place as both ends are moved. You can find a simple example in this answer.

It is possible to build more complex rigs, in this answer a front-end loader rig is setup to move one bone that rotates the scoop as well as the attached parts that would control the movement on a real tractor.


Passing variables in IntProperty constructors ignores changes in the variable when creating more instances using CollectionProperty.add()?

While more of a workaround than a solution, for now I fell back to using ID Properties.

I append a function to bpy.app.handlers.depsgraph_update_post, in which I grab all the properties I'm interested in and compare them to a previously saved copy of them that's stored in a list ID property. If they match, I do nothing, if they differ, I save the current properties to the list and run my update().

This is probably not very optimized, so I won't be accepting this as an answer, in case someone posts a better way.


Higher texture resolution no improvement

Higher resolution texture would theoretically improve surface quality for closeups, in the sense that texture might look less blurry.

"Might", because if you are far enough from the mesh surface the difference will probably not be very noticeable and at lower resolutions it becomes harder to see.
JPEG compression might also wash away some of the detail.

Besides you seem to be using a mix of 1k and 3k images in your node setup, which would further dilute any subtle effect it might have.

My guess is, for your use case and current rendering resolution 1k texture would probably be enough.


how to create UIList with auto-aligned three columns?

By default when you place multiple items on the same row blender will give each item an equal portion of the row eg. three items get 33% of the row each. Due to the fluid nature of blender's layout, we can't specify an exact size of each column, they will get resized as the user resizes the layout.

You can use UILayout.split() to alter the percentage of a row that an item uses. To expand on my earlier answer to include an example of splitting three columns you can get the following result.

Note that the split works on the allocated space, the first split turns a row into two columns, the first column gets the percentage size of 60%, the remaining items then use the remaining 40%. I have then used split again so that the second column gets 30% of the available space - that is 30% of the remaining width after the first split not the entire row.

def draw(self, context):
    measure_size = 0.6
    unit_size = 0.3
    box = self.layout.box()
    col = box.column()

    row = col.split(percentage=measure_size)
    row.label(text='9.3000168000e+03')
    row = row.split(percentage=unit_size)
    row.label(text='in')
    row.label(text='Cube')

    row = col.split(percentage=measure_size)
    row.label(text='7.176e+00')
    row = row.split(percentage=unit_size)
    row.label(text='yd')
    row.label(text='Cube')


Set the Rotation (in Quaternion WXZY) of a bone using API 2.49

Bones have two rotations.  One is the rest orientation, and the other is the pose orientation.

The pose orientation is manipulated something like

obj.pose.bones[0].rotation_mode = 'QUATERNION'
obj.pose.bones[0].rotation_quaternion = q

But the rest orientation requires you to be in edit mode, and you have two choices.  You can manipulate the head, the tail, and the roll (requires extra math).  Or you can set the head and tail to a base state and use functions to transform the bone (and let those functions do the math for you).  Here's an excerpt from http://web.purplefrog.com/~thoth/blender/python-cookbook/bone-orientation-demo.html

translate = Vector([0,0,1])
bpy.ops.object.mode_set(mode='EDIT')
bone = obj.data.edit_bones[0]
bone.head = [0,0,0]
bone.tail = [0,1,0] # Using the Y axis is pretty important, otherwise we can't use the inverse of Q to pose the cube to an unrotated state
bone.transform(q.to_matrix())
bone.translate(translate)

I learned about EditBone.transform from  How to rotate an EditBone? is it possible .

I'll just jump to the conclusion that you want to alter the pose.  The other weird problem with your code is that it looks like you are setting the orientation of each bone several times (handIndices) and replacing a keyframe each time.  Since you are having difficulty updating your code to use the techniques in my examples, here is a rewritten version of your code with a couple of alternative implementations to choose from:

scn = Scene.GetCurrent()
arm_ob = scn.objects.active
bones = arm_ob.pose.bones

if False:
   #more like the original code
   for bone in bones:
      # use bone here
      for handIdx in handIndices:
         # why are we setting the rotation several times for the same bone?
         pos = dataStore['Bone'][handIdx-1][frameIdx]
         bone.rotation_quaternion = pos
         bone.insertIpoKey(Object.IpoKeyTypes.LOCROTSIZE)
else:
   # maybe handIndices is a list of bone indices?
   for handIdx in handIndices:
      pos = dataStore['Bone'][handIdx-1][frameIdx]
      bone = bones[handIdx-1]
      bone.rotation_quaternion = pos
      bone.insertIpoKey(Object.IpoKeyTypes.LOCROTSIZE)

Scene.GetCurrent().update()


Cycles render layers - make overlapping parts transparent

If your two layers are House and Grass:

House will look like this:

This says that all the objects in the scene are on layers 1 and 2, the house is on layer 1, and it should be covered up by layer 2 (the grass).
Grass will look like this:

This says that all the objects in the scene are on layers 1 and 2, and the grass is on layer 2.


working with 1m faces mesh. how to uv map/unwrap?

ok. after the comment of m.ardito i tried uv mapping with easier stuff. after i knew the basics i did my landscape again (using heightmap) with fewer faces. then i could unwrap it and assign my texture to it. after that i didsubdivide smooth a few times to get to an hihger detail grade.

no need to answer anymore.

sadly i cant accept my own answer right now. gotta wait 2 days.


Rendered image is not as smooth as in 3d preview

Well, Cegaton already found the problem, but the question needs an answer for future users.

The Subdivision surface modifier has two important parameters: the view and the render subdivisions. As their name suggests, view determines how smoothed out the surface will be when viewing it in the viewport, and render does the same for rendered images.

This is useful if you want a smoother object when rendering, but want a better performance of the viewport and don't need much detail when previewing – you can set a lower view and a higher render.

If you set the render parameter lower than the view parameter, objects will appear smoother in the viewport than in actual renders.

Another possible cause of this problem is that the modifier is visible  but isn't being rendered . In that case, click the camera icon to enable rendering of the modifier (in the image above, both rendering and viewing are enabled).


Export an individual object for every frame of animation

You can export individual frame as individual obj files.
Goto>>File>>Export>>Wavefront (.obj)
Select a folder and then check animation checkmark on the left.then click Export OBJ


Get an angle of your object "front on" by using one of the orthographoc angles (Numpad 1 for front, Numpad 3 for side, Numpad 7 for top, or Numpad 9 to flip any angle by 180deg), and then press U (unwrap), and select "Project from view" This will make your UV map resemble a "snapshot" from that angle.

After that, connect your image texture as normal. It comes out looking like this:

If you want to stop the image from appearing on the top and sides of the stairs. you can use the respective axes from the Normal Vector as a mix factor between your image and whatever other material (I used plain white for the example). The Normal vector doesn't like being recombined without a third axes, so you have to do it in 2 stages - one for each respective axis that you need "erased":


What is the best way to copy/append geometry from one bmesh to another

Your bmesh is just a python representation of the mesh thats in your scene. As long as you don't write your bmesh back into the mesh-datablock (bm.to_mesh(me)), you can use it for anything you want to do with it.

This means you can create a new mesh datablock and then use

bm.to_mesh(new_mesh)

since it's just a python object, you can copy it with a python copy method:

bm2 = bm.copy()

Which will give you a fully editable bmesh that is disconnected from your first bmesh. So you don't have to copy every vert & edge manually.

edit: this is how you seperate the mesh into two halfs that were split. You can then write it back into the edit mesh and separate the loose parts which will give you two objects. Because with your current code you get vertices and edges that define where your mesh is being cut, and not the actual geometry. -> your result:

My code example:

import bpy
import bmesh

bm_tmp = bmesh.new()
bmesh.ops.create_monkey(bm_tmp)

geom = bm_tmp.verts[:] + bm_tmp.edges[:] + bm_tmp.faces[:]
r = bmesh.ops.bisect_plane(bm_tmp, geom=geom,
    plane_co=(0, 0, 0), plane_no=(0, 0, 1))

bmesh.ops.split_edges(bm_tmp, edges=[e for e in r['geom_cut'] if isinstance(e, bmesh.types.BMEdge)])

bm_tmp.to_mesh(bpy.context.selected_objects[0].data)
bpy.ops.mesh.separate(type='LOOSE')

Visual result from this code:

Edit 2:
in that case, that you want to slice it multiple times -
instead of writing it to a new bmesh after each bisect, do this:

bmesh.ops.split_edges(bm_tmp, edges=[e for e in r['geom_cut'] if isinstance(e, bmesh.types.BMEdge)])

to apply the bisection to your bmesh and actually separating it by parts.
In the end you can write it to a actual mesh. Only then i would combine it with your other bmesh. You can't simply add two bmesh together.
so i'd suggest combining them like this, because it is the simplest way:

bm = bmesh.new()

bm.from_mesh( m1 ) # Add mesh 1 to bmesh
bm.from_mesh( m2 ) # Add mesh 2 to bmesh


Pose your weapon according to the view , than run the script to take a picture using openGl render , got o the UV editor and the image will have the name of the active object :

import bpy

# path to the folder
file_path = bpy.data.filepath
file_name = bpy.path.display_name_from_filepath(file_path)
file_ext = '.blend'
file_dir = file_path.replace(file_name+file_ext, '')

mainScreen = bpy.context.screen

#current scene
scene = mainScreen.scene
#set render settings
scene.render.resolution_x = 128
scene.render.resolution_y = 128
scene.render.resolution_percentage = 100

#render from view (set view_context = False for the camera render)
bpy.ops.render.opengl(view_context = True)

#save and load the render (you can't keep the render result)
img_name = bpy.context.object.name+".png"
bpy.data.images['Render Result'].save_render(file_dir+img_name)
bpy.ops.image.open(filepath = file_dir+img_name)
bpy.data.images[img_name].pack()

you can change the render size in the script

For screenshots while playing the BGE has a function for that :
bge.render.makeScreenshot(filename)    see the DOC


Node for setting render colour, regardless of lighting

I assume you mean a "shadeless" shader:

To create this you can use the Light Path node to make an emission shader which is visible only to the camera, letting other rays straight through with a transparent shader:

Casting shadows:
With a diffuse shader (or a holdout shader, black transparent shader, etc. anything that will cast a shadow and render fast) used instead of the white transparent shader:

You'll notice that there is some indirect lighting (in this case it's a slight orange tint to the shadow, because I made the diffuse shader orange)

If you don't want that orange tint, you can either:

Disable it per object by disabling Diffuse in Properties > Object > Ray visibility:

Disable it per material with the light path node:

Result:


How to make the shapekey influence separate object's position?

You could use vertex parenting to have the objects follow parts of your mesh. This has similarities to the hook modifier.

Select the teeth, shift select the head, go into edit mode, select the target vertex (only one or three vertices can be selected, three vertices allows rotation when following) press CtrlP to parent the other selected object to the selected vertex.

Be careful as I expect you will deform the face for animation and the parenting will keep working. You could add an extra unattached vertex that moves with the neck shapekey but isn't used in facial animation, or maybe you could choose three vertices located one in each ear and one at the top of the head that won't get deformed in animation. You may also need the armature to follow so that any animation will happen relative to the new location, or parent a facial armature which will take the teeth and eyes with it.


Is there a Blender icon reference for the Outliner editor?

Use the Icon Viewer add-on and outliner_draw.c file.

Enable the Icon Viewer add-on.
In Icon Viewer, click on the icon you're trying to lookup.
In an Info editor, note the name of the icon. This may be descriptive enough on it's own, but if not, proceed to the next step. In this example, it is GHOST_ENABLED.
Go to outliner_draw.c and look for the same text, GHOST_ENABLED in this example. You should find the type of object the icon represents in the case statement right above the icon name. In this example, you can see it is a proxy.

Using the same process for the broken paper icon shows it is LIBRARY_DATA_BROKEN.


The reason for jagged shadows lies in the technique used for rendering the shadows.
I assume you used the blender internal render engine and the standard shadow of the lamp; for spots lamps the default is the buffered shadow.

Here is a rough explanation how buffer shadows are calculated

With buffer shadows something like a render is made from the view of the light source lamp. Every surface point not visible on this lamp-rendered image isn't reachable by this light source. Thus, these pixels of the lamp-rendered image projected to the unreachable surfaces will be a good approximation of the shadow in the final render. According to this the blockyness depends on the resolution of this lamp-rendered image. It can be adjusted at the lamp settings:

Here is more info on how the buffering works.

So increasing the size is the solution?

No. A better way is to change the shadow rendering technique. The other one available in blender internal is Ray Shadow which probably is the best solution.

I hope your shadow pass is blockless with this method now :)


How to switch rendering engine via python script

You can set the engine before rendering like this:

bpy.context.scene.render.engine = 'BLENDER_WORKBENCH'

Its possible multiple scenes are involved in the render so you may want to do...

for scene in bpy.data.scenes:
    scene.render.engine = 'BLENDER_WORKBENCH'

Note: If you select the Scripting screen, then change the engine, the code to do this is printed at the top of the screen (called the Info view), eg:

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


API properties.

Set the active bone with arm.edit_bones.active = bone.  However propose there is no need to use the parenting operator, can rather set the properties, parent, use_connect

Python console code with armature arm in edit mode.

>>> arm
bpy.data.armatures['Armature']

>>> bone = arm.edit_bones["Bone"]
>>> bone2 = arm.edit_bones["Bone.001"]
>>> # active edit bone
>>> C.active_bone.name
'Bone.001'
# set active edit bone
>>> arm.edit_bones.active = bone
>>> C.active_bone.name
'Bone'
>>> bone2.parent = bone
>>> bone2.parent.name
'Bone'
# check if connected.. nope
>>> bone2.use_connect
False
# connect
>>> # connect the bone
>>> bone2.use_connect = True
>>>


Mirror modifier is not working, no mirrored object?

The mirror modifier mirrors the object around the object origin (the yellow dot in the center of the cube).

Since the origin is in the center of the cube, the mirrored half is the same as the existing geometry of the cube, and no change is apparent.

If you move the cube in Edit mode (which won't move the origin), you'll notice the cube is mirrored as you might expect:

Note that in addition to moving the object origin (CtrlAltShiftC) where you want to mirror, you can specify a Mirror Object:

This will use the origin of the specified object (usually an empty) instead.


Animation node get particle system points around a radius

Welcome to Blender StackExchange! The Find Close Points node can be used here:

The max distance option defines the proximity of points as you want. This example is actually included in the documentation:


How to recreate the lighting of a reference illustration, with low sun and pink shades on the mountains

I was able to recreate it with two lights, a (lightly emitting) backdrop, and a very dark, but slightly violet tinted, world.

Breakdown

The lights are Area lamps with a fairly big size (for soft shadows), illuminating from the two sides, slightly towards the horizon. One is bright pink/orange (750W), the other is a slightly less bright (500W) blue/violet.

An alternative, if you'd like to have more realistic shadows, is a three-light setup, with one sharper, brighter pink light coming from the direction of the sun: see pic below ↓

The world, as you can see, is dark violet (because the ground in the foreground is in a violet shade).
The backdrop is just an image with low relative emission (1.0). Actually I used a mesh plane and circle with a gradient texture.
The ground is just a default principled material with no specularity.

I also used a high focal length (100mm) camera.

Results

(these are based on the two-light setup)

Eevee

Cycles

Note: I picked the backdrop color with the color picker from your reference image, but they appear duller in my render because I used the default Filmic Color Management settings. Depending on the kind of color you want to give to your scene, you might opt for a different color management scheme.

The file

This was created with an alpha version of Blender (2.82), so it may have compatibility issues.


An object disappears when I start the game engine. How do I fix this?

The object might be located somewhere else. So it is not visible to the camera.

Check the existence and the location with this code:

import bge

name = "Cube"

object = bge.logic.getCurrentScene().objects[name]
print("Object", object.name, "is at", object.worldPosition)


Think about the design of such a system.

Requirements

key pressed once -> start timer AND wait for second key press
key pressed a second time AND wait for second key press -> do operation AND stop timer
timer exceeds -> stop timer

(I guess this is what you want to achieve. If you want something else let me know).

Design

This can be easily achieved via logic bricks. There is no point where you need Python.

Lets break down the requirements.

Sensing a key press

is simple: keyboard sensor

Running a timer

there are several options such as

delay sensor
timer property with property sensor
property with property actuator and property sensor

The timer property gives the time in seconds while the other options use number of frames.

Wait for second key press

There are several options too.

as long as the timer is running, you are waiting ... otherwise not. This could be sensed with a property change sensor
remember the wait state (either use build in state system or use a property to remember the state)

Do operation

This is up to you

Timer exceeds

either the delay sensor pops up or you measure this with a property sensor (greater than mode).

Example

I choose a delay sensor and the build-in state machine.

State "idle" (waiting for first key press)

State "waiting" (waiting for second key press)

Be aware when you have other "breaking" events beside timeout you need to add them too (e.g. pressing another key might break the combo).

Remarks

Yes, you can implement the same architecture with Python. There are no additional benefits.


Why is the Default Screen layout not showing all objects?

From the screenshots you posted, you can see that in the top-left corner it says "User Ortho (Local)", which means you are in Local View mode. Just press NumPad / to toggle it.


This is a great Youtube tutorial on using the 'bake sound to f-curves' to drive animation, starting with very basic movements based on the sound graph to being able to control different parts of animation based on different stems of audio. It uses Blender v2.79 but I recently followed along using v2.82 and it is still very comprehendible.


Why isn't my render matching up with renderview mode on blender 2.8?

If it works by deleting a grass layer, then I suppose the issue comes from the particle's settings. Make sure this option in the particle's render panel is enabled:


How do I rotate a face around an axis in normal orientation in Python?

After some reading I managed a solution, but I'm not sure how robust it is:
tangent = face.calc_tangent_edge_pair()
rot_axis = -face.normal.cross(tangent)

The tangent is one of the other normal axes and from that the last axis is calculated as its cross product with the face's normal.
This seems dependent on which edges are the longest (the documentation for BMFace.calc_tangent_edge_pair says: "Return face tangent based on the two longest disconnected edges."), so I imagine there's a better way to approach this!


Map array modified objects to underlaying surface

Create a simple array of a place object with the same settings as the array you already have.

Shrinkwrap that plane to the underlying bumpy mesh instead, then use Duplifaces or a particle system (if the former has too limited controls for what you want to achieve) to distribute the objects along the array.

Parent the duplicated object to the plane mesh with Ctrl + P, then activate Duplifaces under the Properties Window > Object > Duplication > Faces


Nothing happens when baking fluid simulation

Apply the scale to domain and inflow object. ⎈ CtrlA

Why is there an inverted sphere in the inflow? Remove it, it is going to give us some wrong direction otherwise.

And finally, your domain is very large compared to the preview resolution of 45. The inflow is so small that the emitted fluid is not visible.

Voxels (volume elements) are the smallest unit in the volumetric fluid simulation. Since the emitted fluid is smaller than a voxel, no geometry is created.

To solve this:

Scale up the inflow.
Scale down the domain.
Apply scale.
Increase the resolution.
Immediately switch to final resolution under viewport display. This is going to show us the final resoluted geometry.

Here are some more efficient scale at a final resolution of 200. Note how to domain will barely contain all of the fluid.


Render just part of a final image from Cycles?

Ctrl + B in the 3D Viewport or the Camera View will allow you to drag while holding  LMB select the area of the image you want to render. If you want to clear the border, press Ctrl + Alt + B.

Shift + B also still works in Camera View but is only there for compatibility and will be replaced entirely by Ctrl + B in future versions.

For "Render->Render Image" (F12 ) to render only part of the image you also need to have Render->Dimensions->Border enabled.


I believe that's not an error, it's doing what you're exactly asking it to do.
Joining meshes using Ctrl + J do not affect their geometry, it just puts them as one object, think of it as a way of grouping meshes, any doubles or holes will remain the same, so what you actually did is overlapping your meshes, what you need to do is to close the holes, remove doubles, in other words make the mesh manifold. Trying to understand better what a manifold mesh is, think about it as a model of an open bottle, with a single surface, the hole at the top makes it non manifold, since the "exposed" inside of the bottle,  has no dedicated faces, faces normals are pointing outside, while adding a Solidify modifier, or closing the hole, makes it manifold (in case there are no doubles) because all "exposed" faces now have normals pointing outside the volume of the mesh itself.


How to make a bone NOT inherit location from parent? Or how to position bone at world location?

This can be done with bone constraints

Add an Empty to the Scene at the base of your child bone.
Disconnect the child bone from its parent (AltP) in Armature Edit Mode.
In Pose Mode select the child bone, go to the Bone Constraints context , and add a Copy Location Constraint targeted at the Empty.

Here is an example of the result:

Above: An armature object being moved while one of its bones remains stationary


By selecting the vertices and pressing F you are simply creating a new edge. The faces connected to the vertices are not changed, this behaviour correct.

In this position, delete the problematic face.Select all the vertices and/or edges, which need to be fill and press
F to fill them with new faces.

Alternatively, before creating the edge which intersects the face, press K to cut the face with the Knife Tool. The knife tool can snap to the vertices along the faces' edge.


For this you may want to subdivide the object, then make it a softbody. When animated, the softbody will collide with itself (with the right settings), and it won't look as weird. Make sure you check the Self collision box so that it does collide with itself.


You don't need to convert a vector to an array, you can just assign it to the location. A vector is created from one value which is a set of three (or four) numbers, so you need the extra pair of parenthesis around the three values.

Any location, rotation and scale value can all take a vector or array as input values. All of the following work.

obj = bpy.data.objects['Cube']
obj.location = Vector((-0.9056, -0.0628, -3.000))
obj.location = [-0.9056, -0.0628, -3.000]
obj.location = (-0.9056, -0.0628, -3.000)
obj.rotation_euler = Vector((-0.9056, -0.0628, -3.000))

For bezier curves the same applies to it's curve points

# for bezier curve points
bezcurve = bpy.data.objects['BezierCurve']
SplinePoint = bezcurve.data.splines[0].bezier_points[0]
myLocation = Vector((-0.9056, -0.0628, -3.000))

SplinePoint.co = myLocation
SplinePoint.co = Vector((-0.9056, -0.0628, -3.000))
SplinePoint.co = [-0.9056, -0.0628, -3.000]
SplinePoint.co = (-0.9056, -0.0628, -3.000)

For nurbs paths each point is four values instead of three. The first three values are the x,y,z for the location as above while the fourth value (shown as w in the UI) controls the influence the point has on the curve, where a bezier point has handles that define the angle and strength of the curve leaving the point, a nurbs path only has an influence that pulls the path closer to the point the larger the value.

# for nurbs paths points
nurbpath = bpy.data.objects['NurbsPath']
SplinePoint = nurbpath.data.splines[0].points[0]
myLocation = Vector((-0.9056, -0.0628, -3.000, 1.0))

SplinePoint.co = myLocation
SplinePoint.co = Vector((-0.9056, -0.0628, -3.000, 1.0))
SplinePoint.co = [-0.9056, -0.0628, -3.000, 1.0]
SplinePoint.co = (-0.9056, -0.0628, -3.000, 1.0)

If you are getting a location as a vector from somewhere else you can use resize_4d() or the to_4d() to use the location in the nurbs point. You can then alter the influence with either SplinePoint.co[3] = 1.0 or SplinePoint.co.w = 1.0.


Just start your animation frame 100.

And keep the domain start frame at 0.


Disabling Indirect Light in the Cycles Render

Setting diffuse bounces to 0 is the correct way to achieve what you want. Setting glossy and transmission bounces to 0 as well is unnecessary, it just produces black metal and glass, and the like.

The reason the resulting render doesn't look like the Cornell Box example is because the lighting is different. There are multiple light sources, some of them very large in area. (the windows, in particular) This create diffuse soft shadows and light from many different directions. There are very few places in the scene that do not directly face at least 1 light, so disabling indirect lighting still gives fairly smooth and realistic-ish lighting. In the box example, there is only one light, so any area occluded from it is in solid shadow.


Selecting your face and using Shift+(NUMPAD 1,3, or 7) should allow you to get all the angles you want. Also hitting Numpad 9 will flip you 180 to the other side of the face.


Create paint pour with fluids, needs to fill with a round mesh

Set the viscosity high (either set the Base and Exponent manually in Fluid World properties or by using the Fluid World 'Viscosity Preset' for Honey (which should be somewhere close to paint)) and then use a Fluid Control object to keep the pool of liquid in the desired shape.

See How to melt an object then reverse the melt into another object for an example of using Control objects to direct the fluid into a specific shape, using a thin cylinder to shape the pool.


Bone heat weighting failed to find solution!

Follow this instruction

Have your mesh/armature as two objects (not parented and with no vertex groups on mesh)
Select mesh (object mode). Separate > Loose Parts.
Shift-select Armature (do shift-LMB in Outliner if you keep selecting mesh by accident).
Parent > Automatic Weights. This gives your meshes vertex groups.
Outliner - click "white arrow" of Armature to Restrict Viewport Selection.
(Important!) Select any obect that isn't Armature (so its name in Outliner is no longer highlighted white).
Select all. Join.
Outliner - Unrestrict viewport selection of Armature.

Tell me if it works ;)

Or try with this link

http://blenderartists.org/forum/showthread.php?130935-Bone-heat-weighting-failed-to-find-solution-for-one-or-more-bones


Blender unit conversion without scaling relative to the scene?

I had exact the same problem - solution is - select whole scene, literaly everything and parent to empty, than scale empty :)


When you save as .blend, you're saving the project, not the rendered image.
When you finish a render an image editor window pops up, showing the rendered image; in this window go to the image menu and choose save as, then you will choose if PNG, jpg, EXR, ...
Shortcut is Alt S.


Why does the "screen" node turn hotspots pink and blue?

Let's look at the formulas for the screen and add blend modes. Add is really simple, it just adds the values:

f(a,b) = a + b

Where "a" "b" are our inputs. Easy, just combines things and makes them brighter. Now let's look at screen:

f(a,b) = 1 - (1 - a) * (1 - b)

More complicated. We subtract both values from 1, multiply them, and subtract the rest from 1. You might be asking "what's the significance of 1 in all this". That's where the problem comes from, there isn't any. Screen is inherently a "display referred" blend mode, meaning it was meant for use on values that describe the relative intensity of a screen pixel. Screen values cannot be over 100% intensity (because 100% is as bright as the pixel can go) so display referred values are bound at 100%, which for simplicity reasons is calculated using the value of "1".

When you have a display referred value (or any other value that's always in a 0-1 range) you can invert it by subtracting from 1. So screen inverts both layers, multiplies them, then inverts again. It's designed to prevent clipping when you try and make a brighter combo of two already bright values. Let's try with a bright but display-safe value of 0.9 for both layers:

f(0.9, 0.9) = 1 - (1 - 0.9) * (1 - 0.9)

f(0.9, 0.9) = 1 - 0.1 * 0.1

f(0.9, 0.9) = 1 - 0.001

f(0.9, 0.9) = 0.999

Hooray, it doesn't clip! Whereas add does:

f(0.9, 0.9) = 0.9 + 0.9

f(0.9, 0.9) = 1.8

Our pixels don't go to 180% power, so we have to clamp it all to 1.0. Gross.

Here's the problem though: renders are scene referred, not display referred. The pixel values do not represent relative intensities of a monitor pixel, they represent the absolute amount of light that struck a virtual "sensor". Thus, it's completely ok for them to exceed 1.0. 1.0 isn't any particularly meaningful value at all, it just the number that gets mapped to 100% by default when converting to display values for final output.

So given that we can have values > 1 and that 1.0 is not special in any way, we cannot safely invert values using it. And if we try, weird shit begins to happen. Let's run that again with layer 1 having a value of 1.5

f(1.5, 0.9) = 1 - (1 - 1.5) * (1 - 0.9)

f(1.5, 0.9) = 1 - -0.5 * 0.1

f(1.5, 0.9) = 1 - -0.05

f(1.5, 0.9) = 1.05

Ok, a little weird. But it's still larger than layer b, right? Let's go again, but with much bigger values:

f(5, 2) = 1 - (1 - 5) * (1 - 2)

f(5, 2) = 1 - -4 * -1

f(5, 2) = 1 - 4

f(5, 2) = -3

WTF? -3 is not brighter than 5 or 2. In fact, it's lower than our black point. So screen gets very unreliable once values go above the otherwise arbitrary point of 1.0. Input too big of a number, and the result goes DOWN, not up. If there's a big difference in brightness between color channels, this can result in wild color shifts. Imagine if your red channel is the 5 and 2 example, and your blue channel is the 0.9 and 0.9 example. Where do you think your hue is going to end up when (5, 1.0, 0.9) becomes (-3, 1.0, 0.999)? Somewhere very different from where you started, that's where.

As you found, the add blend mode still works because it doesn't try to invert by an arbitrary max:

f(5, 2) = 5 + 2

f(5, 2) = 7

f(1.5, 0.9) = 1.5 + 0.9

f(1.5, 0.9) = 2.4

So the takeaway is whenever using scene-referred/HDR values, stay clear of screen or any other modes that try and use 1.0 as a max (like overlay, useful as it is with 0-1 values).


How to display progress notifications from an Operator?

This is a hack, at best. So, when an image in blender is rendered, it provides a convenient status bar at the top of the window.  The problem is a script has to be a renderEngine to take advantage of this.  The solution? Make your script a custom renderEngine, then have your button invoke the render function.

Here's a very basic example of updating the status bar, and adding a status string to the render window. You would put the code you want run in the myCode function.

import bpy
import time

class CustomRenderEngine(bpy.types.RenderEngine):
    # These three members are used by blender to set up the
    # RenderEngine; define its internal name, visible name and capabilities.
    bl_idname = 'custom_renderer2'
    bl_label = 'Progress Bar Example2'
    bl_use_preview = True
    # This is an example function, put your code here
    def myCode(engine):
        engine.update_stats("Starting","")        #update the stats in render window
        time.sleep(1)
        engine.update_stats("Running","halfway")
        engine.update_progress(0.5)               #update the progress bar
        time.sleep(1)

    # This is the method called by blender
    def render(self, scene):
        self.myCode()

# Register the RenderEngine
bpy.utils.register_class(CustomRenderEngine)

Then select your new renderEngine. From the top of the blender window click "Blender Render" and select "Progress Bar Example."  Now you can run your script by pressing F12.  One other method that might be useful is test_break, which checks to see if the render(or script, in this case) has been cancelled.
One last thing to note, directly executing a script (eg. with altP) doesn't display the progress bar, however when the render function (byp.render.render) is bound to a panel it displays correctly.

See these for more information:
Blender artists, setting progress bar values
Blender Python Api, RenderEngine


How do you make objects appear in a blender scene at specific times?

While you can animate the visibility of an object, I think you are more interested in adjusting the timing of the animation. Using the dopesheet you can select the keyframes of your animation and move them along to start at frame 245.

Similar tot he 3dview you can use A to select all keyframes and G to move them. After grabbing the keyframes you can also type in the number of frames you want to move them.

You may also be able to render two separate animations and join them together in the VSE


Distortion Coefficients and Camera intrinsic of blender's cameras?

In the direct process of rendering a scene, a Blender camera itself has no distortion coefficients. Distortion is inserted a posteriori as a compositing node, see How to tweak K1, K2 and K3 undistortion values in motion tracking?.

In the inverse process of calibrating cameras from a given video clip, Blender's motion tracking interface estimates distortion parameters K1, K2 and K3, to be used in rendering through compositing in the aforementioned way. To access these distortion coefficients, you have to be in the Movie Clip Editor, load a clip, and press n to toggle on/off region containing the Lens panel:

Notice the option to select the desired type of distortion model ("Polynomial" in this case).

You can access these parameters in Python:

bpy.data.movieclips["movieclip-file-name-here.mp4"].tracking.camera.k1
bpy.data.movieclips["movieclip-file-name-here.mp4"].tracking.camera.k2
bpy.data.movieclips["movieclip-file-name-here.mp4"].tracking.camera.k3

In case you want to render with custom lens distortion parameters, not obtained from Blender's motion tracking, see Custom nonlinear distortion lens


Why is my material index not working on the other eye?

My best thought is make sure you have the blue part of the eye as a separate material index. Then use that as a factor for black and the original image. This will separate the eyes from the mesh.

Afterwards, you can use a glare node on the eyes. If you where to following this work flow make sure the threshold low.


Increase Transparency in Animation for all Materials

You can do this fairly easily by using some simple drivers.  Drivers are a way of controlling one property based on the value of another property or properties.  If you have never used them before drivers can seem a bit daunting, but simple driver setups like this are actually pretty easy to set up.

First, add an empty to your scene.  This will serve as a "fader" to adjust the opacity of your materials.  This way you can just animate the movement of the empty, and in turn it will control all the transparency.  (It is not necessary, but somewhat convenient to add a couple Limit Location constraints to the empty to only allow it to move in a straight line like a real fader.)

Next, right click on the opacity setting for your material and select Add Driver.  This will make the field turn pink, indicating that it is now being controlled by a driver.

Now jump over to the Graph Editor and select Drivers under the Mode selector.

Now find the driver on the hirearchical list on the left and select it.  (I am using the Cycles render engine, so yours may be a little different than mine if you are using Blender Render.  Basically it will just be at the bottom of the hirearchy.)

Now look at the panel on the right side (if it's not there just hit N) and scroll down to the Drivers rollout.  Near the top here is a field called expr, this is the expression that determines the actual value of the driven property.  Just type "var" here, as that is the default name of the default variable and it will work fine for us (in more complex situations when you are dealing with multiple variables it is usually good practice to name them something more useful).  Now go down to the variable named "var" and select the empty you added for the Ob/Bone field and select Y Location for the type.

Now as you move the empty up in the y-direction the opacity of all your materials should change accordingly!


Enter edit mode, select the edges all around your mesh:
Use AltRclick to select an edge loop, or CtrlRclick to select a path between your previous selection and the new one.

Once you have selected all that, simply extrude down:
E for extrude, press Z to constrain it to the Z axis, then validate with Lclick.

Then make this extrusion flat by scaling it on Z to zero:
S for scale, then Z, then Numpad 0 and validate.

Not you just have to make a face from that edge loop, with F.

EDIT :

It looks like your mesh is deformed by a modifier, I would guess a displace modifier. I guess it's how you obtained the shape of the top. The issue is that the modifier affects your whole object, even the parts you want to keep flat.

So we need to restrain the area of action of this modifier.
A simple way to do that is to use a vertex group.

For the sake of demonstration, I recreated your setup (at least what I guessed out of your pictures):

As you can see on the right, I show both the modifier settings and the "vertex group" panel which can be found in the Object Data tab (the triangle icon).

First, let's create the vertex group we need:

Enter edit mode
In vertex selection, select only the top part of the mesh we want to deform
Hit CtrlG to assign the vertices to a new group, hit the confirmation button spawned under your cursor.
You can see the created group in the vertex group panel, I rename it "Deform Mask" for the sake of clarity.
In the modifier's settings, select the Deform Mask group in the vertex group input.

Now it deforms only the top vertices, but we need to do one more thing. You will notice that the top vertices are still being moved on X and Y axes, making the vertical faces deformed instead of flat.
This is because of the direction of the deformation. By default, this modifier deforms in all directions according to the faces's normals. We want in this case to move vertices only up and down, so let's change the direction to Z.

And here we go:


How to create a circular shaped grid, similar to a manhole cover

A duplivert approach.

The aim here is to have a regular quad only geometry.

Here is the result with a bevel and a subsurface modifiers :

To begin :

Make a sixth of hexagon
Make a segment of length 1
Rotate the extremity 60°
Make a face
Rotate all back 30°

Subdivide it the amount of time you want, in order to create the driving vertices (there will be one circle per vertex)
Keep only the vertices

Complete this shape to be close to a circle, duplicating some vertices
Place the cursor at a pivot point and set it as pivot
Select and duplicate the wanted vertices
Mirror these copies along X : Ctrl+M then X

Add a circle with 12 vertices (that will be a good amount for the further tesselation, but you could choose more : see below)
Parent it to our sixth of hexagon
Set it duplivert
Adjust the size of the circles

We will now make the tesselation

First step, make the duplicates real (this detaches the dupli from the sixth of the hexagon)
Make them single user (as they are still a dupli of their original circle)
Join all (note that joining without making dupli single user will work too)
Remove the double (as the selection included the original circle)

Tesselation, second step, enter edit mode
Work on the sixth of one of the circle to link it to its neighbors, so that we obtain the 1/6 of the perimeter
Our goal is to make 'quad only' tesselation, using a 'minimum' of vertices

To do that :

Connect the neighbors, make a face, cut it
Once done for the three in this corner, scale the in between vertices to 0 and remove doubles

Now we have a 6th of what we want, spin it 6 time for 360°
Select the result and separate it

Back to the duplivert, parent this newly created hexagon to the initial 6th of hexagon composed of vertices
We obtain a regular tesselation

Again make duplicate real, join the objects, enter edit mode
Spin all 360 in six steps
Remove doubles
Adjust the normals

The last step : creating the outer circle
We have here 156 vertices in the peripheral
So we add 156 vertices circle around
Then bridge edge loops between
In order to smooth a bit the border, you can also add another outer circle

We are done (long to explain... but shorter to do !).

For information, my first though was to use particles as there is a hexagonal grid option for it. But it seems that there is no way to adjust it so that all the particles stay regularly into the circle. And as you can see, there is an angle between the particles alignment and the hexagon.


It's okay to be composed of a zillion different parts.  Really.

There are a couple of options for dealing with all those parts.  The best is to create an armature for the whole quad, and then parent all those parts to it.  Or you could create an empty and parent all those parts to it.  Or, you could just join all the parts into a single mesh, that works too.  In case you're wondering, just select one object, shift select another, and ctrl-j.

Now, can you merge them into a single mesh?  Yes.  Even though you shouldn't.  You can do this via a boolean modifier on union mode.

Will this screw up how your models look?  Yes, probably.  It will likely require that you retopo the mesh.  That's one of the reasons you shouldn't.

Now, how should you handle this in Unity?  You shouldn't use mesh colliders.  Especially not concave mesh colliders.  Seriously.  They are easy, but they have problems.  You should use primitives-- capsules, spheres, cubes-- that represent your mesh instead.  It is far better to use one hundred primitives than it is to use a single mesh collider.


How to correctly use the Collada exporter?

Try applying scale, rotation and location(Ctrl + A) on the rig and then the mesh, while in Object Mode.

You'll have to redo the animation


We lack some informations about your current file, but the basic way to do it is this one:

Unwrap your planks (Smart UV Project mode is good for this kind of object) and put your wood image texture on it with the following node organization:

In your picture software (Photoshop, Krita or even Blender), create your text with an alpha transparency.

Create a second UV Map and unwrap (Project From View mode) the front plank faces, those where the text is supposed to appear. You need this second UV Map because the first you've created won't fit.

Now you need to mix your wood Image Texture with your text Image Texture. Create a second Image Texture and load the text picture.  Into the Vector input, plug an Input > UVmap node, and choose the second UVmap you've created so that the text will be displayed according it. Use a Color > MixRGB node to mix the 2 Image Textures. In the Factor, plug the Alpha output of the text Image Texture so that it lets all the transparent area display the wood.

Of course it would need a bit more work, like creating a bump map and plugging it into your nodes Normal inputs to give your object a bit of 3D bumps...


File browser does not show up when operator is executed from a shortcut menu

By looking at the add menu defined in space_sequencer.py it sets layout.operator_context = 'INVOKE_REGION_WIN', this doesn't appear to carry into your menu item.

By setting the operator_context within your menu item method, the sample you provide would appear to work as you expect.

def menu_func_import(self, context):
    self.layout.operator_context = 'INVOKE_REGION_WIN'
    self.layout.operator(ImportSomeData.bl_idname, text="Text Import Operator")


Why aren't these faces extruded as the tutorial video?

You have a lot of overlapping vertices which seem to be effecting the scaling operation.

To remove these:

In Edit mode select All of the model.
Open the Vertex menu.
Select the Merge Vertices.
Select the By Distance option.

At the bottom of the screen you will see how many vertices have been removed.

Now re select the 8 faces, and they will scale as shown in the video.


Button with Multiple Operations/Functionality

You have to create custom Operator class and register it.
Inside the operator you have to check if the object has the modifier or not. If it is not then add or else remove it.
Then replace the YourOperator.bl_idname  with "object.modifier_add".

Added shade smooth and flat toggle.
For shortcut you can click on the button and "add shortcut".
Note: Your Operator.bl_idname have to give blender some idea of what group the shortcut should be added to. Otherwise the "add shortcut" button won't appear.

import bpy

class SubsurfOperator(bpy.types.Operator):
    bl_idname = "object.toggle_subsurf"
    bl_label = "Toggle Subsurf"
    bl_options = {'REGISTER', 'UNDO'}

    def execute(self, context):
        mods = bpy.context.object.modifiers
        mod_type = 'SUBSURF'
        mod_name = None
        for mod in mods:
            if mod.type == mod_type:
                mod_name = mod.name
                break
        if mod_name != None:
            bpy.ops.object.modifier_remove(modifier=mod_name)
            bpy.ops.object.shade_flat()
        else:
            bpy.ops.object.modifier_add(type=mod_type)
            bpy.ops.object.shade_smooth()

        return {'FINISHED'}

class CustomPanel(bpy.types.Panel):
    """A Custom Panel in the Properties Toolbar"""
    bl_label = "V3"
    bl_space_type = 'VIEW_3D'
    bl_region_type = 'TOOLS'

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

        obj = context.object

        row = layout.row()

        # here is your operator

        row.operator(SubsurfOperator.bl_idname, text= SubsurfOperator.bl_label, icon = "MOD_SUBSURF")

        row.prop(bpy.context.space_data.overlay, 'show_cursor', text = "3D cursor", toggle = True)
        row = layout.row()
        row.operator("object.modifier_add", text= "Subsurf", icon = "MOD_SUBSURF").type="SUBSURF"

# requires to register classes
from bpy.utils import register_class, unregister_class

# Class list to register
_classes = [
    SubsurfOperator,
    CustomPanel
]

def register():
    for cls in _classes:
        register_class(cls)

def unregister():
    for cls in _classes:
        unregister_class(cls)

if __name__ == "__main__":
    register()


How to wrap an object around a cloth and "squeeze" the cloth, like a napkin ring or rag on a jar

For starters, I'd say model the thing manually if its not necessary to use the cloth sim.
Cloth sim is for interactivity, i.e. if you want the cloth to interact with something later in an animation.

However, if you want to use the cloth sim, try using Cloth Sewing (new since 2.70), here is a general tutorial: https://www.youtube.com/watch?v=ySyQsLD_7GM

In your case, i would use a similar approach as in the video with the cloak, wrap the cloth mesh around the jar lid, connect all open vertices with edges and mark them as seams to pull together.

I would model the string holding it together entirely manually.


Array modifier fit curve option( curve direction problem(already Ctrl+A applied, but failed to fix)

It works better when you use the Curve modifier.

1) Go to Edit mode and rotate your mesh 90 degrees so it aligns better with the curve.
2) Set array modifier to Count or Length
3) Add a Curve Modifier and set the target to your curve.

Rotate your mesh in edit mode.

Set Array modifier to Count and add a Curve modifier

Voilà!

And here is the edited file.


You need to take care of the timing.

Within a single frame (over the complete scene):

sensors evaluation
controllers execution
actuators running
physics, render etc.

The code always runs with "controllers execution". This does not mean that all operations have immediate effect.

Activating an actuator, does not make the actuator running at the moment of the call. The actuator gets a signal to activate. The actuator will run within "actuators running". Which is later than your code.

KX_SCA_AddObjectActuator.objectLastCreated provides you a reference to the last created object by that actuator. That can be last frame or any frame before.

Within the first execution of your Python controller the actuator never added a new object. This means you get None. I expect you get an error each time you trigger the controller the first time as None has no "worldPosition" (always have the console window open when you run Python code with the BGE).

There are several ways to solve the timing issue.

A) Two step processing. You store the position and adjust the position of the new object within the next frame. The drawback is, that you can see the unchanged position for a single frame. This can be annoying.

B) Do not activate the actuator, but let it add the object via instantAddObject(). AFTER that call objectLastCreated will return the just created object.

You code could look like that  (supposed to run in script mode):

import bge

controller = bge.logic.getCurrentController()

mouseSensor = controller.sensors["Ray"]
activationSensor = controller.sensors["Clik"]

if activationSensor.positive and
   mouseSensor.positive:
    addActuator = controller.actuators["add"]
    addActuator.instantAddObject()
    addedObject = addActuator.objectLastCreated
    addedObject.worldPosition = mouseSensor.hitPosition


Can't orbit the center of the object after painting a single stroke

That is what blender thinks it  is doing :)

in object mode it orbits around selected object (as object of your interest)
in edit mode it orbits around selected vertex
in paint, weight, vertex, sculpt it orbits arround place of painting (like a place of your interest)

So in this case, disable Orbit Around Selection if you want to paint arround Torus. So it starts orbit around view center.

To recenter point of view select object or vertex and hit Numpad . or go to 3Dview Editor > View > Frame Selected.

If you use this operator in paint mode in will "frame" last place you paint on.


How to Parent Bones to the Panels of a Dieline Package (Paper Folding)

Ditch the bones and make an object hierarchy.

Since each flap of your test file is a separate object would suggest can be done without the extra hassle of creating an armature.
For simplicity the face with the most folds is selected as the parent. Its origin is arbitrary and has been kept as the center of geometry.
Now for each flap connected to this, move its origin to the middle of the fold edge and parent to it.
And so on. In example the top flap is parented to the left flap which is parented to the bottom flap.
Make sure the rotation is applied on all the flaps.
Angle axis Rotation.
One of the rotation types available in blender is axis angle. ie how much to rotate about a particular axis, which is ideal in this case, since the fold determines the axis.

For example the front and bottom faces fold on the X axis. To keep the angle of fold direction desired positive, the -X axis is chosen for front flap.
Custom Rotation for a tilted aircraft flap
Driving the result.
Since for simple example, flat is angle 0 and folded is angle 90. Added a simple custom property "prop" to the bottom which goes from 0 (flat) to 90 degrees (pi / 2) folded and driven each child flap with it.

and here is the end result.

Same for armatures.

Slapped this together, thought I'd add it here.  Can make a single mesh where each edge between two flaps is exactly aligned down the axis of the hinge.
Makes an armature and puts in hinge bones with head in closest point on of edge to face center, and tail pointing towards the face center.  This will ensure that the bone always hinges on the X axis (1, 0, 0). With the mesh in XY plane the bone z axis matches the global z axis (or face normals)
All the hinge bones rotation modes are set to axis angle.
Each hinge bone is given a name with the edge index appended.
If a temp mesh is made as such, the location of the face center will become the bone tip. The actual objects can be parented to tip, or constraints used.
Added vertex groups to each face of the object.
Select the base face of the folding structure and run script.
import bpy
from mathutils import Matrix, Vector
from mathutils.geometry import intersect_point_line
import bmesh
context = bpy.context

def hinge(armob, ob, pb, face):
    arm = armob.data
    # add a bone from edge center to face center
    face.select_set(True)
    edges = [(l, f) for l in face.loops for f in l.edge.link_faces if not f.select]

    for l, f in edges:
        e = l.edge
        b = arm.edit_bones.new(f"Hinge_{f.index}")
        b.parent = pb
        pt, dist = intersect_point_line(
                f.calc_center_median(),
                e.verts[1].co,
                e.verts[0].co,
                )
        b.head = pt
        b.tail = f.calc_center_median()
        vg = (
                ob.vertex_groups.get(b.name) or
                ob.vertex_groups.new(name=b.name)
                )
        vg.add([v.index for v in f.verts], 1, 'ADD')
        hinge(armob, ob, b, f)

def make_armature(ob, face_index):
    me = ob.data
    bm = bmesh.from_edit_mesh(me).copy()

    face = bm.faces.active
    bpy.ops.object.mode_set(mode='OBJECT')
    bpy.ops.object.armature_add()
    arm = context.object

    mw = (
            ob.parent.matrix_world.copy() if ob.parent
            else ob.matrix_world.copy()
        )

    ob.matrix_parent_inverse.identity()
    #ob.matrix_world.identity()
    ob.parent = arm
    ob.matrix_parent_inverse = ob.matrix_world.inverted()
    ob.vertex_groups.clear()

    arm.matrix_world = ob.matrix_world
    bpy.ops.object.mode_set(mode='EDIT')
    b = arm.data.edit_bones[0]
    b.tail += face.calc_center_median()
    b.head += face.calc_center_median()
    hinge(arm, ob, b, face)

    bpy.ops.object.mode_set(mode='OBJECT')
    for pb in arm.pose.bones[1:]:

        pb.rotation_mode = 'AXIS_ANGLE'
        pb.rotation_axis_angle = (0, 1, 0, 0)
    ob.modifiers.clear()
    mod = ob.modifiers.new(
            "Hinger",
            type='ARMATURE',
            )
    mod.object = arm
    bpy.ops.object.mode_set(mode='POSE')
make_armature(context.object, 0)


How can I fix the rotation for this hand?

you have to rotate them in edit mode by pressing R + the axis to rotate (you are wanting to align the bone rotations so you have to select if i am not mistaking the Y axis must be) and rotate the by a value of 90  or -90. ensure that the armature its not assigned to a mesh because it may get really bad bug in your mesh if you are editting it (the armature) with it, so you have to clear the parent and when you are done fixing it parent it again.


Your properties panel is scrolled down. Try scrolling up with the mouse wheel or the scroll bar:


Making a single node using multiple nodes

This is quite simple. All you have to do is to create a group from the nodes.

Simple example:

Say you have some fancy node setup:

To group these nodes, select those you want to group (press B to border select ). Then in the nodes menu select Node > Make Group (or press Ctrl+G):

After having created the group, connect the input sockets you want to have as input (here the color to diffuse shader):

To get out of your group click on the little up arrow at the bottom:

(Or press the Tab key)

Et voilà, you have a fancy shader:

Hope that helps


I found that because I had the Clip Start set to 0.001 it was producing this unusual effect. However, when I bumped this up to 0.1 the shading went back to normal.


Importing models from AutoCAD to Blender

TL,DR
There is no quick one-button way to do that.
Long Answer
CAD models generally have either native NURBs or ACIS Solid based geometry, which are mathematical models describing surfaces, rather than polygon based meshes common in subdivision based modelling. Blender can neither read nor import any of those, and only has very basic support for builtin NURBS geometry.
File formats Blender can read are always mesh centric, like FBX, OBJ, STL or 3Ds, and most don't even support holding NURBS or solid data, like say IGES or STEP.
At export those models are always converted into meshes by the very CAD application, before they even reach Blender. There is no way to guarantee arbitrary CAD geometries can conform to a good quad based topology, let alone convert them cleanly. Even when there was, CAD application meshing algorithms aren't always the best or most efficient anyway.
MoI is an example of a CAD application with a relatively decent meshing algorithm, that outputs good quad based meshes, but even this fails to produce proper quad geometry on every occasion.
Good quad based topologies are purposefully planed from scratch along with your shape, and your model has to be built around them from the ground up to guarantee good results. Your mesh is your topology, not an afterthought or something you tack at the end.
There is no one-button-press solution to turn a triangulated topology into an elegant quad dominant edge-flow, good topology is an art, and there is no easy way to fix your models.
Possibe Solutions
You can try Retopology which is laregely a manual process
You can look into the Remesh Modifier which is semi automatic method, but has limitations and drawbacks. Can speed things up, but don't expect miracles, no automated solution will beat well thought out manual topology.
My experience is that dealing with model cleanups always ends up being more work than doing it cleanly from scratch.
You end up spending a lot of time doing menial tasks, micromanaging, dealing with corner cases and unforeseen consequences, for average end results at best. The same time would probably be best spent, learning good modeling techniques using proper topology and actually refining your work, rather that fixing issues after the fact.


Edge Sliding multiple verts/edges along a single edge axis?

The easiest way is to create a custom transform.
Select an edge that represents the orientation of your desired transform, in your case, this will be where the red arrow is pointing, then Ctrl + Alt +  Space bar  this will create custom transform using the orientation of the selected edge, now you can use this new transform to move your mesh along. For example if you want to move the selected vertices/edges/faces on the new Y axis, select them, press G to move, then press Y + Y, this will change the orientation from the default Global to the new custom transform. You can edit the parameters of your custom transform immediately after creating it in the tool's   shelf to the left of the 3D view, if you can't see it use T to show it. You can rename and delete the custom transform in the properties shelf to the right of your 3D view, use N to toggle it's visibility.


Don't use the "mix" function on the glare node. Just set it to 1 (outputs glare only) then add it back to the original with an add node, like this:

Not only can you chain as many as you like this way, but you can use the factor on the add node to have complete control over the intensity of the effect.


How to use pointcloud_write(...) and pointcloud_search(...) ? (Open Shading Language)

I was quite intrigued by these functions and tried to following the code examples in the OSL language specification but without success. On digging into the Cycles code, however, it becomes clear why this was not working :

int OSLRenderServices::pointcloud_search(OSL::ShaderGlobals *sg, ustring filename, const OSL::Vec3 &center,
                                         float radius, int max_points, bool sort,
                                         size_t *out_indices, float *out_distances, int derivs_offset)
{
    return 0;
}

int OSLRenderServices::pointcloud_get(OSL::ShaderGlobals *sg, ustring filename, size_t *indices, int count,
                                      ustring attr_name, TypeDesc attr_type, void *out_data)
{
    return 0;
}

bool OSLRenderServices::pointcloud_write(OSL::ShaderGlobals *sg,
                                         ustring filename, const OSL::Vec3 &pos,
                                         int nattribs, const ustring *names,
                                         const TypeDesc *types,
                                         const void **data)
{
    return false;
}

The functions merely return 0 or false and perform no action. Therefore, it appears that this functionality has not yet been implemented in the current version of Cycles.

The source can be found in the Blender GIT Cycles repository at https://git.blender.org/gitweb/gitweb.cgi/cycles.git/blob/HEAD:/src/kernel/osl/osl_services.cpp


Ok I came up with the solution by myself, based on new info provided about Boolean modifiers not working on flat planes in answers to my OP.  Instead of trying to model a 2D shape and then extrude it to a 3D shape later, it occurred to me that I should just create the 3D shape in its entirety and then use the Boolean modifier as it's intended to cut out the alcoves from the room.  I created cubes in the dimensions of each alcove, then used snapping to position them relative to the appropriate corner (a fiddly process), then apply the operator.  This has achieved exactly what I wanted.

I guess that if I still wanted a 2D shape then I could have still modelled it as above, then deleted the edges/faces that make it 3D, leaving a flat face in the shape I wanted.


Liquid simulation sees obstacles' rotation correctly but not their location

Curious about the problem, I set it up myself, but a bit simpler.
The cause is that your glass is too thin walled. Upon closer inspection I saw that at the start it already slips through the bottom.

So I created a thick cup for the water and then you see it stays contained. Because you wouldn't like to create such thick glass, what you could do is create a helper object that has the same inner dimension as your glass, but with thicker walls. In the outliner you disable the render output for this object (so that it won't render), but it will contribute to the backing of your fluid.

*) notice that it's not the best GIF, as I am kind of new to creating GIFs.

update 1
Ok usually the above is the case with fluids, but in this file more was going on. Some of the objects had non applied scales (ctrl+a) all objects where parrented to a bezier. I removed it and it behaved right. Though then ofcourse the cup wasnt moving. At least it showed your walls where thick enough. So i went to frame 0 and in 3d view while selecting the cup press i Select "loc rot" skip a few frames (best do this in Right or left View), then move cup up , rotate slightly over x axis (R+x) skip some frames again move cup towards the bin rotate some more. press i loc rot again.
So with "i" +locrot you split up the movement in parts, and you can even control how smooth the motion goes between each "i"+locrot in the graph editor where one can adjust for smooth movements.
Here is the fixed version :

Update two
There is another way to fix your blend file, but the result wont be as good as compared to update 1, you'll have to apply scales to your objects first.
Next for the cup under volume initialization there is an option "export animated mesh", the solver works a bit different (and its not looking as good as update 1), its rarely used. Often used when combined with armatured meshes, i'm not sure why you had this small bezier cube, for such simple motions i wouldnt use bezier curves but go for update one. Just compare how few i+locrot i had to do as compared to the many nodes in grapheditor for your object (that might be a close match to something your not showing here, but tuning that many key frames isnt handy).

update 1 in action :


Is there a way to import .mx or .mxa files?

Now there is a at least partially implemented importer (prints a lot of stuff to the console) All you need to do is copy the script in the editor and
edit this (last) line before pressing the run button:

importMX("c:\\path\\avatar.mx", 'Avatar')

The first argument is the path to the file to import, second the object name in Blender.

import bpy
import mathutils
import struct

def read_n_items(file, n, func):
    for i in range(n):
        func(i, file)

def read_struct_from_file(file, fmt):
    return struct.unpack(fmt, file.read(struct.calcsize(fmt)))

def skip_string(file):
    s=''
    while True:
        c = struct.unpack('c', file.read(1))[0]
        s = s + c.decode("utf-8")
        if c == b'\x00':
            print(s)
            return

def importMX(filename, obj_name):
    verts=[]
    faces=[]
    with open(filename, 'rb') as file:
        prjx = read_struct_from_file(file, '8ch')
        print(prjx)
        num_texture_files = prjx[8]
        print(num_texture_files)
        while num_texture_files > 0:
            num_texture_files = num_texture_files - 1
            skip_string(file)
            groups = read_struct_from_file(file, 'h')[0]
            exec_lists = read_struct_from_file(file, 'I')[0]
            exec_type = read_struct_from_file(file, 'h')[0]
            vertices = read_struct_from_file(file, 'h')[0]
            #groups,exec_lists,exec_type,vertices = read_struct_from_file(file, 'hIhh')
        print( 'vertices=%d' % vertices )
        idx=0
        while idx < vertices:
            x,y,z,reserved,colour,specular,tu,tv = read_struct_from_file(file,'fffIIIII')
            print('%d %f %f %f' % (idx,x,y,z))
            verts.append((x,y,z))
            idx = idx + 1

        num_tex_groups = read_struct_from_file(file, 'h')[0]
        print(num_tex_groups)

        while num_tex_groups > 0:
            texture_type,start_vertex,num_vertices,texture_no,num_triangles = read_struct_from_file( file, 'hhhhh' )
            num_tex_groups = num_tex_groups - 1
            print( "tt=%d sv=%d nv=%d tno=%d tria=%d" % (texture_type,start_vertex,num_vertices,texture_no,num_triangles ))
            while num_triangles > 0:
                v0,v1,v2,pa = read_struct_from_file( file, 'hhhh' )
                nx,ny,nz = read_struct_from_file( file, 'fff' )
                print('%d,%d,%d %f %f %f' %  (v0,v1,v2,nx,ny,nz))
                num_triangles = num_triangles - 1
                faces.append((v0,v1,v2))
        print(verts)
        print(faces)
        mesh = bpy.data.meshes.new( obj_name )
        object = bpy.data.objects.new( obj_name, mesh)
        object.location = (0,0,0)
        bpy.context.scene.objects.link(object)
        mesh.from_pydata(verts,[],faces)

if __name__ == "__main__":
    importMX("c:\\path\\avatar.mx", 'Avatar')

Result:

avatar.mx

airmoble.mx

To get started you can extend on the following code, there is also an undocumented 8 byte "PRJX...." id at beginning of the file besides that the format seems to match.

See https://docs.python.org/3.4/library/struct.html for the format strings like: h=uint16 and I=uint32 etc.


Make sure that if you are using an older version than 2.8 to check volumetrics in render properties tab and adjust the end clipping if you scene is large.


Sadly it doesn't seem to be possible. You can remove and add items to the quick favorites to somewhat reorder them but that seems to be the most you can do for now.


Layout is weird and there is multiple ones that is the same/wrong spot

I would advice to get the basic stuff like using the UI on your own before continuing. It might not be practical to ask for every small detail like this. But, sure, the answer is not difficult at all.

Just grab a corner of some editor and drag it towards another to merge the UI areas:

Please note that it makes a difference what side you click on. If you drag towards another area from where you clicked it merges them, if you drag towards the area you clicked in it splits it into 2.

You can also right-click the line between them to get a menu with options:

And there are also layout presets on the top that you can chose:

And if you click the + button at the end you can create new layouts from default presets:

Don't worry, if yours are not identical to mine in the GIFs, they can be customized. There is nothing wrong with defaults, mine are just what I use most.


OBJ format: can you export faces with indexes relative to the last "o Something" (object)?

I do not understand the question. Can you specify why it is impractical for your specific case. Where and how do you plan to import the data?

Obj files will need a unique face index as different objects are separated by obj groups referring to the vertices which are included in each object. Otherwise the file would result in something different when importing somewhere else. If you want to alter the way the wavefront obj format is imported or handle the data externally in a specific way you could always parse the file for obj groups using python and sort it the way you would like for your specific application. Alternatively you could also export all objects separately using python, obviously depending on the constraints you have making it impractical for your specific case.


IMPORTANT EDIT

re question change, pretty much the same code added to a modal timer operator, and changed to use view3d.border_select.  Run the operator in 3dview, then when in edit mode Right click in camera view to select vertices.   Setspace.use_occlude_geometry to view unobstructed and visible vertices.

import bpy
from bpy_extras.view3d_utils import location_3d_to_region_2d

def view3d_find():
    # returns first 3d view, normally we get from context
    for area in bpy.context.window.screen.areas:
        if area.type == 'VIEW_3D':
            v3d = area.spaces[0]
            rv3d = v3d.region_3d
            for region in area.regions:
                if region.type == 'WINDOW':
                    return region, rv3d
    return None, None

def view3d_camera_border(scene):
    obj = scene.camera
    cam = obj.data

    frame = cam.view_frame(scene)

    # move into object space
    frame = [obj.matrix_world * v for v in frame]

    # move into pixelspace

    region, rv3d = view3d_find()
    frame_px = [location_3d_to_region_2d(region, rv3d, v) for v in frame]
    return frame_px

class ModalTimerOperator(bpy.types.Operator):
    """Operator which runs its self from a timer"""
    bl_idname = "wm.modal_timer_operator"
    bl_label = "BXXX"

    _timer = None

    def modal(self, context, event):
        scene = context.scene
        obj = context.object
        region = context.area.regions[-1]

        if event.type in {'ESC'}:
            self.cancel(context)
            return {'CANCELLED'}

        if event.type in {'RIGHTMOUSE'}:
            print("modal")
            if obj.mode == 'EDIT' and obj.type == 'MESH':
                camframe = view3d_camera_border(scene)

                #print([xy for xy in camframe])

                bpy.ops.view3d.select_border(gesture_mode=3, xmin=camframe[2].x, xmax=camframe[0].x,
                                             ymin=camframe[1].y, ymax=camframe[0].y)

        return {'PASS_THROUGH'}

    def execute(self, context):
        wm = context.window_manager
        self._timer = wm.event_timer_add(0.1, context.window)
        wm.modal_handler_add(self)
        return {'RUNNING_MODAL'}

    def cancel(self, context):
        wm = context.window_manager
        wm.event_timer_remove(self._timer)

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

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

if __name__ == "__main__":
    register()

Similar to the method used in https://blender.stackexchange.com/a/40264/15543 , the handler below selects only the verts in the camera view, and deselects the rest, live, in edit mode.

Uses view3d_camera_border(...) and view3d_find methods from https://blender.stackexchange.com/a/14746/15543

dic = {}
@persistent
def edit_object_change_handler(scene):
    # if not some.prop return
    obj = scene.objects.active
    if obj is None:
        return None

    if obj.mode == 'EDIT' and obj.type == 'MESH':
        camframe = view3d_camera_border(scene)
        region, rv3d = view3d_find()
        #print([xy for xy in camframe])
        bm = dic.setdefault(obj.name, bmesh.from_edit_mesh(obj.data))

        for v in bm.verts:
            xy = location_3d_to_region_2d(region, rv3d,
                                          obj.matrix_world * v.co)
            v.select = ((camframe[2].x <= xy.x <= camframe[0].x)
                    and (camframe[1].y <= xy.y <= camframe[0].y))
            #print(v.select, v)
        return None

    for bm in dic.values():
        bm.free()

    dic.clear()
    return None

Cannot see why same would not work in a modal(timer).  Needs some property flag to turn it on or off.

I'd be tempted to extend the BMesh


How can I extrude a dome from a circular face?

Yes, try extruding and scaling it multiple times:

To help make the extrusions more even, you might try using the To Sphere operator (⎇ Alt⇧ ShiftS). You can define where the center of the "sphere" To Sphere uses by using the 3D cursor as the pivot (.).

If you want to be more precise, try adding a sphere and deleting half, then using Bridge edge loops (W, E)

Note that the number of vertices on the perimeter of the sphere should match the number of vertices around the initial circle.


How to edit a glass shader to make it look like bumpy frosted glass

You can also use a bump node, which offers more control and tends to have fewer artifacts than the displacement output (see What is the difference between the displace socket and a bump map?):

The fake glass node group lets light pass through the glass more easily, see this answer.


Move all objects that you want to render in a separate layer.
Move all lights and anything affecting the objects in another separate layer.
Than click the second tab from your main editor (which says Render Layers). And select only the layers which you want to be rendered (the one which has the separated objects and the lights layer).


The "Restrict Render" setting only applies to the Cycles or BI renderer, but not the OpenGL renderer (used in the viewport, and for the Game Engine).

If you want to achieve something similar, animate the "Visible" attribute instead.

Note that this is a binary state. There's no way to fade, or gradually shift from visible to invisible. It will be totally visible one frame, and totally invisible the next frame.

If you're wanting to fade, you'll need to animate the Alpha channel instead (though there is some benefit to turning "Visibility" off, once something is totally transparent).


Splitting giant action into many sub actions via python?

Got it! I was attempting to call the remove() method on a Keyframe object instead of the keyframe_points property of the FCurve. Below is working code that transforms a giant action into multiple sub-actions (working in 2.79, I'd say it should work in 2.8 as well but I don't know how extensive the changes were to the api between 2.79 and 2.8 so if you're on 2.8 your mileage may vary):
import bpy

# Define the name of the giant action containing all other sub-actions
base_action_name = "bend"

# Define the name, start, and end frame of each sub animation
sub_actions = [
    ("sub_bend_001", 0, 14)
    ,("sub_bend_002", 15, 29)
]

for a in sub_actions:
    new_action = bpy.data.actions.get(base_action_name).copy()
    new_action.name = a[0]
    for fc in new_action.fcurves:
        # Remove unwanted frames
        for i in reversed(range(0, len(fc.keyframe_points))):
            kfp = fc.keyframe_points[i]
            frame_number = int(kfp.co[0])
            if frame_number < a[1] or frame_number > a[2]:
                fc.keyframe_points.remove(kfp)
        # Shift remaining frames
        offset = fc.keyframe_points[0].co[0]
        for kfp in fc.keyframe_points:
            kfp.co[0] = kfp.co[0] - offset
            kfp.handle_left[0] = kfp.handle_left[0] - offset
            kfp.handle_right[0] = kfp.handle_right[0] - offset


Ditch the operators

Test run with default text and default bezier circle objects

Below is code which does, what I believe to be, same as above, but without any operators.  For case of example I have used an object named "Text" in scene for text object, and an object named "BezierCircle" for the curve. Change to suit

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

context = bpy.context
scene = context.scene

text = scene.objects.get("Text")
curve = scene.objects.get("BezierCircle")

if text and curve:
    # add modifier
    cm = text.modifiers.new("foo", 'CURVE')
    cm.object = curve
    cm.deform_axis = 'NEG_X'
    # rotate
    R = Matrix.Rotation(radians(90), 4, 'X')
    text.matrix_world @= R # replace @ with * for pre 2.8
    # translation
    text.matrix_world.translation += Vector((12.8872, 0, 0))
    # insert keyframe
    text.keyframe_insert("location", frame=1)
    # and again
    text.matrix_world.translation += Vector((-11.6886, 0, 0))
    text.keyframe_insert("location", frame=249)


Is there an option to turn off the save prompt before quitting in 2.8?

Yes, you can choose to loose all of your work by not saving (and be unbothered), if that is what you want to do...

Disable the Save Prompt on the system preferences>Save and Load section.


How to get all types of nodes dynamically?

This addresses the second part of your question. How to auto generate all this.

Node Category (cycles) and each registered node.bl_idname in the category

import bpy

ddir = lambda data, filter_str: [i for i in dir(data) if i.startswith(filter_str)]
get_nodes = lambda cat: [i for i in getattr(bpy.types, cat).category.items(None)]

cycles_categories = ddir(bpy.types, "NODE_MT_category_SH_NEW")
for cat in cycles_categories:
    print(cat)
    for node in get_nodes(cat):
        print('bl_idname: {node.nodetype}, type: {node.label}'.format(node=node))

Output is (snipped):

NODE_MT_category_SH_NEW_CONVERTOR
bl_idname: ShaderNodeBlackbody, type: Blackbody
bl_idname: ShaderNodeValToRGB, type: ColorRamp
bl_idname: ShaderNodeCombineHSV, type: Combine HSV
bl_idname: ShaderNodeCombineRGB, type: Combine RGB
bl_idname: ShaderNodeCombineXYZ, type: Combine XYZ
bl_idname: ShaderNodeMath, type: Math
bl_idname: ShaderNodeRGBToBW, type: RGB to BW

Custom Node Groups of type ShaderNodeTree

[ng for ng in bpy.data.node_groups if ng.bl_idname == 'ShaderNodeTree']


Is there a way to model schrödinger's wave equations in blender?

I was able to find a tool that did everything for you. The tool is here: https://github.com/Niuskir/Electron-Orbitals-Blender-3D


Why is my Eevee viewport render different from my full render?

To quote an answer I got elsewhere,

  What makes the rendered image look dark is the volume material of the
  particle emitter. However, the emitter is not shown because you have
  to enable “show emitter” in the particle options :slight_smile:
  Unfortunately, the “show emitter” checkbox doesnt have influece on the
  viewport so you always need to double check if it’s turned on or off.
   --eaNiiX


You can do compositing to selective parts of a scene by using render layers. In your case you need two render layers. The first one should contain your everything except the dice. The second one should contain your dice and have "sky" disabled. The red cube is in the normal render layer and the blue cube is in the blur render layer. Here is an example compositor setup to get the effect you want.


can i set the pivot of one object as that of another one?

Select the clock object in object mode.  Shift s (snap) -> snap cursor to selection.  Select the dial in object mode.  Shift ctrl alt c (set origin) -> set origin to cursor.  Done.


If you parent a physics object to another object it becomes a static object.
  Therefore there is no velocity anymore.

It was answered to me in another forum.Thanks for all the effort.I 'll mark it answered if I find how.


In the view menu of the graph editor, uncheck "show group colors", and the default color should be back.

This light blue color you see is associated to the bone groups in the armature properties. It is very handy in the viewport, but make things less readable in the graph editor.


How to move alot of objects by "Force Field" each one in a different speed

Giving each object a unique weight is the right idea and can be done with two lines of code.
The following loops over every object in a collection, generating and assigning a random mass value between 0 and 1 for each object.
    import bpy
    import random

    for obj in bpy.data.collections['obs'].all_objects:
        obj.rigid_body.mass = random.random()

If you want to specify limits on the values of mass, the following sets each object's rigid body mass to a random value between 0.2 and 0.5:
    import bpy
    import random

    for obj in bpy.data.collections['obs'].all_objects:
    obj.rigid_body.mass = random.uniform( 0.2 , 0.5 )

This is straight forward within Blender:
1.Make sure all your objects are in their own collection - here I've named it 'obs'

Open a new text editor window:

Create new text file:

Add code, using the name of your collection ('obs' in this case) then click the run button to execute.


How should a glass material be setup in Cycles?

There are a couple things going on here:

The glass is not entirely white, so a noticeable amount of light is being absorbed. Setting it to white (or almost white) gives a more glassy result:

With a less uniform lighting/environment the glass is more visible:

In this render I adjusted the model to get rid of the subsurf artifacts and thicken the bottom a bit.
There is an air gap between the liquid and the glass. This isn't the way liquid normally sits in a glass in real life, so it might look funny. See Liquid / glass interface IOR and normals in Cycles.

If the interface between the liquid, air, ice, and glass are setup as described, you get a result like this:


VSE Blender (editing formats native RAW, XAVC, ProRes, cinemaDNG)

Blender VSE is not a time-based video editor (like Premier Pro or Sony Vegas is), but it is a frame-based video editor (like After FX or Nuke).

As such it caches the frames into memory and has no native codec to speak of.

The question which remains is whether it will decode/encode such codecs:

Blender can already read ProRes, ProRes encoder is in development.
There is no support for CinemaDNG. There was a discussion about it and it was suggested it would be better to include the support into the openimageio open-source library directly, rather than into Blender. There was a Google_Summer_Of_Code project wanting to implement DNG but never materialized.
OpenEXR is fully supported

It is generally better to export still frames from Blender and encode the video with different application - for output formats and performance reasons.


Cycles Viewport render ( Shift + Z ) is much brighter than final render

Your area lamp is disabled for render (last icon on the first line):


How to keep UV set position while moving an object?

You can map your texture using another object. If you move the one with the material, the texture will stay still. If you move the 2nd object, the texture will move.


Is there any way to group meshes in a single model to make animating parts of that model easier?

You can work with Vertex Groups which you created in the Vertex Groups panel in the Mesh data tab:

Here you can select and deselect them, rename them, delete them, assign vertices etc. When it comes to animation, you'll propably want to use an armature. Armatures can contain bones, which can be animated (so they contain the keyframes), and by using vertex groups you can tell Blender which vertices to move and how much as soon as you move a bone.


Ok, this is strange… I just changed print(ob.pose) to print(ob.parent.pose) and it seems to works. Idk why or how, but it seems to work and I am just happy about. But still, thanks if someone actually tried to help me.


For converting triangles to quard faces use Alt+J (Tirds to quards).

For good result in your model, tweek Max Shape Angle:

About "these faces called": https://blender.stackexchange.com/a/34267/32374

  The idea is to decimate the model and the frame shown here is part of
  a bigger model and just this is having issue when doing limited dissolve.

About decimating: there is no much difference between this 2 models:

Before limited dissolve:

after:

As you see tirs count stays same. That's because n-gons (that created by limited dissolve) based on same triangles, so there'is no any memory saving in doing this.

  Well, the idea is not to triangulate but decimate. This is part of a
  larger model and the frame is giving issue

If you realy want to save some memory - use decimate modifier or (much better way) - instancing.


Where can I find what version of python is bundled with certain Blender versions?

You can see the version also in the Python Console (here: v3.4.1 64bit)


Best way to change a value between render layers?

I don't think there is any way to know the name of the render layer currently being rendered, which means you can't use a driver or app.handler to calculate a property that varies by render layer.

We can however, render one layer at a time, this allows us to control which layer is being rendered and to alter properties before starting to render a layer.

As an example, we can set a text object to the layer name.

import bpy

for l in bpy.context.scene.render.layers:
    bpy.data.objects['Text'].data.body = l.name
    bpy.ops.render.render(layer=l.name)

Note that rendering a single layer doesn't work when rendering an animation, which means you would need another loop to render multiple frames.


Is it a correct math definition of averaging two vectors? (Blender vector math node)

The Average operator was initially added to Blender as a way to get a Unit Angle Bisector, which is a unit vector that bisects the angle between the two input vectors. The operator assumes that both input vectors are unit vectors, otherwise, it will not work as expected.

Due to the misleading name and the ambiguity of operation. The Average operator has been removed in Blender 2.81. Thought it might be added again in the future in a more clear form.


Can I achieve orthographic lighting in Blender?

Use a Sun Lamp
Form the blender manual:

A Sun lamp provides light of constant intensity emitted in a single direction.
This direction can be changed by rotating the Sun lamp, like any other object, but because the light is emitted in a constant direction, the location of a Sun lamp does not affect the rendered result (unless you use the “sky & atmosphere” option).


Why Ctrl+P menu would be different, and no "Bone" option

That is referred to as a context menu, the available options vary depending on the active item that the action will be performed on. The active object is the one that will become the parent of the remaining selection, it can usually be identified by being highlighted in a lighter colour that the other selected objects.

In your first example you are parenting to an armature.

In the second example you are parenting to a mesh object (that is why you get the vertex parent options).

If you are parenting to a curve object you get curve options.

Parenting to a lattice you get lattice options.

While if you parent to an empty or metaball object you only get simple object parenting options.


Uncheck the "Load UI" button when loading the file. That'll keep the user interface as it was before, instead of loading it from the blend file.


Emitter Particle System not using Density Vertex Group(Single Vertex Emitter)

Because you've set Emission > Source > Faces, and as you've painted the central vertex it considers that all the faces that this vertex is part of will be affected. So you need to subdivide your plane a bit so that only the central face will be affected.


A bone is defined by two points, known as the head and tail of the bone. When you select one of these points you only move that point, the bone/s defined by that point then stretch to fit the opposite point.

If you want to move both points of a bone together you select both points. Clicking the body of the bone will select both points for you.

While I don't think it applies to you, you can lock the points of a bone in the bone transform properties, so that they can't be moved in edit mode. If this is the case, it is a matter of turning off the lock.


Blender Python Data (equality works between instances, identity not)

Each time you access object.data it will return a new instance,
however this is a very small data type to access the real mesh data stored in Blender.

Equality works as expected (and they have the same __hash__), so you can put them into dict/set types. You just can't rely on identity. (As with any 2 strings with the same content).