I wish to make a smooth motion like hips of belly dance

Note 1: It's not bad to have a lot of keyframes! You can easily get used to a key on every frame and grabbing large blocks of keyed animation. When animating over motion-captured or simulated data this is a common occurence. The graph editor should be intuitive, but not clean/tidy!
Note 2: A belly dancer's hips would likely move in an ∞ like shape or an ellipsoid, not in a circle (a very unnatural shape for movement).

A simple sin and cos function can be overlayed if the circular motion is happening on 2 axes only. Select the graphs, add a modifier each (sin and cosine), choose additive for both and set their phase multiplier to the same value. (You can type 1/pi in the phase multiplier field.)

If you want the movement on certain frames use the Restrict Frame Range functionality of the modifiers or keyframe the Influence.
When you want to edit the movement further you'll have to bake the action.
Another method is simply setting good keyframes and using interpolation to your advantage. Keying the four position (1, 0), (0, -1), (-1, 0) and (0, 1) gives us this awkward motion.

To fix this, make the extremes the start and end of the cycle and remove the breakdowns of the curve. Or rotation the Auto Clamped keys which prevent a smooth movement.


Why are these textures diagonally tiled?

If you go into edit mode you will see that the faces have odd edged subdivisions on it.
so if you go back to the UV image editor select all or A then press u and instead of unwrapping go to project from view. This will unwrap the project from view.


How to fix bad shading on cylinder with a difference boolean?

'Auto Smooth' under the normals section of the Object Data Properties tab should do the trick for you. Oftentimes adjusting the angle of the Auto Smooth will also be necessary.


Simple material (diffuse nodes mixed through a "Pointiness" factor) does not work in EEVEE

Not all shader nodes that work with Cycles work also with Eevee. The Geometry "Pointiness" socket doesn't, as well as the other "geometry-aware" nodes like Ambient Occlusion or Bevel.

Here is a reference about node support: https://docs.blender.org/manual/en/dev/render/eevee/materials/nodes_support.html

If your mesh isn't animated, you can bake Pointiness using Cycles and then use it in Eevee:

Unwrap your mesh,
connect the end of the Color Ramp to an Emission shader and the Emission Shader to the Material Output
Add an Image Texture* node, with a blank, new image, and leave it unconnected, but selected
Bake in "Emission" mode (while using Cycles)
Save the baked image
Use the baked image as a Texture* for the Mix factor in Eevee

* if you have multiple UV maps, the image textures must always have their Vector input connected to the correct UV Map node.


Some objects are not rendered in UV pass

The UV pass display the UV coordinate from the UVmap so if an object don't have one they will be black, to solve this you have to unwrap these objects and render again.


For a very, very quick start. The absolute 3 things you need to know to begin effectively modeling in Blender are:

Interaction Modes

Object Mode

You are placed in object mode by default when you add a new primitive. You can translate, rotate and scale the object along the three axes whilst in this mode but to get finer control, you want to enter edit mode. Use Tab to enter edit mode from object mode.

Edit Mode

In edit mode, you have access the underlying structure of the object, you have much more control here and this is where you will spend most of your time when modeling. Likewise, use Tab to exit edit mode and enter object mode.

Mesh Select Modes

Once you are in edit mode, you have 3 different control handles that you can use to help shape the mesh. These are pretty intuitive so I won't explain them and you can read more about these on the relevant wiki page.

Vertex

Edge

Face

Mesh manipulation

This is how you can shape and tweak your mesh. While you can do this object mode as well, you have much more control while you are in edit mode as you have access to the mesh control points.

Translate

Rotate

Scale

If you can understand those, you are on your way. Once you are past this stage, you can start looking at more advanced things such as extrusion, beveling and modifiers etc.

There is too much information to go into here and this should suffice. Your next steps would be to:

Watch some introductory video tutorials (archived), more tutorials for modeling in Blender.
Read the introduction to modeling on the manual.
Browse the modeling and workflow tags on this site for more tips and tricks such as this.

Also, some common shortcuts that you should learn are:

G to grab (translate)
S to scale
R to rotate

Nail these basics and you will be making your own models in no time, using the basic steps above, you can make your train tracks easily by just scaling and translating simple cubes.


How do I attach these arms to the torso?

You already did all the important steps. All you have left to do is move the arm into place (you could use snapping). After the arm is aligned, simply remove doubles.
W > Remove Doubles, from the 3D view header > Mesh > Clean Up > Remove Doubles, or from the tool shelf, tools tab Remove Doubles.

If you did not have every vertex perfectly aligned. You could select both the loop on the arm and the loop on the shoulder and Bridge Edge Loops.
Or you could go around selecting each vertex and its corresponding pair on the shoulder and Merge the vertices M > At Center, or from the 3D view header > Mesh > Vertices > Merge > At Center.

Three ways to do this, all pretty easy.


You can use masking for that, add a mask in the motion tracking editor.


Internal "get/set" function of property?

It's named "testprop" not "test_float"

When a property defined via

bpy.types.Scene.test_float = bpy.props.FloatProperty(...)

is assigned a value scene.test_float = value  it is stored. "behind the scenes" as a custom property scene["test_float"]  ("second time above")

In the get / set example ("first time above") it is instead stored in a custom property named "testprop".

Instead, had  the custom property been named "test_float" in the getter and setter, it would emulate the behaviour of the float property without a getter and setter, and be reflected in the value and existence of scene["test_float"] when set.

Perhaps this needs to be an edit in docs re what RNA would do internally.

Note if the getter is defined thus

def get_float(self):
    return self.get("test_float", 0.0)

def set_float(self, value):
    self["test_float"] = value

bpy.types.Scene.test_float = bpy.props.FloatProperty(get=get_float,set=set_float)

it will return a default value, in this case 0.0 even if the property has not been set.


Modelling an airplane with a irregular shape

Start by adding a edge around the "triangluar-ish" part. Add a circle with the same number of vertices as the outer edge.
Then open up the specials menu with W, and find the Bridge Edge Loops command.

In this picture I have a mirror modifier so I only have to model half of the plane.


blender cloth simulation not simulating properly with collision

Add more loop cuts to the skirt (i.e., with CTRL-R), to make the mesh faces more square.  I added about 5 cuts between each of yours, and it simulates much better now.  It will start to look jumbled at first, but it should straighten out by around frame 40.  This will of course make the mesh much bigger.  You can also do coarser (but still squarish) faces and use a subdivision surface modifier.


How to rename active or first texture slot of a material from script

I realize I just posted the question but I solved this myself not long after. You can also rename the texture names and texture image names with this script by modifying the block of code that renames materials like so:

        if self.rename_material:
            if ob.material_slots:
                for m_slot in ob.material_slots:
                    if m_slot.material:
                        if m_slot.material.users == 1:
                            if (self.rename_use_prefix
                            and self.prefix_material):
                                m_slot.material.name = self.rename_prefix + name
                            else:
                                m_slot.material.name = name
                        if m_slot.material.texture_slots:
                            ~~~~VVV Added The Following VVV~~~
                            if(len(m_slot.material.texture_slots) > 0):
                                m_tex = m_slot.material.texture_slots[0]
                                m_tex.texture.name = name
                                m_tex.texture.image.name = name

Obviously there's some checks that could be done such as number of users and such. I'll post back as I polish the script.


How do i make the image look like its directly outside my window

There are a lot of ways to achieve this, one would be to enable images as planes addon.
It is already included in blender so just go to prefernecs and enable it.

Once its enabled press SHIFT + A > Image > Images as planes and select the image you want to import.
Now simply place the new plane where your window is and transform it as per your needs


You can custom your bones. Create the new shape you want to see as bone, for example a circle. Then select your armature, go in Object or Pose mode, then Properties panel > Bone > Viewport Display, and select the object you've created. If you enable the Wireframe option you'll only see a wireframe object like in your picture.


How can I make it so that a texture displacement applies to all sides of an object?

You need to set the 'Texture coordinates' to UV, and eventually choose a UV map:


Is there a way to prevent Blender from creating .fbm folders when exporting to .fbx?

You should delete the material on the object you're exporting in Blender and have the material importing disabled in Unity.


Blender ascii fbx adds a Armature bone before root bone UE4

Had this same problem and spent a day trying to work it out. Reverted back to Blender 2.74 and export with FBX 7.4 binary and it worked fine.

For some reason Blender 2.75 and 2.76 add this bone, which means enabling root motion in Unreal Engine does nothing. This sucks because replacing a skeleton in Unreal when you have heaps of animations and montages is annoying. Really hope this gets fixed.


Why do baked textures turn out checkered or blocky?

Try to increase/decrease that parameter before baking:
Render - Baking - Ray Distance.
Begin with small ray amount - 0.1 or around it.
Also, some information from this video also can help:
https://www.youtube.com/watch?v=0r-cGjVKvGw

P.S. As i can judge by shape - you unwrapped your mesh properly? Re-check it, just to be sure.


Dynamic Paint - "Use Object material" for Brush removed in Blender 2.8?

In the end I didn't use the material color, but used a small script to assign the vertex color of each object to the brush color of a dynmaic paint modifier. (Use Strg+L to link modifier to all objects)
for obj in bpy.context.collection: #use active collection
    obj_col = list(obj.data.vertex_colors['Col'].data[0].color)[:3]
    obj.modifiers['Dynamic Paint'].brush_settings.paint_color = obj_col


I just ran into what I believe is the same issue.

Check the Temp path in both versions' preferences. You probably changed it for the old version in the past but forgot to do this in the new installation. You must use the same path otherwise the clipboard contents won't get shared across versions.

What's happening is that upon copying an object Blender temporarily stores it in a file called copybuffer.blend, found in the temp directory. When the temp path isn't the same in all versions preferences you'll get independent copybuffer files in those  different directories, and each Blender version will only read the files from their respective temp directories.

Here's how to setup the temp directory path:

2.79 and earlier

Temp in File tab of  File > User Preferences

2.8+

Temporary Files in File Paths tab of  Edit > Preferences


No Option For Graphics CPU in Render Settings

Now you must have Blender Render on that renderer option of yours.
Change it to cycles! Now! Now!

The option box on the render setting will magically appear!

Additional Notes
You may need to make sure the Performance numbers are setup correctly
to make rendering go faster when you are using the GPU. Also beware
that overly bright scene that renders with lots of "firefly" noise
will slow down the render too.

Turn on "Auto Tile Size" in your user preference add on tab.

Here is where you will find the tool on the performance header.


how to change the render image size without changing camera settings

I think you can achieve your goal by changing the Sensor Fit setting under the camera settings from "Auto" to "Vertical".


Normal edit modifier creates jagged edges

The problem has been solved. In the latest build an extra option has been added to the normal edit modifier. It is a field called "Max angle". Standard it gives a volume of 180 degrees. As explained by the developer, if you bring this value below 90 degrees (say 30) it prevents the normals from inverting and producing the jagged edges. Thanks for this life saver Bastien.


Mix normal texture with noise texture to create flat patches

You could use the following material set up to achieve the desired effect :

This is using a Bump node instead of the Displacement socket as it is more easily configurable. Using Displacement (True Displacement) can result in gaps in your surface - especially if there are hard edges in the texture (such as where the surface transitions between brick and plaster). The Color Ramp allows the noise texture to be modified to produce the desired patches and this passes on to a Maximum node so that the flat plaster gives way to brick as the noise texture drops low. This will mean that the White areas will be the plaster rather than the Black in your example.

The Bump node is used to apply the texture to the surface Normal and this gives the impression of displacement rather than actually displacing the surface.

The Invert node is there simply to invert the brick texture I am using as my particular texture has light mortar and dark bricks. I am using the raw colour data to determine the depth and this is not ideal (it's under the assumption that lighter colours (the mortal) are set back more than the bricks). The inversion ensures that the mortar is inset rather than protruding.

You can adjust the plaster by varying the Color Ramp - this can adjust the amount of plaster/holes as well as changing the hardness of the edges by making the transition between Black and While sharper or softer. The thickness of the plaster can be varied by reducing the brightness of the White.

The Bump node can be amended to change the height/strength of the bump effect and this will affect the thickness of the plaster as well as the strength of the brick texture. The Normal from the Bump node feeds into the shader Normal.

Here's the brick texture I used. It isn't ideal as it has dark shadows which affect the bump mapping :

Tweaking the Noise distortion and adding colour based on the presence of plaster can produce the following result :

Or adjust it for a more subtle effect :


You could also try to change the Steps.

Inside the particle system go to Display (2.79) or Viewport Display (2.8) >>

Good Luck.


You can get rid of the brush circle, but you can't get rid of the system cursor. Turn off 'Show Brush' in the Options tab.


How can I draw a parallel line to other edge in a face?

There are a few methods, but usually the most intuitive is the knife tool. Put your view in orthographic and snap it so that the line you want to cut is either flat horizontal or vertical and use the angle constraint mode (c).

If there are things blocking your view of the cut just hide them (h). If the cut isn't aligned to one of the global axes then you can select a face with a parallel edge and snap you view to it with shift+numpad7/1/3.

In the case you have drawn though, I would just use the knife tool and cut the edge without worrying about getting it parallel. After the edge is cut grab the vertex at 'g', enable vertex snapping and constrain movement to z axis. Then snap it to the vertex at 'f'.


You need to check the "Limit Selection To Visible" button

in the toolbar in Edit mode. This will hide the back edges from view.


Straightening Lines without Straightening Iron

You can do this with a custom orientation.

Select the A and C vertices and choose a Normal Orientation
Click the + button to save this new orientation
Select vertices A + B + C (order matters) and set pivot point to Active element
Scale the selection to 0

Making a custom orientation

Scaling to 0, active vertex as pivot point.


How to rig a plate so that it points to a target, with off-centre tilt, and constraints on elongation and tilt

Disclaimer: This solution is not quite geometrically perfect, it doesn't take into account the disk radius and angle when adjusting the height to the target, so the disk doesn't necessarily touch the target at close ranges, but otherwise it seems to work, and ended up being relatively simple.

Just setup a single armature with two bones, so that the middle hinge is at half the whole height of the armature. In this case the armature is 1 unit high, so the tail of the second bone is at $0.5$ units in Z.

Create your $Target$ empty exactly at the tip of the second bone.

Add a single Transform constraint to the whole armature, and set it up to transform the Z location of the source object into Scale transform of the armature, and pick the $Target$ object as source.

Getting the right values was sort trial and error, but since the armature is 1 unit high, I suspect the min and max values for both source Z coordinate are respectively $0$ and $1$. Set the max scale to whatever height you want to limit the arms to; set space from World to Local.

Now enter Edit Mode in your armature, select the tip bone and add a bone constraint of the Damped Track type and point it to the same $Target$ empty. Track with Y and set Z as Up. You may also want to add a Limit Rotation to bound it to the desired values.

And is about it for the setup. Just create your disk object and parent it to the tip bone (not the whole armature). Make sure to add a Limit Scale constraint with all axis set to $1.0$ so it doesn't change size with target height.

Moving the $Target$ empty around should give you the effect you want while always bending at the middle hinge point.


I think the mismatch that is giving you a challenge is between the default sizes of the dimensions. The default size of a unit in Blender is one meter. The default size of a unit of measurement in Meshlab is one centimeter. If you create a blender object that measures 4 blender units in one dimension, and 2 blender units in another, when imported to meshlab, it will be 4 centimeters in one dimension, and two centimeters in the other.

You either need to account for the difference in sizes when you create your model, or change the units in Blender so that one grid square is one centimeter, instead of one meter.


Question about verticles!(new on blender)

If I understand correctly, your main question is what the difference is between smoothing an object via a subdivision surface modifier and via smooth shading.

A subdivision surface modifier smooths an object by taking each face and dividing it into smaller faces, and then smooths the result. You aren't able to edit the vertices generated by the modifier without applying it. However, you are able to edit the original faces still, and the modifier will update accordingly.

Smooth shading doesn't actually change the vertices of your object. What smooth shading does is tell blender to reflect light off of the surfaces as if they were smooth. If you take a default sphere and set the shading to smooth, all it does is tell blender to reflect light off of the object as if it was a perfect sphere and not made up of flat faces.

Often both a modifier and smooth shading are used together, although not always.

With blender, you can almost always edit the vertices of your object with no problems. There are a few cases where it's not a good idea or not easy to edit them, but they are scenarios you won't encounter for a while.


Simply adding an image to mesh (UV confusion)

So for everybody looking for a solution for that situation as well.
There are two ways (probably even more) to solve it:

The one that Akai explains in his post very detailed
The one that is explained in this video https://www.youtube.com/watch?v=VnfTSXWF21A

Thanks for the help!


How to add panel into 3D view port (beside object 3D)

Setting bl_space_type = 'VIEW_3D' will place your panel within the 3dview. You then set bl_region_type = 'TOOLS' to have it show in the tools region while the less intuitive bl_region_type = 'UI' places it in the properties region.

If you want to place a panel in the properties editor, you would set bl_space_type = 'PROPERTIES' and bl_region_type = 'WINDOW', then you set bl_context to match the context you want it shown in - Object, Scene, World, Modifier...

Also remember that you need to register your panel class -

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


I find this setup best to mimic proper glass in eevee. Pay attention to the Blend Modes I have highlighted (I didn't use a transparent shadow but you can if you want). You can leave the IOR at default, but I find 1.05 gives a better look for a lot of things.


Texture Image Material is flipping the PNG file I Input

You're probably looking at the "back" of the plane, then.

To fix this, pick any one of the below options:

Mirror the plane on the X-axis. Do this with SX-1Enter or CtrlMXEnter.
Flip the plane's normals. Press Tab to enter Edit Mode, press A to select all vertices, and then look in the tool shelf at left for Flip Direction under the Normals subheading (it's about halfway down the list).
Flip your camera around. Put the 3D cursor at the center of the scene, change the pivot point to 3D Cursor by pressing . (period), and press RZ180Enter
Create a UV map. This is probably the best and most flexible solution, but it requires a little more work. Press Tab to enter Edit Mode, select all the vertices with A, and, since it's only a plane, simply press U and select Unwrap. Then, in the UV/Image Editor, you can move the UV vertices to make your texture display correctly.


bpy.ops.transform.translate does not work as expected for object just linked from one collection to another

Objects need to be selected.

Since the operator works on all selected objects and you are translating each the same, could select and call the operator once.  Tip only need to set non default values in an operator call

As an example will use default file, and set active object to None and assume no other objects selected

>>> C.view_layer.objects.active = None

Selecting works:

>>> for o in D.collections['Collection 1'].objects:
...     o.select_set(True)
...
>>> bpy.ops.transform.translate(value=(0, 0, 1))
{'FINISHED'}

Overriding context

>>> c = {"selected_objects" : D.collections['Collection 1'].objects}
>>> bpy.ops.transform.translate(c, value=(0, 0, 1))
{'FINISHED'}

Putting it together to add a copy of each object in 'Collection 1' to 'foo'.

Copies the objects, links them to foo and moves them using one call of overridden operator.

>>> bpy.ops.object.select_all(action='DESELECT')
{'FINISHED'}

>>> foo = D.collections.new(name="Foo")
>>> C.scene.collection.children.link(foo)

>>> obs = [o.copy() for o in D.collections['Collection 1'].objects]
>>> for o in obs:
...     foo.objects.link(o)
...

>>> bpy.ops.transform.translate({"selected_objects" : obs}, value=(0, 0, 1))
{'FINISHED'}

Ditch ops when possible

  but still I would like to use the methods that the API provides and
  learn those, instead of patching the matrices directly.

IMO it's the other way around, the operator is basically a bridge between UI and API.  For transforms you are far better off manipulating the matrices directly. There are some ops I would suggest you never use, eg adding a modifier.  Why? see

https://blender.stackexchange.com/question/7358/python-performance-with-blender-operators

Hence you have already found what would have been my suggestion re answering this and manipulate the matrices directly and not rely on operators and a lot of diddling around to get context.


Remove pop-up window when running an operator

In the viewport menu just uncheck the option View → Adjust Last Operation and the popup no longer appears. You still can hit F9 to bring it back and adjust the last operation.


What are the options to extrude fingers from a low poly hand?

You can use inset, but I have only tried this for three fingered hands:

Individual inset (II) with both faces selected:

Select the faces inside the new inset, move them forward a bit, inset again:

Select the faces inside that inset and move them forward, extrude middle section:

Extrude fingers:


you will need to learn more about constraints in blender to do this. i would give a solid answer but im not good at constraints. i only know this because ive used constraints before to controll a metaball with an armature. there are probably lots of online tutorials about these. i also would comment this but i dont have enough reputation.


Hair Paricle System not rendering properly on plane

Make sure the use modifier stack checkbox is checked in the Emission section of Particle settings.


Keep divided edge straight when dragging it's end point

You may not be able to move other than the active one the way you want by dragging, but you might get closer to what you want to achieve, by using, in addition to the grab tool—G, the rotate tool—R, and the scale tool—S. If I were wanting to do what you want, I'd select all three vertices, with the grab tool, and move the active vertex to where you want it to end up. Then I'd use the rotate tool to adjust the location of the end vertex furthest from the active vertex, so that it is located on a line from the the new location of the active vertex and the location at which you want the furthest vertex to line up. Then, I'd use the scale too to actually set the location of the furthest vertex.

Note that in doing it this way, it is important to select the vertices in the correct order. First select the vertex furthest from the vertex you want to be the active vertex, then select any intermediate vertices, and finally select what you want to be the active vertex.

Also, if precise placement of the intermediate vertices is desired, I sometimes find it useful to count the number of intermediate vertices, delete them, place the two endpoints, create the edge, and then subdivide the edge into the required number of vertices. If there is other geometry incorporating those intermediate vertices, sometimes I don't delete them, but rather merge them into the intermediate vertices of the edge I created and subdivided.


How to access the 3D cursor with 'Local View' support?

Here's an example of 2 different ways to access the cursor.

Checking the space type and using only 3D views.

def context_cursor(context):
    scene = context.scene
    space = context.space_data

    cursor = (space if space and space.type == 'VIEW_3D'
              else scene).cursor_location
    return cursor

Using getattr with a fallback, however this isn't so reliable since it may return a 2D cursor for the image space (which probably isn't what you want).

# don't use this example!
def context_cursor(context):
    cursor = getattr(context.space_data, "cursor_location",
                     context.scene.cursor_location)
    return cursor

Note that when the 3D view isn't a Local View. context.space_data.cursor_location  will use the scene's cursor.


Editing Text Geometry Without Converting To Mesh

After a bit of experimentation my conclusion is that there's no direct way to add a particle system to a text object, or to use it for boolean operations.

However, you can make your life easier by using a single button to create and update a mesh version of your text, using the script below.

I tried making the mesh updates automatic by running the update function in the scene update event handlers, but this proved to be a bad idea, and caused memory usage to increase continuously every second.

The script will add a "Text" tab in the tools panel, where you have a button called "Update text mesh".

Pressing the button will generate a mesh version of your text, or update an existing one to any changes you made to your text object. It will also hide the text object so as to make it a bit easier to work. To update anything, just unhide the text object, make your changes, then press the button again.

To make things simple, the script assumes your text object's name is "Text". No other name will work, and if no such object appears, you will not even see the "Text" tab in the tools panel.

Copy and paste this to a text editor and press "Run Script", or install as an addon for more permanent usage.

bl_info = {
    "name"        : "Update text to mesh",
    "blender"     : (2, 75, 0),
    "version"     : (0, 0, 0, 1),
    "location"    : "3D View > Toolbox",
    "description" : "Update mesh copy of text object",
    "category"    : "Object"
}

import bpy

class update_text_mesh( bpy.types.Operator ):
    bl_idname      = 'object.update_text_mesh'
    bl_label       = 'Update text mesh'
    bl_options     = {'REGISTER', 'UNDO'}

    @classmethod
    def poll( self, context ): return 'Text' in context.scene.objects

    def generate_text_mesh( self, context ):
        if 'TextMesh' not in context.scene.objects:
             m = bpy.data.meshes.new_from_object(
                context.scene, context.scene.objects['Text'], True, 'RENDER', True, True
             )

             o = bpy.data.objects.new( 'TextMesh', m )
             context.scene.objects.link( o )

    def execute( self, context ):
        o = context.scene.objects['TextMesh']
        t = context.scene.objects['Text']

        t.hide = True
        o.location = t.location

        o.data = t.to_mesh( context.scene, True, 'RENDER', True, True )

        return {'FINISHED'}

class UpdateTextPanel( bpy.types.Panel ):
    bl_idname      = "UpdateTextPanel"
    bl_label       = "Text to Mesh Updater"
    bl_category    = "Text"
    bl_space_type  = 'VIEW_3D'
    bl_region_type = 'TOOLS'

    @classmethod
    def poll( self, context ): return 'Text' in context.scene.objects

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

        col.operator(
            'object.update_text_mesh',
            text = 'Update text mesh'
        )

def register():
    bpy.utils.register_module(__name__)

def unregister():
    bpy.utils.unregister_module(__name__)

if __name__ == "__main__":
    register()

EDITED: added a version that updates the mesh automatically with every frame change. Also requires the text object to be named "Text", but otherwise requires nothing else. Copy this script to the text editor and press "Run Script" to activate.

import bpy

def update_text( scene ):
    if 'TextMesh' not in scene.objects:
         m = bpy.data.meshes.new_from_object(
            scene, scene.objects['Text'], True, 'RENDER', True, True
         )

         o = bpy.data.objects.new( 'TextMesh', m )
         scene.objects.link( o )

    o = scene.objects['TextMesh']
    t = scene.objects['Text']

    t.hide = True
    o.location = t.location

    o.data = t.to_mesh( scene, True, 'RENDER', True, True )

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


X axis mirror is mirroring along X axis considering the origin point of the object (mesh or armature) is the center of the mirror:

As your armature seems to be centered around the world center, you can

Snap the 3D cursor to the center ShiftS then cursor to center
Then transform the origin point of your armature using the menu in object mode: object/transform/origin to 3D cursor

If the world center was not the center of your armature, you can use other snapping options to place it where needed.


How to get really defined plane changes?

Even though you are using subsurf and manually poly modelling, you can still use sculpt mode and its tools to shape/edit the mesh, without damaging the topology at all, so long as you don't enable DynTopo.

Maybe you've not ventured into 'hard surface modelling', but perhaps surprisingly, that's where I found the kind of techniques you seem to be looking for - i.e. high poly subsurfed machine shapes which have abrupt seams / holes with nice edging - you may find that's closely related to this question.

To create those crisp edges, you need to deliberately counteract the smoothness the subsurf is giving. So, first you need edgeloops running along the lines where you want that sharp delineation. Then, crucially, you need to sharpen that edge so it isn't rounded out by subsurf - either by adding another loop cut on either side of it, or by adding edge creasing.

Extra loop cuts: (pulled in close to define the turn) - are my favoured method. Typically you need two new loop cuts, one on either side of the corner loop, in order to 'pinch' it sharp enough. This does let you individually tweak either side of that corner individually, with edge slide (g,g). The downside is you do have more geometry to deal with, and 'less clear' topology in some sense.

Edge creasing: (shift-e, move cursor outward, click to confirm) can be more easily taken back out (and doesn't upset your other topology) but it doesn't offer as much control, and in order to create corners properly you often have to mess around setting crease amounts on loops that aren't really ones you'd want to crease.


How to manually achieve a motion blur effect on a object in the compositor?

Use the directional blur node.

Form the blender manual:

Iterations
Controls how may times the image is duplicated to create the blur effect. Higher values give smoother results.
Wrap
Wraps the image on the X and Y axis to fill in areas, that become transparent from the blur effect.
Center X, Y
Sets the position where the blur center is. This makes a difference if the angle, spin, and/or zoom are used.
Distance
How large the blur effect is.
Angle
Image is blurred at this angle from the center.
Spin
Rotates the image each iteration to create a spin effect, from the center point.
Zoom
Scales the image each iteration, creating the effect of a zoom.


Cannot assign material to an object or object face


OK, I answer my question. It was easy. Just have to make Material > Physics> friction to 0.000.


How do I stop vertex normals getting overwritten when I enter edit mode?

You want to use Mesh.normals_split_custom_set(normals).

Custom normals are always set per loop (i.e. face corners), but this utility set those per-vertex (it internally translates those 'vert normals' to loop ones).

Note that you have to set all normals for all vertices at once (basically because this is a rather heavy process, so setting it by vertex or loop would be inefficient), however you can set some normals to zero (0.0, 0.0, 0.0) vector to keep existing custom normals, or use default auto-computed ones.

Finally, you must be in Object mode currently, custom normals at BMesh level (Edit mode) are not yet supported really.

You can find some examples of that API in use in the new mesh_custom_normals_tools.py addon, as well as OBJ and FBX importers.


I've separated my front bumper and now put it in the same collection but both objects are giving different shading between them

Collections aren’t for managing materials.
Go to the Materials tab of the Properties editor instead:
Then, check that the same shader is set for both the hood and the other thing (select each in turn and observe what is displayed in their material slots).
For more information, please see the Materials information in the Blender Manual, particularly Material Assignment.


Short answer:

.x3d, an xml based format. Color can be either specified

per vertex of face
per face ( colorPerVertex='false' )

When imported via Blender's importer either method get converted to a per vertex  per face scheme for the vertex_color layer.
Stanford .PLY format. (vertex colours are shared over all faces that use the vertex, only way to get color-per-face with this format is  wasteful duplication of each vertex)

or

homegrown code: essentially this code. all you need to write is the part where you map the current polygon.index to a color, so all vertices of that loop are assigned the same colour.

Take a cube.

import bpy

indexed_colors = [
    (1,0,0), (1,1,0), (1,0,1),
    (0,0,1), (0,1,1), (0,1,0)]

obj = bpy.data.objects['Cube']
mesh = obj.data

# you probably know how to create the color layer..
if not mesh.vertex_colors:
    # creates one 'Col' by default
    obj.data.vertex_colors.new()

color_layer = mesh.vertex_colors['Col']

i = 0
for poly in mesh.polygons:
    # print(poly.loop_indices)
    color = indexed_colors[poly.index]
    for idx in poly.loop_indices:
        # loop = mesh.loops[idx]
        # v = loop.vertex_index
        color_layer.data[i].color = color[:3]
        i +=1

More elaboration on mesh generation is here: How to create a mesh programmatically, without bmesh?

from_pydata (docs link) :

mesh = bpy.data.meshes.new("mesh_name")
mesh.from_pydata(vertices=[], edges=[], faces=[])
mesh.update()

obj = bpy.data.objects.new("obj_name", mesh)

scene = bpy.context.scene
scene.objects.link(obj)

Showing vertex colors

For both methods you still need to configure the Object's material once imported, if you want it to show the vertex_color layer. This configuration is relatively painless but slightly different depending on which render engine you intend to use.

For Cycles you use a node based material, shown here

For Blender's Internal renderer the process is covered here


You seem to misunderstand how operators work. If there's supposed to be a props dialog, it is displayed before the operator execution. More specifically, in the invoke phase:

poll(cls, context) -> invoke(self, context, event) -> execute(self, context)

The poll classmethod of an operator is used to determine if the context allows the operator to run at all. If the context is not suitable (wrong area type, no object selected, ...), it needs to return False. You won't be able to run this operator until there's a valid context (not only from a button, but also spacebar menu and Python console). Operators in panels (=buttons) will be grayed out if polling fails.

What happens next depends on the execution context. If you run an operator from spacebar menu or by a button click, it will be usually INVOKE_DEFAULT and thus call invoke() of the operator. Notable about this method is, that an event object is passed to it. You need to return the result of wm.invoke_props_dialog(self) in invoke() to make the dialog work. It will open the dialog and wait for user input. If the user clicks outside the dialog, the operator will be aborted. If he/she clicks on OK, execute() will be called.

The execute() method of an operator contains the actual code of the operation. It is immediately executed if the execution context is DEFAULT_EXECUTE, which is the case for scripts and the Python console by default. There is usually no point in invoking the operator to get user input prior to the actual operation, and it's sometimes not even possible because of an incorrect context (an invocation from the Python console would run invoke() in the Python console, but a 3D View might be required). You would need to pass custom context along the execution context, like this:

bpy.ops.your.operator({'area': my_area}, 'INVOKE_DEFAULT')

Your operator does not define invoke(), therefore execute() is called immediately. The scene parameters are changed, but then you call the props dialog. It can't be used here and does crash for that reason. It is not supported to display a dialog after an action (operators supporting undo can display something in the redo panel, but that's about it).

class SceneSettings(bpy.types.Operator):

    bl_idname = "wm.scene_settings"
    bl_label = "Scene Settings Set Up"

    def invoke(self, context, event):
        wm = context.window_manager
        return wm.invoke_props_dialog(self, width=175, height=50)

    def execute(self, context):
        scene = context.scene
        scene.unit_settings.system = 'METRIC'
        scene.unit_settings.scale_length = 0.5
        return {'FINISHED'}

A more appropriate way to inform the user is to use self.report():

import bpy

class SceneSettings(bpy.types.Operator):

    bl_idname = "wm.scene_settings"
    bl_label = "Scene Settings Set Up"

    def execute(self, context):
        scene = context.scene
        scene.unit_settings.system = 'METRIC'
        scene.unit_settings.scale_length = 0.5
        self.report({'INFO'}, "Applied scene settings.")
        return {'FINISHED'}

def register():
    bpy.utils.register_module(__name__)

def unregister():
    bpy.utils.unregister_module(__name__)

if __name__ == "__main__":
    register()

Run this code in the Text Editor, then search for the operator in the 3D View spacebar menu.


Shadows on alpha channel PNG's and eevee

You have to change some of the material's options :

It works for me with Blend mode to alpha blend, and transparent shadow to clip.


Remove doubles isn't removing overlapping vertices

I didn't realize you needed to select vertices for remove doubles to have an effect. To remove doubles on the whole model, select everything with A first (you may need to press it twice if you have anything selected beforehand).


Python: Duplicating a group with animation

Make a copy of all objects in group "Group" and assign to a number of new groups, "NewGroup[.nnn]"  If the object in the new group has a parent or an armature modifier object in "Group" then it is assigned to the respective copy in the new group.

import bpy
scene = bpy.context.scene
number = 5 # make 5 group copies
group = bpy.data.groups.get("Group")
obs = [o for o in group.objects]
if group is not None:
    for g in range(number):
        group_objects = [o.copy() for o in bpy.data.groups['Group'].objects]
        new_group = bpy.data.groups.new("NewGroup")
        for o in group_objects:
            # parent
            if o.parent in obs:
                o.parent = group_objects[obs.index(o.parent)]
            # armature modifiers
            armature_mods = [m for m in o.modifiers if m.type == 'ARMATURE']
            for m in armature_mods:
                if m.object in obs:
                    m.object = group_objects[obs.index(m.object)]
            new_group.objects.link(o)
            scene.objects.link(o)

To check if an object is armature and change action, something like

    for o in group_objects:
        if o.type == 'ARMATURE':
            o.animation_data.action = someaction
        new_group.objects.link(o)


How to make playhead / transport / cursor return to start position in Blender?

Stop animation and move playhead to a frame you start from?
Use just Esc


How can I add an image to a texture in Cycles?

Idle Chit-chat

I don't see any reason why you should not be able to simply unwrap the eyes and add in your texture, as I said in my comment. I will, however, elaborate here.

Materials

I will use a sphere to represent the eye (smooth shading), and the following eye texture from Google (full size linked).

With the sphere selected, go to the Materials tab in the Properties panel. + New a material to the sphere. Go into the Node editor, and use the setup shown.

Now, go to the sphere in the 3D Viewport. Tab into edit mode, Numpad 1 to front view, and Numpad 5 to orthographic view. Press U and select Project from View (Bounds). Split the screen into a 3D Viewport and a UV Image Editor by dragging the marks in the top-right corner to the left. Make sure you are still in edit mode. Open the image of the eye through the toolbar at the bottom of the UV Image Editor. The orange should already be aligned over the eye.

Final Notes

For whatever reason, the eye did not show up right from the pure UV editing, so I had to add the Mapping node to the node setup.

Here is the .blend file:


blender sapling tree error; leaves rearrange to one direction

I had the same issue- however, if you go to Object>Apply>Make Instances Real you can convert the leaves to an editable mesh.


Troubleshooting Blender's Memory Use (Memory Statistics)

To fully investigate the problem you may need debugging tools (debug builds etc), but as a user, here are some things you can do.

The first thing to check on is Blenders memory statistics in the top header and compare this to what the operating system reports Blender is using, to see if the memory is being tracked by Blender or not.

If Blender's header doesn't show a large difference in memory then its possible there is a memory leak, or more likely - one of the 3rd party libraries Blender uses is holding onto memory.

If Blender also reports a jump in memory then you can use an operator which reports details about memory use.

Reporting Memory Use

Start Blender in a terminal: See manual for instructions.

Before rendering run the operator "Memory Statistics" from the space-bar search menu. Copy and paste this text into a file.

Render the scene and re-run "Memory Statistics" copying the output into a different file.

The text will look like this:

total memory len: 9.319 MB
peak memory len: 18.868 MB
slop memory len: 5.043 MB
 ITEMS TOTAL-MiB AVERAGE-KiB TYPE
  1993 (   3.051     1.568) BLI_Mempool Chunk
   210 (   0.972     4.740) Data from ME
  2544 (   0.612     0.246) PropertyRNA
    20 (   0.584    29.922) Chunk buffer
  2296 (   0.438     0.195) StructRNA
  3025 (   0.369     0.125) IDProperty array dup
  2209 (   0.322     0.149) dupli_alloc
  1723 (   0.302     0.180) keymap entry

--- snip ---

Now you can compare the results, it may help to use a visual diff tool. search online - many free applications exist.

There may be a perfectly logical reason that Blender is using more memory but if not, then best report a bug on the tracker so a developer can investigate,


How to automatically join stripped pieces of video?

Keep the cursor (the green vertical line) on the left hand side, then ShiftBackspace to remove all gaps. (If pressing Backspace once, it will only remove the first gap to the right of the current frame, which can be operate continously. This operation can be found at Strip > Remove Gaps)

P.S.:

Here, Gap means frame durations that don't hold any strips. So, in case of multiple channels, you may want to first select strips on particular channel, then CtrlG to make them as a temporary meta strip, then Tab into that Meta strip, do what you want to do. Then Tab again to exit meta group, AltG to ungroup it.


How to disable or enable a constraint of a bone, by a rotation of another bone?

That can be this kind of setting:

Here three bones: one parent and two children.
Bone.002 has a constraint: track to an empty.
The constraint activation has de driver:
var is based on Bone.001 and its "W" rotation in quaternion mode and local space.
The driver expression is to test if "W" is below 1. In this case that mutes the constraint.
The eye corresponds to a "mute" property, so a True value to mute.

Complement
If you want the constraint to be "mute forever", you can use a little script.
Add a custom prop to the constraint target (the empty here), named "prop" and set to 0 by default.

Then execute this script:
import bpy

def lock_constraint(self,rotation):

    self.target["prop"] += abs(1 - rotation)

    return self.target["prop"] > 0

bpy.app.driver_namespace["lock_constraint"] = lock_constraint

"lock_constraint" will be known in driver space, so that you can use it in the driver:

As "prop" can only grow, once the other bone is rotated the constraint will stay mute.


Here's one way:

Scale a cube to a shape like in the first picture. Then cut a loop using the Loop Cut and Slide tool. (Picture 2.) Change the selection mode to Faces and select the end Face shown in picture 3. Press E to extrude, then drag away from the face to "pull out" a new section. Now you can use your bevel tool on the shape and there'll be no gap.


Reliable way to find out the required context for an operator?

Asking for a way to find the context for all possible operators that need such an override is at the same time ignoring all the responses to people looking for their specific override for their needs.

As is often the case with 'context is incorrect', there is a solution that's much simpler and (more) logical than the potential workaround using context overrides. While most operators can take an override context, you will invariably (if you dig deep enough) find several that can't. You will also find operators which are the only way to achieve some goal.

For all other cases where there's a better way to do it without the operator in question, you simply use the lower level bpy code. Ask, we will always give an answer, or dig using the Info console and track the changes in bpy.data to see what got added and which parameters are adjusted after a manual Operator invoke (ie you click a button, and that calls the operator in question).

(Sometimes a context override is the only way, but not this time)

Make a new world material.

>>> m = bpy.data.worlds.new('amazon')
>>> m.use_nodes = True
>>> m.node_tree
bpy.data.node_groups['Shader Nodetree']

>>> m.node_tree.nodes['Background'].color
Color((0.608, 0.608, 0.608))

# setting current scene world
>>> bpy.context.scene.world = bpy.data.worlds['amazon']


Adjacent faces can have different plain colors, and a vertex can have a different color for each face it participates to.

In 2.79, it's possible to select the faces in Vertex Paint mode, and use 'Set Vertex Colors' (Header > Paint menu or Shift-K).

Likely the integration in Blender of a separate script that was used before.

Edit:

To view colors in the 3D editor when 'Material' display mode is selected, the option 'Vertex Color Paint' must be enabled for the material used (Properties editor > Material tab > Options panel).
The 'Face Selection Masking for Painting' button must be down in the 3D Editor header (Vertex Paint mode).


Need to modernize my scripting, this bpy based script from 2.77 doesn't run in 2.92 so I can't post my main question yet

The answer to your question may be found in this Q&A. Since 2.8, it seems that objects should be linked to collections instead of scenes.
old:
bpy.context.scene.objects.link(ob)

new:
bpy.context.scene.collection.objects.link(ob)


curve intersection with volume in animation nodes

Naively intersecting lines with planes could be problematic as the Intersect Line Plane node, or the Python function behind it, considers the plane to be infinite. Therefore, as a second step, you would have to check if the intersection really is on the polygon.

I suggest using the BVHTree > Ray Cast node instead.

With the Evaluate Spline node (for Aimation Nodes v2.1; Get Spline Samples for AN v2.0) and two different slices of the node's Locations list – vectors[:-1] and vectors[1:] – I create small line segments along the spline.

start vector and end vector of these segments (as iterators) as well as the BVH Tree of the object (as parameter) are fed into a loop. Within this loop I call Ray Cast with a maximum distance of the segments' lengths and a minimum distance of zero. (The minimum distance by default is 0.001 or something which might result in some missed intersections.)

With the Condition input of the loop's Vector List output I collect all location vectors of ray casts that resulted in a hit.

The Ray Cast node also has a Normal output that lets you align objects on the face where there is an intersection – e.g. by using the Direction to Rotation node. If you also want to distinguish entries into and exits from the volume then you can calculate the angles between the normal and the segment and check if it's smaller or larger than 90°.


Going by the image alone,  it seems like the nails might be the problem. I have seen figures with separate nail meshes and that causes problems with AW.

-snip-

One bit of unrelated advice, if this model is to be used in Blender, renaming your bones and adding .L and .R (left and right) at the end will greatly speed up your work. "Forearm.R" reads a lot faster than "Bone 50" and allows you acess to built-in functions like Paste Mirrored Pose

Edit

The next item on your checklist is to go into Weight Paint Mode and check if the messed up parts are (somehow) assigned to another bone.


How can I turn the frames rendered by blender in an animation into a video?

Open Blender and go to the video sequence editor view.
Add->Image. Select to the folder with all you images and select them with a (all), b (box select), or shift+click (single select). Press "Add Image Strip"
You image sequence will be added as strip
Set start and end frame according to the strip's size.
Go back to the default view.
In the rendering tab of the Properties panel, make sure that "Sequencer" is checked in "Post Processing".
In "Output", set the wished video format, compression and out file
Render the animation (Ctrl+F12)


How do I make my mirrored object work independently?

Apply the modifier using Apply button, that is located below the modifier name. Then you will be able to edit both sides separately.


How to animate a camera to follow an object

Create an Empty and parent the camera to that instead of the actual object. Then add a Copy Location constraint to the Empty to copy the location of the object, ignoring the rotation. To get a delay between the object and the camera (so the camera lags behind the motion) you can use the Slow Parent option when parenting the camera to the Empty.


Blender Material Color in Mitsuba (or any other) Shader

You can read the mat color from Blender Internal material like so:

# from material
mat = bpy.data.materials['Material_Name']
color = mat.diffuse_color

# or from object
ob = bpy.context.active_object
if len(ob.data.materials):
    # get 1st material slots material
    mat = ob.data.materials[0]
else:
    # no slots
    print("No Material")
    mat = None
if mat:
    color = mat.diffuse_color

To change LuxRenders material diffuse color:

mat.luxrender_material.luxrender_mat_matte.Kd_color = color

Mitsuba:

mat.mitsuba_material.mitsuba_bsdf_diffuse.reflectance_color = color

In Yafaray there is no need to change anything, it will use:

mat.diffuse_color


you need to RENDER your video - use the "properties" panel for this.

PS.- don't forget to check the "sequencer" and uncheck the "compositor" under "post processing".


I could use some help finding the scripting tab

All the “tabs” are at the top of the window in the default layout. The scripting tab is farthest to the right-hand side, so you may need to scroll if your monitor is small.
For more information on Blender’s UI, check out Blender’s Documentation


How to get the name of the object from its coordinates (in object mode)?

All objects with origin within a tolerance of cursor.

Simple script to make a list of all objects whose origin is within a tolerance TOL of the scene.cursor_location.

import bpy

from bpy import context
scene = context.scene

TOL = 0.1 # get all objects within 0.1 bu of loc
#use cursor for location
loc = scene.cursor_location

obs_in_location = [o for o in scene.objects
        if (o.matrix_world.translation - loc).length < TOL]

print(len(obs_in_location), " at ", loc)
if len(obs_in_location):
    for o in obs_in_location:
        print("\t", o.name)


Getting started with animation accelartion?

Perhaps this will help you get the acceleration you want:

Blender Basic Animation - Using the Graph Editor and Interpolation Modes

https://www.youtube.com/watch?v=R9gCHhJOjlQ

In this intro, inascott888 positions a cube and keyframes location at the start frame, he then goes to the end frame, repositions the cube and keyframes location there. In the graph editor window, he then uses the bezier handles to change the shape of the transition curve, and shows how this can be used to effect acceleration of the cube (when the animation is played back), that is by making a very slow start, but increasingly steep curve up.


Can I use the API to select an edge or face by length / area?

Using the bmesh module

This is quite simple with the bmesh module.  Test script selects all faces with area > 10 and all edges with lengths > 10.  Remember these are local coordinates.

import bpy
import bmesh
context = bpy.context
ob = context.object
me = ob.data
bm = bmesh.from_edit_mesh(me)

# select faces with area > 10

for f in bm.faces:
    f.select = f.calc_area() > 10

# edges length > 10

for e in bm.edges:
    e.select = e.calc_length() > 10


Display object textured regardless of viewport display mode

As you use the unwrapped plane with image texture (or image imported with Images As Planes addon) to show as the reference, it will lose effects from the Solid shading mode because the plane is a mesh and will behave exactly the same as the one you're modeling. So while changing shading mode to Wireframe no image will be visible.

Use background images instead; they don't depend on shading mode. Note that they will appear only in preset orthographic views, however those should be used for precision modeling anyway.
It's also possible to use an  empty of Image type (Shift+A > Empty > Image) which can be useful as reference image. It doesn't depend neither on shading modes nor on ortho views.


go to view -> measureit tools -> precision

UPDATE: Measure

Move one end with cursor, then hold CTRL and let go on one edge of default cube. Same to other end.
Result:


How to make sharp triangle hole using subdivision surface modifier?

I think this could be a good start :

Another thing would be to do as much as you can from a bevel modifier with angle detection, weights and/or vertex groups. It has the advantage of being non-destructive and faster.


Copy light location in relation to object

Something along these lines may work. This version assumes that your lamp-posts are instances, and the only transforms responsible for putting them where they are, are their own, without the interference of parenting or constraints. You may need to arrange that, by, for instance, clearing their parenting, keeping their transforms.

Make a backup of your file
Alt D create an instance of one of your lamp-posts
(Probably, you'll want to isolate it / hide everything else, so you can see what you're doing)
Ctrl A, or via the Header > Object menu, > Clear all its transforms
Position your light where you would like it, relative to the lamp-post
M Add the light and the lamp-post to a new collection, called, say, 'Practical'
With Shift C the 3D cursor at World 0, Shift A add a new Collection Instance to the scene, based on the new collection.
Unhide your original lamp-posts, select them, and then your
'Practical' Collection Instance, so it is the active object.

Now we want to make a copy of the Collection Instance in the place of all the existing lamp-posts. I'm surprised there isn't an operator / add-on to do this without scripting, but unless someone finds one for us, here goes.. run this script:
import bpy

C = bpy.context
D = bpy.data

src = C.active_object
src.select_set(False)
sel = C.selected_objects

cp_col  = D.collections.new('Practicals')
C.scene.collection.children.link(cp_col)

for ob in sel:
    cp = src.copy()
    cp.matrix_world = ob.matrix_world
    cp_col.objects.link(cp)

it should create the copies in place, and put them in a new collection called 'Practicals'. (plural)
Hopefully, you should now be able to hide the original lamp-posts, and see them replaced with practical, light-bearing instances. And be left in a state from which you can change all the lights / do whatever you like, by editing the objects in the 'Practical' collection from which the Collection Instance is derived.


Growing Text -   Rendered with OpenGL in Blender 2.77a -

Edit dated 3rd Dec. 2018 -

Whilst as you point out this is a trifle complex for your needs, I was remiss in the original answer below, not producing the final effect shown in your Youtube video link.

The original answer deals primarily with a method of 'box masking' to simulate mesh growth without disturbing that mesh and consequently avoiding the tendency to end up with ugly surface streaks.

This added section deals with the final visual effect you were hoping to achieve, albeit seeking a simpler solution.

For those who have watched the video and may be interested in how it might be achieved in Blender, most steps were as described below.

Viz - This new text was also extruded, converted to mesh, and parted to be individual letters, although I don't think the last step was entirely necessary.

The letters' forward and rear faces were removed to another layer so the originals end up as hollow shells.  (much as a cylinder without end caps)

These were 'solidified' with that modifier, ready for their removed faces in the other layer to be extruded, coloured black, and used to fill in the hollowed letters.

As for the growth animation of their white exterior, the method described below in the original answer was used again here.

-==============-

Original post -

This isn't exactly "Noob" territory but it does pretty much 'Write" the text as requested.

Rather than interfere with the text's mesh, I find it less troublesome to leave the text as is and wrap each letter in a similarly shaped 3D "invisibility cloak". (mask)

The mask's end-cap is then progressively moved back with some shape-shifting method made to follow a letter's contours, revealing that part of the mesh that progressively ends up outside the mask.

Mask Z fighting (with it's own surfaces) and shading distortions aren't of concern because of it's invisibility.

OpenGL masking is used here because they can be discriminatory and 3D meshed (bevelled) two essential elements for this effect.

To this end the text is converted to mesh and letters separated to become individual objects.

Within each, a "Curve Path" shaped the same as the letter is added and that bevelled using a square plane curve.  (The plane has no face and converted to a curve with ALT-C)

Letter segments or sections are therefore wrapped in a rectangular 'pipe' which is much the same shape as the letter it's concealing.  All of the masks are assigned the same Material Slot.
(For masking - Diffuse at half, Material --> Transparency --> Alpha set to 0.008, and both Speculars set to zero)

Because these 'pipes' are left as curve-paths, their start  "Resolution" slider in the path's Geometry tab, can be keyframed to roll back the pipe's end-cap and progressively reveal letters as though being newly formed or written.

With letters in such close proximity and when viewed at an angle, a mask can end up cutting holes in an adjacent and previously revealed letter.

Some knowledge therefore as to what makes these masks tick is going to be more than a little helpful, particularly in the way their discrimination works as related to the 'age' of objects to be masked.  It's what makes them so useful and allows letters already revealed to remain unscathed by 'younger' masks.

Read up on this here ->

How to put a mask into 3d space

If you prefer to use Blender's Internal Render then it's own layer masking or perhaps nodes will have to be employed, along with any post production necessary.  Similarly with Chroma Key.


Use Snap To. Remove the diagonal edge after you positioned the red hexagon on it.


How to bevel a vertex corner that is between a circle and straight?

This pretty much exactly what the Spin tool is for ..

In an orthogonal view of the circular arc you want to create, put the 3D cursor at the center of the new part-circle, select the vertex you want to extrude around it, and invoke the tool.

In your case, you might ShiftS snap the cursor to the two selected endpoints of the bevel, so it's exactly between them.

You can adjust the center during the operation by using the arrowheads, and the number of vertices generated in the sweep using the tool's Adjust Last Operation panel


Achieve Damascus steel style with Cycles

Final

Node setup

Setup is fairly easy to understand. We will use only Wave Texture with Distortion controlled by vector driven by Color Ramp. Then we will use output of this for Roughness in Principled BSDF.

First Color Ramp (left one) can be used to control how many stripes should be on bottom of the mesh and blend between stripes and pattern. Black is straight, white distorted. Second one controls Roughness value and here colors are important. Black is shiny, white is matte.

Output of the texture

Final with UV mapping and mask for blade


You can extrude from  a cut in the ceiling rather than trying to project the wall to it.

ShiftD duplicate off the top surface of your wall, and make a clean profile of it using X limited dissolve, but not so harshly as to damage the curvature.

From orthographic Z, Header Menu > Mesh > Knife Project the profile
onto the ceiling, checking 'Cut Through'

With Snap set to Vertex and Active, and a convenient vertex active, EZ Extrude a duplicate of the resulting selection in the ceiling downwards in 2 stages, snapping on the way.. (Take care not to create internal faces)

SZ0 scale the bottom of the wall to 0 about its median, AltM > By Distance merge out redundant vertices.. You can tidy up again with Limited Dissolve.)


How can I apply decimate modifier to multple files and save them as a different file automatically?

Ok, I wrote a script for my purpose. Maybe it will be helpful for somebody.

Here is the python script that decimates model and save as a new file.
You can change iteration and decimateRatio

import bpy
import os

##Cleans all decimate modifiers
def cleanAllDecimateModifiers(obj):
    for m in obj.modifiers:
        if(m.type=="DECIMATE"):
#           print("Removing modifier ")
            obj.modifiers.remove(modifier=m)

numberOfIteration=2
decimateRatio=0.3
modifierName='DecimateMod'

for i in range(0,numberOfIteration):
    objectList=bpy.data.objects
    for obj in objectList:
        if(obj.type=="MESH"):

            cleanAllDecimateModifiers(obj)

            modifier=obj.modifiers.new(modifierName,'DECIMATE')
            modifier.ratio=1-decimateRatio*(i+1)
            modifier.use_collapse_triangulate=True

    fileName=bpy.data.filepath
    fileName=os.path.splitext(fileName)[0]

    #Trim decimate version of file name
    indexOf_=fileName.rfind('_')
    if(indexOf_!=-1 and fileName[indexOf_]+fileName[indexOf_+1]=="_d"):
        fileName=fileName.split("_d")[0]

    fileName='{}{}{}{}'.format(fileName, "_d",str(i+2),".blend")

    bpy.ops.wm.save_as_mainfile(filepath=fileName)

Also you can run this script with a bash command for all child files having .blend extension.

find . -name '*.blend' -exec blender {} --background --python myScript.py \;

Thanks to Attie for bash command


Blender How can I extrude a cylinder outward

This is a great case for spin modeling. There are two way to do this, you can use the screw modifier (I prefer this way); or you can use the spin tool in edit mode.
I will just describe the process to use the modifier, the modeling it exactly the same for either method; however using the spin tool is destructive (and a little harder to set up).

Start by creating the outline of the shape. This could be done using curves or a mesh object. I used a mesh object, and just extruded a few vertices to make half the shape. Take note of where the object origin is, the origin (highlighted in red) is where the modifier, by default, spins around.

All that is left to do is add the modifier. The default values work very well, provided you modeled the object around the Z axis. The only setting you need to be sure to turn on is Calc Order. That setting makes the normals consistent (sometimes you will then need to then check Flip because they will be backwards).


Efficient tool for making tree-like shapes

Skin Modifier

add a new mesh object, go to edit mode, delete all vertices
add Skin modifier
in edit mode with Ctrl mouse click create a new vertex
now you can start draw branch by another click with Ctrl or press E (extrude)
change thickness of vertex by cmd+A on mac (Ctrl+A on pc?)

Notes: you can change size (thickness) also

from 3Dview > Properties panel (N) > Vertex Data > Radius X/Y
or check or reasign shortcut in User Pref >  Keymap > search Skin Resize

Grease Pencil

You can use Annotation or Grease Pencil object to draw branch and convert to mesh and use Skin modifier. But it is probably more work. Like with Annotate tool ** you will have to Convert to GP, than Convert GP to Curve, than Convert to Mesh. Using default Annotate tool generates smooth but vertex intensive line that doesn't fits to Skin modifier later (you would have to use Simplify add-on in step Convert GP to Curve ...


How do I deselect one object between other objects?

Surely this will not be so easy if many objects are in selection conflict, but, ShiftAltClick (the click button here may depend on your configuration), brings a menu that allows to choose the wanted object:

PS: was in hope the object order in the menu was relative to the ray cast distance, but this is not the case.


Can modifiers be called in the Game Engine?

While certain mesh modifiers like subdiv and array modifiers works* in the game engine, modifiers cannot be called while you are in the game engine. (i.e. you cannot create an explode or array modifier using actuators)

*Actually, I would suggest baking the mesh modifiers anyway before you run the game. Otherwise you might run into physics bounding box issues.


It turns out my issue was with some hidden geometry (the original sculpt).
The AO map came out looking as expected after this was hidden from the renderer.

Sorry if anyone was in the process of answering.


I've created a procedurally animated Rorschach test but I don't know how to stop it from being cut off on the edges?

The key to prevent the texture from cutting off at the edges is to reduce its density towards the edges. The simplest way of achieving this is to use the Distance (Vector Math node) from the centre to adjust the output from the Musgrave texture. By using some maths functions we can change how quickly and how sharply the adjustment falls off as the point moves away from the centre.
I've replicated your nodes and added the ones highlighted to apply a factor based on the distance :

So the Distance from the origin is first passed through a Power node. The higher the power, the faster the falloff (so the sharper the edge). The multiply node allows the 'strength' to be adjusted and this is combined with the output of the Musgrave.
This produces the following result :


This is likely a configuration problem with your graphics driver.

Disable Anti-Aliasing (or all kind of filters that blur the output, Super Sampling, ...) in the driver, so that it does't override Blender's own settings.

https://developer.blender.org/T24059


Reducing noise in interior Scenes caused by many lights using Cycles

I guess, that you know most of the common tricks. But here are some tricks that I often use:

Make a hole into the building outside of the cameras view of field
Increase the resolution, decrease the sample rate and resize the image afterwards. This will make the image softer, but if you double the image size, and render with a low sample rate and resize the image afterwards, the noise is evened out (I was able to render an interior architectural scene with only 5 samples)
Enable a small amount of global illumination and increase the shadows afterwards with the Compositor


(blend example file)
   ==>https://drive.google.com/open?id=1yny39dZCLL8pv886YI0fmaarocPItcwh<==

in this example you can drift(go sideways) get drift score(depending on drift speed) very simple actually. Feel free to use this example .


The setup using the alphaover node and transparent rendering is a good idea, try going back to that and make the following changes: First go to your Blur renderlayer (in the renderlayer panel) and turn on the Environment pass,

then go to the compositor and add a second alphaover node. Plug the output of the first alphaover node into the bottom input of the second, then plug the Environment pass from the renderlayer into the other image input and pipe the alphaover output to the composite node.


changing filepath and creating directory in python

Python has useful functions built-in to handle common pathname manipulations.

import os
desired_path = os.path.join(some_existing_path, "some_folder", "some_file_name.ext")

See os.path, and see shutils for high-level file operations.

to test if a directory exists, and make it when not found):

if not os.path.exists(directory_to_test):
    os.makedirs(directory_to_test)


Cycles - CUDA CPU Extremely Slow When Combined With GPU

This is normal. It is common for GPUs to be a lot faster at rendering than CPUs and in this case GTX 1070 is definitely a few times faster than i7(?) 6700K so for renders that take seconds, this is to be expected. You would probably benefit from combining GPU and CPU on longer renders(think minutes and hours, not seconds), but 20 seconds is short enough time that the render would get stuck on slower CPU tiles at the end when the GPU has nothing else to do. Managing the render process on a few devices probably also takes extra time. You could try using really small tiles and see if that helps, if not, just use the GPU alone.


How to make a brush (alpha image) using Cycles

First Render out the image. The lights and materials don't matter.

In the compositor add a normalize node and drop the z pass through that. This will make the lowest value 0, and the highest 1 while mapping the rest through that.

Then with the RGB Curves node, switch the handles so that they are inverted (left being on the top, and right on the bottom), and add a handle in the middle and adjust it until you're happy with the result.

The finished node setup should look something like that


2.80 Make the data single user. Like pressing U key in blender 2.79

From menu Object - Relations - Make single user


Got it!

The problem was I had all the planets Parented to an empty at the sun's position.

Once I unparented the planets, I was able to Apply the change and have it stick.


Is there a convenient way to "collapse" the view of multiple, possibly nested, collections in the outliner?

Hover your mouse in the outliner and hit Shift + A to expand everything, do it again to collapse everything.


I tried changing "piston" constraint settings a bit, setting

world <==> world
adding X as contraint axis

then I animated the train rotation, to check and it seems to work now,

see the attached file. (btw, next time please use the same service I used, here http://blend-exchange.giantcowfilms.com/, it helps preserving example files for others in future).

edit:
as you say in commenmts, there were other issues on different train's movements.

I tried and probably you just need to add also Z axis to the piston contraint, and then ALSO add a location contraint for piston on Z, limiting max Z to its "deafult" Z location in local space, like this:

and it seems to behave well (hopefully) on all desired train movements...


How to deform a plane according to the shape of other objects

If the base terrain plane is deformed by a displace modifier why not just give the second plane the same modifier stack?

If I understand correctly this is the effect you are aiming for, kind of like a manta-ray wavy hover motion

Just add a second plane above the first one, subdivide it accordingly, and link the modifiers to the original one. Select new plane > select terrain > Ctrl + L Modifiers.

Make sure both objects have the same displace modifier or most importantly share the same displace texture and with the both Texture Coordinates set to Global


Assign a shortcut to "Limit selection to visible" toggle

This is not available by default in preferences but you can add it manually. Open your user preferences and go to the Input tab, toggle 3D View and then Mesh.

Scroll to the bottom where you will see a button that says Add new. For the identifier, enter wm.context_toggle and for the Context Attributes enter space_data.use_occlude_geometry, next assign a key combination to it and save your user settings.


This probably isn't the answer you are looking for, but you could always render out using BI at the end of production, with a 'shadeless' white material applied in the render-layer settings as the material override (applies to all objects when rendered) Also, set the world colour as 100% white as well.

render result

This would then allow you to composite the rendered image or sequence of images ontop of your cycles render, you can use a colour mix -> multiply so that only the black 'edge' is applied to the cycles render.


Non-destructive way would be to use Subdivision Surface modifer along with Cast modifier set to Sphere > Factor > 1.


welp, apparently I had a stray vertice a million miles in the sky. I was able to pinpoint it and delete it.


It must be a problem of flipped normals, some softwares only display the normal side of the face. select your object and in Edit mode press ShiftN.


How to remove extra materials from a mesh if the mesh has more than 1 material?

You can set the index of the list to 1, iterate through the upcoming slots, call and override the context of material_slot_remove(). Demo on how to remove all slots > 0:
for obj in bpy.context.selected_editable_objects:
    obj.active_material_index = 1
    for i in range(1, len(obj.material_slots)):
        bpy.ops.object.material_slot_remove({'object': obj})


If you're doing scripting with python checkout the documentation

Mesh attributes can be found in the Bmesh api


Why Is My Transparency Shader Not Working

It looks to me that everything works normally, but you have a second material on those faces that doesn't turn transparent (and those faces just happen to form the observed weird shapes due to your mesh).

So to solve this you can either make all faces have the same material or have a transparency node and keyframes for each of those materials.

(If this answer does not work for you, please provide a .blend since other problems might show the same symptoms)

Happy Blending! :)


How do I "Re-Randomize" Particle Emmission?

You can change the "seed" value next to the emitter type selection:


Conventionally, (a bit like grabbing/releasing weapons, etc, if you want to look up other examples,) set up two or more Empties with the desired motion and timings for the car. Each empty can have its own Follow Path constraint. Ensure they are located and rotated similarly at hand-over points.
Give the car a Child Of constraint for each Empty, and for an instantaneous hand-over from one Empty to another, keyframe the Influences of the appropriate Child Of constraints to 0 and 1 respectively, in consecutive frames.
(Use the Set Inverse switches to ensure the car is all lined up, ready for hand-over)

If you need further control over rotations, moves, you can add another layer of indirection / hierarchy between the constrained Empties and the car: then the car would be constrained to be a grandchild of the path-following Empties.


Cycles noise reduction introduced in recently released Blender 2.79 version works exclusively for rendered images because it specifically uses information from the 3D scene to make an educated approximation, as far as I know.

As such it would not work for random video files since no 3D information would be available in most situations

Everything else that uses the Compositor and/or Video Sequence Editor should be able to work as well for externally obtained footage, as long as it does not rely on data obtained from 3D rendering, like render passes, layers, or any other buffered data from a virtual model.

The mentioned addon seems to be used in the node editor as a node group based approach, so in theory it should work with any externally obtained footage.

Just use an Shift+A > Input > Image or Input > Movie clip to insert your video sequence and use the desired nodes as recommended.

Disclaimer: Whether the algorithms or processes used in those nodes will work correctly or satisfyingly in your particular footage or specific type of noise is unknown.

Those nodes were made specifically with Raytracer bound noise/fireflies in mind, that have particularly very high peaks, so it may not work well of the low intensity noise or your particular case.


How do I batch render multiple scenes with animation settings?

You can use a file output node in the compositor to save the renders from each scene to individual files. While multiple render layer nodes can trigger multiple scenes to be rendered, blender doesn't save each scene to file unless you connect it to a file output node.

For each render layer node a different scene can be selected as well as a render layer from that scene. Any number of inputs can be added to the file output node with each input having different filename settings and can use a different image format if desired.

The base path and the file subpath will be combined for each connection, a file subpath with a / will create subdirectories in the base path for the connection. If you want to use multiple base paths then you can add multiple file output nodes.

Now when you render this scene, the scene listed in each render layer will also get rendered and the connections to the file output node will all be saved to file.

As you have already setup multiple scenes you can use a script to create the master scene for rendering. This script should do most of the work.


You are in Solid mode (Blender will automatically switch back to Solid when you'll start), switch to Material or Rendered mode by clicking on the icons on the top right or press Z for the pie menu.


How to switch to orthographic in blender 2.8?

It's not available in EEVEE. You have to switch to cycles render for ortho camera.


In the snap settings, activate the setting "Absolute Grid Snap". It snaps to a whole number on the grid regardless of where it started from. So if you start dragging from 2.346, it will snap to exactly 2.


1 step: add a keyframe on your scene

2 step: enable the "Embed animation" checkbox


Here's a python script that selects all objects with animation data or that have materials with animation data:

import bpy

animated_objs = []

for material in bpy.data.materials:
    if material.animation_data:
        for obj in bpy.data.objects:
            for slot in obj.material_slots:
                if slot.material == material:
                    animated_objs.append(obj)

for obj in bpy.data.objects:
    if obj.animation_data:
        animated_objs.append(obj)

for obj in animated_objs:
    obj.select = True


I want to move vertices in an accurate way but the 3D Manipulator is missing

Looks like you set the 3d cursor as your pivot point.

I can't see the 3d Cursor is not to be see in your view. The 3d manipulator is in the same place as the 3d cursor, therefore is it offscreen as well.

Change the pivot point to any other setting (like median point) to the 3D Cursor show at the current selection.


Get angle of a face relative to object origin?

The way to get the information I want per-face out is to run:
euler_rotation = matrix_rotate.to_euler()
euler_rotation

for the Euler rotation, and
matrix_translation

for the translation, taking only the magnitude portion of the matrix's x, y, and z rows. This is as a Euler transformation.  To do it as a Quaternion, I can simply run:
my_quaternion = matrix_translation @ matrix_rotate.to_4x4()
my_quaternion

and get a 4-number output that I believe includes both position and rotation transformations for the joint.


Get Object/Material Index of Completely Transparent Objects

In Cycles you can adjust the Alpha Threshold for the Render Layer to adjust how layers are affected by transparency. Setting the Alpha Threshold to 0.000 will result in all objects - even those that are completely transparent - affecting the Index passes (as well as the Z, Normal, UV, and Vector passes).


Moving the Properties Shelf to the right of the UI

Under blender 2.79 and previous there used to be a hot key for this that has been removed from 2.8 series.
The operator is called Flip Region and it switches the side a region (like the tool shelf or the properties sidebar) is docked to.
In 2.79 you could toggle it by hitting F5 while hovering the relevant area, in 2.8# you have to call it from the menu.
The nuance is your mouse cursor must be hovering the region you want to affect when invoked, so move your mouse over to the properties region, press Space bar or F3 (depending on your key config) type Flip Region and execute while the cursor is hovering the relevant sidebar.

For 2.9 Series.
You need to have Developer Extras on. Then you can follow the 2.8 series directions.

Top left of Blender's window, click Edit for a dropdown menu.
Then drop down to click Preferences. You'll get a Popup Window.
From the Popup Window, be sure to click Interface to open up Interface preferences.
Expand the Display panel.
Then turn on Developer Extras under the expanded Display panel.

You can now follow the 2.8 series instructions. Go back up to the top of this answer for further instructions.
No major UI changes have happened in the search menu in 2.90


How do I remove gaps between two wavefront OBJ layers?

The imported OBJ files were projected to the British National Grid (EPSG:27700) and as a result they were located very far from the origin. So, selecting the layer and setting Origin to Geometry and then updating the Location to (0,0,0) results in the buildings sitting flush on the surface.

Thanks to suggestions from batFINGER


Is it possible to control where texture is applied with weight paint or similar

Masks can be used to control where you want to have cracks. It's similar to weight paint but used in the shader editor.
Create one or two grey-value images (masks) and a MixRGB (or Mix Shader). Use the image texture as Fac value for the mix node.
Depending on your shader node setup you might need a Math mode (Multiply operation) to control the color of the cracks and the base color. Alternatively, you can different materials and transparency. The mask then controls the transparency.
Example:
Default cube with cracks


I can't get a SpaceView3D draw callback to work

All possible callbacks

Prints to console when callbacks fired

So much info in the python console, autocomplete on draw handler add. Will see that args is a tuple of arguments passed to the callback method.  Error in question was passing 1 arg to a method with none.  Will show up in system console as an error.

>>> bpy.types.SpaceView3D.draw_handler_add(
draw_handler_add(callback, args, region_type, draw_type)
.. method:: draw_handler_add(callback, args, region_type, draw_type)
Add a new draw handler to this space type.
It will be called every time the specified region in the space type will be drawn.
Note: All arguments are positional only for now.
:param callback:
   A function that will be called when the region is drawn.
   It gets the specified arguments as input.
:type callback: function
:param args: Arguments that will be passed to the callback.
:type args: tuple
:param region_type: The region type the callback draws in; usually ``WINDOW``. (:class:`bpy.types.Region.type`)
:type region_type: str
:param draw_type: Usually ``POST_PIXEL`` for 2D drawing and ``POST_VIEW`` for 3D drawing. In some cases ``PRE_VIEW`` can be used. ``BACKDROP`` can be used for backdrops in the node editor.
:type draw_type: str
:return: Handler that can be removed later on.
:rtype: object

Attempt to add every draw call back possible.  Has to be a redraw of the type specified to fire the callback.  I doesn't relentlessly fire.

import bpy
from bpy.types import SpaceView3D, Region
class DrawClass:
    def __init__(self, context):
        print("INIT")
        for rt in  Region.bl_rna.properties['type'].enum_items.keys():
            for d in ('POST_PIXEL', 'POST_VIEW', 'PRE_VIEW', 'BACKDROP'):

                try:
                    SpaceView3D.draw_handler_add(
                        self.dcb, (rt, d,), rt, d)
                except:
                    print("No dcb for", rt, d)

    def dcb(self, rt, d):
        print("Testing dcb:", rt, d)

if __name__ == "__main__":
    DrawClass(bpy.context)


Text Editor Scripts not available in the Python Console - but are available to scaling drivers

All good, you have the file "drivers.py" (correctly with the py extension) registered already you can simply

import drivers
drivers.driver_Combo(..

or

from drivers import driver_Combo

in the py console


I found that the following parameters influence on smoke's density above other objects:

Density value in Volume Principled shader (it should be between 30-60)
High Resolution mode in Domain object settings (using this, you can set Density 1.5-2 times smaller)
Volumetric scene settings -> Volumetric Lighting -> Light Clamping. It should about 10-15, or zero (no clamping). Using this parameter you can easily control the brightness of the smoke separately from the density.

And of course the light must be good.

Here is what I've got with Density 30, Light Clamping 10, HighRes turned on, and Sun light energy 10:


Is there any way to bake texture from world space to UV?

Well I just figured it out. You can just bake it. super easy

What I did

Assign a material with HDRI environment texture based on object space mapping to your object.
Unwrap your object
go with bake and make sure bake the map you used in your shader i.e used diffuse node then bake diffuse, Emission then emit etc.

Baked image is perfectly projected on your UVs :)


Bridge edge loops (W, E) will work provided the end edges that close the loop are not selected:


If I understand you right, the bone shall have the same rotation as its parent (in pose mode):

To achieve this by script, all you basically need is the rotation part of the parent. Construct a 4x4 transformation matrix from the parent rotation and the target bone's translation and scale. Assign it to the bone's matrix property.

import bpy
from mathutils import Matrix

pbone = bpy.context.active_pose_bone
pbone_parent = pbone.parent

loc = Matrix.Translation(pbone.matrix.to_translation())

# Rotation only (strip location and scale)
# TODO: make it work for parent bones with negative scale too
rot = pbone_parent.matrix.to_euler().to_matrix().to_4x4()

s = pbone.matrix.to_scale()
scale = Matrix()
scale[0][0] = s[0]
scale[1][1] = s[1]
scale[2][2] = s[2]

mat = loc * rot * scale

pbone.matrix = mat

# Force redraw, so transform properties are immediately visible
for area in bpy.context.screen.areas:
    if area.type == 'PROPERTIES':
        area.tag_redraw()

Note that the script has issues with negative scaled parent bones, couldn't figure out how to do it properly.


Python code for Edge Data Bevel and Crease Weight?

EDITED:

OK, apparently the previous answer was pretty worthless. Although there is a meshedge.crease property and a meshvertex.bevel_weight property, they do not influence modifiers at all, and their values do not change when changing the corresponding values in the properties panel.

However, there is a way to access these values through custom layers via BMESH. The addon below adds a panel that allows you to influence selected verts / edges or all verts / edges' crease and bevel weight properties.

It does have one weird bug though, which seems to be a bug in Blender, as seen in the GIF above. Even though this does indeed update the respective mesh properites, Blender does not update the display until you also change any value of a modifier on the active mesh.

EDITED 2:

Thanks to a comment from batFINGER, found a solution to the weird behavior mentioned and seen above: adding a bmesh.update_edit_mesh( meshData ) after updating the crease / bevel values. Updated code below accordingly.

To use this, download the code and save it as a python (.py) file on your computer, then install it as an addon (File --> User Preferences --> Add-ons --> Install From File).

The panel appears in Edit Mode only in the Tools tab, under "Crease and Bevel".

bl_info = {
    "name"       : "Crease and Bevel weight panel",
    "version"    : (0, 0, 1),
    "blender"    : (2, 77, 0),
    "category"   : "Tools",
    "location"   : "3D View > Toolbox",
    "description": "Shortcut UI panel for Mesh edge crease and vertex bevel weight properties"
}

import bpy, bmesh

class creaseAndBevelPanel(bpy.types.Panel):
    bl_idname      = "creaseAndBevelPanel"
    bl_label       = "Crease and Bevel"
    bl_space_type  = 'VIEW_3D'
    bl_region_type = 'TOOLS'
    bl_category    = 'Tools'
    bl_context     = "mesh_edit"

    @classmethod
    def poll( self, context ):
        ''' Only show panel if there is an active mesh object '''
        return context.object and context.object.type == 'MESH'

    def draw( self, context ):
            layout = self.layout
            props  = context.scene.creaseAndBevelPG # Create reference to property group

            box = layout.box()                    # Draw a box
            col = box.column( align = True )      # Create a column
            col.prop( props, "whoToInfluence"  )  # Add properites to panel
            col.prop( props, "bevelWeight"     )
            col.prop( props, "edgeCrease"      )

class creaseAndBevelPG(bpy.types.PropertyGroup):
    ## Update functions
    def update_bevelWeight( self, context ):
        ''' Update function for bevelWeight property '''

        o  = bpy.context.object
        d  = o.data
        bm = bmesh.from_edit_mesh( d )

        bevelWeightLayer = bm.verts.layers.bevel_weight['BevelWeight']

        if self.whoToInfluence == 'Selected Elements':
            selectedVerts = [ v for v in bm.verts if v.select ]
            for v in selectedVerts: v[ bevelWeightLayer ] = self.bevelWeight
        else:
            for v in bm.verts: v[ bevelWeightLayer ] = self.bevelWeight

        bmesh.update_edit_mesh( d )

    def update_edgeCrease( self, context ):
        ''' Update function for edgeCrease property '''

        o  = bpy.context.object
        d  = o.data
        bm = bmesh.from_edit_mesh( d )

        creaseLayer = bm.edges.layers.crease['SubSurfCrease']

        if self.whoToInfluence == 'Selected Elements':
            selectedEdges = [ e for e in bm.edges if e.select ]
            for e in selectedEdges: e[ creaseLayer ] = self.edgeCrease
        else:
            for e in bm.edges: e[ creaseLayer ] = self.edgeCrease

        bmesh.update_edit_mesh( d )

    ## Properties
    items = [
        ('All', 'All', ''),
        ('Selected Elements', 'Selected Elements', '')
    ]

    whoToInfluence = bpy.props.EnumProperty( # Material distribution method
        description = "Influence all / selection",
        name        = "whoToInfluence",
        items       = items,
        default     = 'Selected Elements'
    )

    bevelWeight = bpy.props.FloatProperty(
        description = "Bevel Weight",
        name        = "bevelWeight",
        min         = 0.0,
        max         = 1.0,
        step        = 0.01,
        default     = 0,
        update      = update_bevelWeight
    )

    edgeCrease = bpy.props.FloatProperty(
        description = "Edge Crease",
        name        = "edgeCrease",
        min         = 0.0,
        max         = 1.0,
        step        = 0.01,
        default     = 0,
        update      = update_edgeCrease
    )

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

def unregister():
    bpy.utils.unregister_module(__name__)


Multiresolution modifier not working for bake

Create new or choose existing texture for bake to in material node editor and make it active by selecting it.

Then set preview subdivisions number of modifier to 0 before multires baking.


How do I stop Blender from automatically creating floating windows?

I assume you're looking for fullscreen by default.

Open a new blank file. Go to Window > Toggle Fullscreen Window. Then, go to File > Defaults > Save Startup File

Edit:

To stop renders and file browsers from popping up in new windows, go to Edit > Preferences.

Then select Interface > Editors > Temporary Windows.

Keep User Interface will not make any changes to the user UI when you press render. If there is an Image Editor set to Render Preview open, it'll display in there.

Fullscreen will replace your current window with a fullscreen render preview/file explorer.

Image Editor will replace the current editing window to an Image Editor set to render preview (for ex. your default 3D viewport will be switched to Image Editor it that was open)

EDIT 2

If you want to keep the current interface without any floating windows all you need to do is change the editor type or Toggle the active window, by selecting it on the top left, or selecting the shortcut of the editor you want. The file browser is Shift+F1. To go back to the 3D viewport press Shift+F5. Rendered images will be in the Image Editor or Shift+F10

To toggle the current active window into the preferences window you need create a new shortcut (version 2.8 has no pre-assigned default).

To edit the preferences and add a new shortcut:
Open the preferences window>keymap open the window section. Press on Add New to a new shortcut :

Type screen_space_type_set_or_cycle and select a combination of keys of your choice (in previous versions of blender it was Ctrl+Alt+U) and select the preferences window as "type" on the bottom left.

Then Click on the top right of the screen to show the option to save the preferences to make the change permanent.