It looks like you are using relative paths but the files are in different drives and not in the folder where the project file is. Move all the files to a common directory, along with the project file, or disable relative paths, so that the files are in a fixed location.
From the blender manual:

Relative Paths
Many blend-files reference external images or other linked blend-files. A path tells Blender where to look for these files. If the external files are moved, the blend-file that references them will not look right.
When you specify one of these external files, the default option is to make the path relative. Blender stores a partial path evaluated relative to the directory location of the referencing blend-file. This choice helps when you need to reorganize folders or move your files.
With a relative path, you can move the blend-file to a new location provided the externally linked files are moved along with it. For example, you could send someone a folder that contains a blend-file and a sub-folder of external images that it references.
When relative paths are supported, the File Browser provides a Relative Path checkbox, when entering the path into a text field, use a double slash prefix (//) to make it so.


Dynamic Paint Cycles - How do you make waves caused by an object to turn white?

Geometry Input - Pointiness

You might want to experiment with the Geometry Input and try out Pointiness to mix the whitecaps with the water.

Update

The order of the Shader inputs is important. If white becomes the dominant color, the inputs on the Mix Shader need to be swapped.
The black value in the color ramp should start at 0.5 or above. We want to preserve the water material and only add the whitecap material to the pointy parts of the mesh.

If an answer was helpful please consider marking it accepted

Here's your updated blend file:


Make the selected object to be highlighted in outliner

The hotkey Numpad . might be what you're looking for, the Outliner follows the same Show Active behavior that the 3d Viewport does, while the cursor is in either pane.
This also works for bones in armatures, you'd press Numpad . once to target the armature, then again to open the tree and highlight the selected bone.


I think there are 2 different questions, modeling and cloth.

About modelling: You can create a basic profile, then give your object an Array modifier, then a Simple Deform modifier (Bend mode, Angle 360°). Extrude inwards, then give it a Solidify modifier. Add some edge loops to sharp the edges, it will also allow you to twist it a bit with Proportional Editing option enabled once you'll have the modifiers applied (but you can also keep the modifiers and deform it with a Mesh Deform modifier).

You don't say a lot about how you want to animate it as a cloth, maybe you should give your object a Surface Deform modifier with a (bit) subdivided plane as object and give this plane a cloth physic. If you create a Pinning Group, the less the vertex will be part of the group the more it will be affected by the gravity. Then parent the collar to the plane. It will be much lighter than if you give the whole object a cloth simulation. Needs to be tested though.


What is the range of values produced by Cycles texture nodes?

Rather than list the specific ranges of the texture nodes it is more useful to provide the tools you can use to analyse them yourself - partly so that you could apply the same technique to any other texture or shader function you made create in future, but also because stating specific upper and lower ranges is meaningless unless you also appreciate how the values are distributed over that range.

For example, consider a mathematical 'normal' distribution (https://en.wikipedia.org/wiki/Normal_distribution) :

In a normal distribution, the values are centred around a specific place - there is more chance than any particular sample will be near that centre and progressively less chance the further away from the centre you go. However, where does it end? Technically the range is actually -infinity to infinity as there is a chance of any value being returned by the normal function - just progressively less chance, the further from the centre you move. How could you measure such a boundary?

From a practical point of view, however, we may just that we've reached the limit whenever the chance of a result of a certain value is below a particular threshold. ie, it becomes very relevant to know the shape of the distribution to be able to determine where the practical limits are.

The built-in Blender UV/Image Editor window includes tools that can show the distribution of values and we can use that to analyse the output from any node. Open a UV/Image Editor window and press T to open the tools panel. You should see a Scopes panel with a number of graphs. The most useful for this situation is the Histogram panel :

The histogram shows an analysis of the pixels in the image over the range 0.0 to 1.0 for each channel R, G, B, A in addition to 'combined' channels Luma and RGB, with the shape of the graph showing how those values are distributed throughout the image. The peak shows what the most common value is, the lower the occurrance, the lower that point in the graph.

The histogram shows the analysis of the image after any color management has taken place on the image. Therefore, to avoid skewing the results we need to first disable color management. This can be achieved by opening the Scene properties and selecting 'None' in the Display Device setting of the Color Management properties.

Since the histogram only shows values in the range 0.0 to 1.0 and some of our textures (such as Musgrave) produce values outside that range, we'll need to apply some maths to shift and scale the values to something more useful. Since the Histogram window includes grid lines to split the graph into 4 we can use the centre line as 'zero' with a range of -2.0 to +2.0 using the following nodes :

Note that this shows the nodes for the Environment rather than a specific material. By removing all the objects from the scene and simply rendering the environment we can get a clean image that only contains the results of the texture being tested.

Now simply plugging different texture's Fac output into the Color input of the Background node and pressing F12 to render should produce an analysis of the texture as a histogram. For example, Noise produces the following :

Note : Varying the Scale of the texture node will affect the smoothness of the curve.

For the Noise example above the vertical grid line in the centre of the histogram represents 0.0. Values to the left of this are increasingly negative (with the 1/4 grid line representing -1.0) to the left-hand edge, representing values of -2.0. Similarly, the 3/4 vertical grid line represents 1.0 while the right-hand edge represents 2.0. As can be seen from the graph, the values of the Noise texture centre around 0.5 and vary down to about 0.25 and up to about 0.75. However, there is a 'tail' that theoretically extends indefinitely - presumably down to 0.0 and up to 1.0 but with ever decreasing frequency. So, for practical purposes the Noise texture varies from 0.25 to 0.75 with approximately a normal distribution.

Plugging other textures produces the following :

Voronoi - varies between 0.0 and 1.0, biassed towards the lower end and gradually dropping off :

Musgrave - centred around 0.0 and tailing off to -1.5 and +1.5 :

Magic (Fac) - between 0.0 and 1.0 with a high peak at about 0.3 :

Wave - Between 0.0 and 1.0 with more values at either end (the peak and trough of the wave) :

Similar methods can be used to analyse the Color output of the textures by splitting the color into individual channels and performing the same calculations before combining back into a single color. The histogram can then be used to split the channels to compare :


Under Render Properties > Device switch from GPU to CPU. Your graphics card can't handle this task.


How to select a point of a MaskLayer with python?

So apparently the above method is actually the way to go, it just doesn't work due to a bug, which will hopefully be fixed soon.


As @MrZak suggested, you can get the files from online resources.

Go to the "interface_theme" folder in the Blender Source Code
Copy the contents of the XML file for the theme you want
Go to the folder in which blender is installed(usually located in program files)
Navigate to "2.79\scripts\presets\interface_theme"
Create a new XML file and paste the previously copied item in it


move transform gizmo to selected vertex in edit mode

If you hit Shift + S in Edit Mode, you can "snap (the crosshairs 3D) cursor to selected". Then change the center of your rotation to "3D Cursor" using the little figure eight-like icon near the magnet towards the top of your screen. (You can also reach "snap cursor" via Object > Snap > "Cursor to Selected" in Object Mode.) If that doesn't put the gizmo in the middle of all your selected vertices, then you can try Object > Set Origin > Origin to 3D Cursor in Object Mode.
Incidentally, it looks like you have a mass of vertices selected. Try zooming in really close to select just one vertex.


How can I model a snug mesh around a complex object?

Edit: So as Batfinger says I missed the coat thing, so it should probably be done with hair particles on a cloth, I'll try to rework my answer.
The first thing that comes to mind is to use a Particle System > Hair, with a leaf as object. Here is what it could give, with the Particle System settings: In Render, choose Render As > Object, and for Instance Object > choose the leaf object.
Give your leaf the same material as the tank hull, on the bottom of the Texture Coordinate node, don't forget to choose Object > Tank so that the leaves will take the color of the area where they are emitted.


Just click the click the yellow dot next to the color picker and select Environment Texture.

Or from the shader editor select World instead of Object:


When you get that kind of trouble it is usually a second bone causing another extra influence on the area you´re presenting. Scroll-select each vertex group on your bone´s vertex groups. Surely you will find a second other bone causing an additional influence.
Also, make sure the paw bone is set it´s influence to 100% (completely red).


Is there a way to convert a mesh's UV's into a second mesh using a script?

In Object Mode with an object selected (tested with an unwrapped cube)

import bpy

ob = bpy.context.object

def createMeshFromData(name, verts, faces):
    # Create mesh and object
    me = bpy.data.meshes.new(name+'Mesh')
    ob = bpy.data.objects.new(name, me)
    ob.show_name = True

    # Link object to scene and make active
    scn = bpy.context.scene
    scn.objects.link(ob)
    scn.objects.active = ob
    ob.select = True

    # Create mesh from given verts, faces.
    me.from_pydata(verts, [], faces)
    # Update mesh with new data
    me.update()
    return ob

out_verts=[]
out_faces=[]
for face in ob.data.polygons:
    oface=[]
    for vert, loop in zip(face.vertices, face.loop_indices):
        coord = ob.data.vertices[vert].normal
        normal = ob.data.vertices[vert].co
        uv = ob.data.uv_layers.active.data[loop].uv
        out_verts.append((uv.x*10,uv.y*10,0))
        oface.append(loop)
    print(oface)
    out_faces.append(oface)

createMeshFromData(ob.name + 'UVObj', out_verts, out_faces)

If you are using Blender 2.8 series, the script below does the exact same thing. Note that there is a size variable introduced to help scale the output mesh if needed:

import bpy

C = bpy.context
ob = C.object
size = 10.0

def createMeshFromData(name, verts, faces):
    # Create mesh and object
    me = bpy.data.meshes.new(name+'Mesh')
    ob = bpy.data.objects.new(name, me)
    ob.show_name = True

    # Link object to scene and make active
    C.view_layer.active_layer_collection.collection.objects.link(ob)
    C.view_layer.objects.active = ob
    ob.select_set(True)

    # Create mesh from given verts, faces.
    me.from_pydata(verts, [], faces)
    # Update mesh with new data
    me.update()
    return ob

out_verts=[]
out_faces=[]
for face in ob.data.polygons:
    oface=[]
    for vert, loop in zip(face.vertices, face.loop_indices):
        coord = ob.data.vertices[vert].normal
        normal = ob.data.vertices[vert].co
        uv = ob.data.uv_layers.active.data[loop].uv
        out_verts.append((uv.x*size,uv.y*size,0))
        oface.append(loop)
    print(oface)
    out_faces.append(oface)

createMeshFromData(ob.name + 'UVObj', out_verts, out_faces)

Result:


Backdrop doesn´t work/ image won´t show up (for compositing)

You will need to shift-A add a Viewer node and connect your image/renderlayer node to the Viewer as well as your Composite. At the bottom header, tick the option for 'Backdrop' like you have, and the image should show up in the background of the node editor.


Those shortcuts apply to Walk Mode not fly mode. Make sure you are in the correct mode.

see https://docs.blender.org/manual/es/dev/editors/3dview/navigate/walk_fly.html


Dynamically change the bl_label for an operator

please check this code:

'''
BEGIN GPL LICENSE BLOCK
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.    See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software Foundation,
Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
END GPL LICENCE BLOCK
'''

bl_info = {
 "name": "test properties",
 "author": "Diego Quevedo ( http://doshape.com/ )",
 "version": (1, 0),
 "blender": (2, 7 , 3),
 "location": "View3D > EditMode > ToolShelf",
 "description": "test properties ",
 "warning": "",
 "wiki_url": "",
 "tracker_url": "",
 "category": "Mesh"}

import bpy, sys, math
from bpy.props import (StringProperty,
                       BoolProperty,
                       IntProperty,
                       FloatProperty,
                       FloatVectorProperty,
                       EnumProperty,
                       PointerProperty,
                       )
from bpy.types import (Panel,
                       Operator,
                       AddonPreferences,
                       PropertyGroup,
                       )

class testOperador(bpy.types.Operator):

    bl_idname = 'ops.test'
    bl_label = 'test'
    bl_description  = ""
    bl_options = {'REGISTER', 'UNDO'}

    test1 = bpy.props.BoolProperty(
        name="test_properties after execution",
        default= False
    )

    def main(self, context):

        print("hello")

    @classmethod
    def poll(self, context):
        obj = context.active_object
        return all([obj is not None])

    def execute(self, context):

        self.main(context)
        return {'FINISHED'}

class MySettings(PropertyGroup):

    x_size = FloatProperty(
        name = "x size",
        description = "A float property",
        default = 23.7,
        min = 0.01,
        max = sys.float_info.max
        )

    test = bpy.props.BoolProperty(
        name="test",
        default= False
    )

    vertices = bpy.props.BoolProperty(
        name="vertices",
        default= True
    )

class UV_OT_my_panel(Panel):

    bl_space_type = "VIEW_3D"
    bl_region_type = "TOOLS"
    bl_label = "test"

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

        split = layout.split()
        col = split.column()

        a= bpy.context.scene.my_tool.x_size

        layout.prop(mytool, "x_size", text="x-size")
        col.operator(testOperador.bl_idname, text=str(a), icon="COPYDOWN")

        ############################

        split = layout.split()
        col = split.column()

        b = bpy.context.scene.my_tool.test

        row = col.row(align=True)
        row.prop(mytool, "test")

        if b:
            col.operator(testOperador.bl_idname, text="test1", icon="COPYDOWN")
        else:
            col.operator(testOperador.bl_idname, text="test2", icon="COPYDOWN")

def register():
    bpy.utils.register_module(__name__)
    bpy.types.Scene.my_tool = PointerProperty(type=MySettings)

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

if __name__ == "__main__":
    register()


Have a doubt on Recalculate option in Shading Option?

Recalculate Normals function is used when you're modelling and some inappropriate dark areas appear. Recalculating the normals is used to fix this problem.


Plane in Render not visible in Object Mode

You do have another plane in your scene, it's just not showing in the viewport.

In your outliner check these options and look at all the collections you have, there is a plane there not visible but renderable. You can disable by object or entire collections.

Nice donut btw!

More about it at: Blender Docs


Modifiers not applied in texture paint mode

I found the solution. There's a button that enables the Paint Mask mode, which caused the behaviour I was experiencing.
If the button is OFF (as in the picture), the whole mesh (after applying modifiers) can be painted on.
If the button is ON, then face selection masking is enabled, and the selected faces of the mesh (without applying modifiers) can be painted on.


Can I check to see if an object is used in another objects modifier?

I thought that objects used as a target in a modifier had their user count incremented but apparently not.
I'd use a script for that :
You can loop through all objects and all their modifiers and check what objects are linked to modifier fields. The following script will deselect all objects and select only objects that appear inside the target field of a modifier.
import bpy

bpy.ops.object.select_all(action='DESELECT')
# Deselect all objects

for obj in (o for o in bpy.data.objects if hasattr(o, "modifiers")):
    # Loop through all objects that actually support modifiers
    for mod in obj.modifiers:
        # Loop through all modifier(s) of that object
        for attr in dir(mod):
            # Loop through all attributes of that modifier
            target = getattr(mod, attr)
            # Get the value of that attribute field
            if isinstance(target, bpy.types.Object) and target is not None:
                # Filter in only attributes that link to an Object
                target.select_set(True)

How to run a script in blender
Note :
On some instances object fields retain their object link even when the linked object is not actually used.
Example : On the boolean modifier, if you first use an Object as a target, then set the type to Collection, the link to the Object still remains. If you switch back to the Object type, you see that the target is still filled in. You'd have to add in special use cases for that in the script if that behaviour bothers you.


The problem lies with the custom normals you have on your mask and horns objects.

Before clearing custom split normals:

After (using a simple diffuse shader I created while debugging the file):


Let's start with the question first.

Ngons' behavior in game?

It will become Triangle faces that support the ngons vertices, exactly same when you manually triangulate any face in Blender, with some algorithm you don't know or don't care.

So the answer seems to be clear: You need to know when will an Ngons behave as same you want

We could divide the situations in following:

1. The Ngons is flat

Then the algorithm matters, in Blender, most of the ngons can be easily triangulate:

But not all game engine use a good algorithm to deal with this thing, it might be confuse by the strange behavior, or the ngons corners is not always convex. And the UV coordinates might be messed up. You should better try it in the game editor to test it.

2. The Ngons is not flat

If the angle is small, it will be OK with the same issue in flat Ngons. But when the angle is quite big. Don't use that ngons. Quick example:

The face with 2 vertices in different height cause render engine confuse. When manually triangulate it, it might not be the thing you see in view port before.

conclusion

Don't keep ngons when you are not sure what will happen to it. Use CtrlT to make them triangle, especially when it is not a flat plane.

The rest of the things

And your mesh: Separate those detail mesh if doing it will keep the mesh clean

If you are creating the game asset, then you might want to bake those detail to bump and normal map, or even displacement map. And Ngons might not be bad if the ngons is flat, and clear to triangulate. You should try on rough attempt, export the object to game engine and see what will happen.

And also, it is not that evil to separate the mesh that should be one thing in real-life. If the object is craft in that way (traditional way, not CNC or 3D printing), then do the same thing in modeling.

You may need to decrease the vertices on the large object and use details map textures. But for the tiny thing like buttons and grips, make it separated help a lot in your topologies. Look at the mesh in your vendor machine, those checked edges are meaningless.

It won't cause large overhead using multiple mesh toward rendering. In fact, there is no any cost when the vertices is not connected, the shader(program who draw your scene) only care about the number of vertices, faces and of course the textures. On the other hand, a complicated, well constructed mesh will slowdown your shader by the large amount of vertices and geometry.

But keep in mind: The shader used in these separated meshes should be the same one. Otherwise, this object will be treated as multiple draw calls. That's why it is not recommend to add too much material(shader) to your game object in Unity or other game engine.


Importing from Blender to Unity - Model looks different?

In Unity, pay attention to the color of the Sun lamp and match it to what you had in Blender. In Unity the result currently looks tinted towards green. This could also be because of the sky which constitutes to the color as well.

Texture definition is another probable key issue. Depending on how optimal your UV layouts are, you should be getting good results using high resolution textures like 2048 x 2048. In Blender you could bake the textures at 4k or 8k resolution, Unity by default imports images as 2k textures. You can adjust this per texture in the import options, so make sure it's currently not bottlenecking your quality if your textures are otherwise high quality. From the images it's not apparent but make sure to bake normal map and apply the normal map texture to your Unity material. When using a normal map, your model should always be set to smooth shading.


GPU Rendering issue “Cuda error at cuCtxCreate: Illegal Address

Roll back the Nvidia graphics driver to when it did work properly.

In my case Nvidia drivers to v391.0 caused this error.
Since I don't auto update my drivers I rolled it back to v388.0 and rendered over a 100 frames in full HD with no problems.


Reflections do not work the same way in eevee as they do in cycles. To get proper reflections in eevee from an emissive object, you should use an irradiance volume and a reflection cubemap (Shift+A > Light Probe).

Make the probes big enough to encapsulate what you want to reflect, and then bake indirect lighting. See below:


Cannot find the node called texture coordinate in blender 2.79?

Since Blender render (internal) is missing that (shader) node, I guess you have maybe not set Cycles as render engine:


How to set up the IK Controller bone without separating its parented bone in the process?

This is happening because of where you've set the bone to rotate around. In the video, he has the IK bone and the foot bone rotating in the same spot. In your file, the IK bone is rotating around a point off to the side of the foot bone (at the center of the sphere). This means that any bone that is parented to that IK bone will move in an arc around that IK bone.

Think of it this way: when parenting objects/bones you're telling Blender that bone A has to always be at some position relative to bone B. Let's say that this position is 3 inches to the left of bone B along the X axis of bone B. When we rotate bone B, it's local axes rotate with it. So after rotating bone B, it's X axis could be pointing straight up, or forward, off to one side at 56.67809 degrees, you get my point. But bone A will still follow along, and be 3 inches along the X axis, wherever it points.

So if you move your IK bone to have it's base where the base of your foot bone is, everything should be good to go(try setting the cursor at the base of the foot then using Snap to Cursor). Since the sphere will now be on top of the foot, the foot will be hard to see. If you select the IK bone and go to where you selected the custom shape you can choose wireframe to make it see through.


How can X, Y, Z and W go above one in a quaternion animation on Blender?

But....Blender does work with quaternions between 0 and 1.

There's an interesting video put out by Nathan Vegdahl (that's part of his Humane Rigging series) that discusses quaternions: https://www.youtube.com/watch?v=FRD0PgsY3pU&index=14&list=PLE211C8C41F1AFBAB
If you go to about 10:31 in the video, it talks about quaternions only being valid between 0 and 1. By 11:09, he mentions what Blender does with values greater than 1.

Not sure what would prevent the file from being imported correctly.


In Blender 2.8 +, how do I limit the (animation / multi-frame) render to only one pass (e.g. only z-pass or only Mist pass)?

I figured out a simple way to do use the compositor programmatically to isolate the mist pass in the renderers (Inspired by this answer).
import bpy

# (perhaps) more code here

# perhaps defined in some function or method
node_tree = bpy.context.scene.node_tree
render_layers_node = node_tree.nodes.get("Render Layers")
composite_node = node_tree.nodes.get("Composite")
links = node_tree.links
links.clear()
links.new(render_layers_node.outputs["Mist"], composite_node.inputs["Image"])

# (perhaps) more code here

bops.render.render(animation=True)
```


Is there some way to map different image textures to instances of linked duplicates?

Keep the object data linked, but make the material linked to the Object, not Object Data:

From there, make a new texture for each object-linked material. That way, several objects can have different textures, while still sharing the same object data.


How to make character-mesh deform naturally when animating?

Add edge loops on your mesh  at both sides of a bones joint.

Ctrl+R with the mouse cusror on an edge, click to add one (roll middle mouse button for more than 1), slide mouse to place it, click when it's where you want.

When done, parent your armature again with automatic weight (you'll play with weights later :))


How do I change the focal length of a camera with python?

It's in bpy.data.cameras['name of your camera object'].lens, or camera.angle (thanks @ideasman42).

Note that you must have a camera in the scene.


Python Script attribute error while using node editor

probably this material has been created for the blender render engine (by default nodes are disabled ) so you just have to enable using nodes before accessing the node tree by the following line : mat.use_nodes = True then you'll have access to the node tree, you can do a test before accessing to avoid getting into errors


How do I replicate this asymmetrical bevel?

but bevel ( the destructive operator ) can do some cool stuff too.

make a cylinder, use the Knife tool (K) to cut a line at the right angle through the cylinder.

Press Z to set the mode to "cut straight through".
to make a straight cut: left click the start location, double left click at the final location to end the cut line. Hit Enter to finalize the cut.

inset a circle in the top, and drag it towards the side where you want the shortest radius. Then select the outer edges.

then Ctrl+B (bevel) and press M until the mode is percent. Then add segments using the mouse wheel.

look at the tool information bar at the bottom of the active 3dview.

If you can make it so all fillet edge pairs are similar in length, you'll get nice approximately "circular" fillets.


You can add a shortcut in Edit Mode using the bar at the bottom of the 3D view.

The button in the menu for Edge Bevel Weight is under Mesh ‣ Edges ‣ Edge Bevel Weight.

Right-click the button and then select Add shortcut from the popup menu that appears. You can also do this with any other item in the menu or the toolbar on the left.

Also notice that the shortcut for the Edges menu is Ctrl E, so if you wanted you could type Ctrl E in the 3D view and select Edge Bevel Weight. You can also add a shortcut from this menu by right clicking and selecting 'Add Shortcut', as above.


how to texture a head model using exsiting images?

Try this: https://www.youtube.com/watch?v=KoiYMx2xXGA

A few suggestions (since you are new): While in object mode on the Tools Shelf (open with T key) select  Smooth under Shading. I'm assuming you don't want flat shading for a head :).

For hair I recommend Particle System based solution, if the model isn't being created for a game.

If you use your picture for hair it will probably look like these old 3d models in Playstation 2 , remember the flatness?

But there are some techniques for hair that are pretty good although made with pictures.

For any questions, don't hesitate to ask.


Converting a masked 2d grayscale image to an object

I used your image as height map and got this result:

Work in progress:

Take a plane and scale it up, subdivide it ~1000 times.
Add a displacement modifier with the image as texture.
To smooth out the result, add a subdivision surface modifier before and after the displacement modifier.
Apply the modifiers.
Go into edit mode (be careful with your modifiers, the first time Blender crashed at this step due to too many polygons) and select all the mesh. Go to "smooth vertex" and smooth it a lot (5 times with factor 1 on the screenshot; should have been more)
Add a decimate modifier to remove unnecessary geometry. Remove vertices based on the angle with the "planar" mode. I had to first decimate it with "collapse" because planar decimation takes a lot more of time to calculate. Ratio 0.1 and 6° angle limit worked well.
Go into edit mode again, select all vertices on the bottom with height 0 and delete them.


If it's cycles you are using it might be possible. All of the particles do have a unique ID that you maybe can use to give them different textures. The ID is used to calculate ag. collisions, if i haven't misunderstand how it works.
In the math node should it be an options for compare values, if you set it to check if the value is the same and if they are it will send 1.
You should be able to do it but I'm not sure if it is worth the extra time.


How would I change a Cycles material's color using the scale of the object instance it's applied to?

Cycles Sample 01

Cycles Sample 02

Consider a particle system and material shader nodes.

Use the particle info node size [relative scale] value.

Note the object particles with [size] set to 1 and [random size] set to 1 in the image below.

We assume that your placement of spheres can use a particle system.
Particles are emitted in 2 frames.  Of course with a more complex mesh particles can be placed anywhere.  There was no artistry in placement of the example I provided.  You can do better.

Below same Material with different Particles Settings. A more controlled placement with particles spaced evenly.


Blender Python: Call operator function from another function?

You can pass what you want and even self, this way it is easy determine where the call is coming from. Operator based on Templates > Python > Operator Simple:

import bpy

def main(operator, context):
    print (operator, context)
    operator.report({'INFO'}, 'Call is comming from: {}'.format(operator))
    #return operator

class SimpleOperator(bpy.types.Operator):
    """Tooltip"""
    bl_idname = "object.simple_operator"
    bl_label = "Simple Object Operator"

    @classmethod
    def poll(cls, context):
        return context.active_object is not None

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

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

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

if __name__ == "__main__":
    register()

    # test call
    bpy.ops.object.simple_operator()


Rendered file black, even though Play Rendered Animation is correct

When you render the file you must choose the output format and the video codecs. Probably your video player is not supporting the video codec that has been rendered.


Dummy property to update bpy.app.debug via UI

Script below uses a dummy boolean property on the window manager, with an update method to set bpy.app.debug to same.  Button is prepended to the 3D view header.

import bpy
from bpy.props import BoolProperty

def toggle_debug(self, context):
    bpy.app.debug = self.toggle_debug
    print("bpy.app.debug = ", self.toggle_debug)
    return None

bpy.types.WindowManager.toggle_debug = \
        BoolProperty(update=toggle_debug)

# function display the button
def display_toggle(self, context):
    layout = self.layout
    wm = context.window_manager
    layout.prop(wm, "toggle_debug", text="DEBUG", toggle=True)

# prepend to 3d view header
bpy.types.VIEW3D_HT_header.prepend(display_toggle)

To add properties to, or display properties in the UI,  the object must be an ID type.  Below is a simple test in python console to see if an object is an instance of an ID type.

>>> isinstance(C.window_manager, bpy.types.ID)
True

>>> isinstance(bpy.app, bpy.types.ID)
False

see that bpy.app is not, hence the error trying to use layout.prop(bpy.app, "debug")

Also the error in your posted image is because app was not defined, assumed you meant bpy.app.


How can I move the pivot/gizmo to (0,0,0) in a Python script?

Apply location sets local origin to global
Via the UI can set an objects origin to global origin (scene (0, 0, 0)) by applying location CtrlA Location
equivalent of calling
bpy.ops.object.transform_apply(
    location=True,
    scale=False,
    rotation=False
    )

At a lower level.
Method to set the origin of an object to a global location, without moving the object ie the vertices remain in the same global location.
Setting the origin for each object to geometry
Set origin to bottom center of multiple objects

Get the local coordinate of the new origin
Subtract it from all coordinates
Set the global translation to new origin location

Test script:
import bpy
from mathutils import Vector, Matrix

def set_origin(ob, global_origin=Vector()):
    mw = ob.matrix_world
    o = mw.inverted() @ Vector(global_origin)
    ob.data.transform(Matrix.Translation(-o))
    mw.translation = global_origin

# test call

set_origin(bpy.context.object)


Is there an easier way to create an inset extrude along a model?

Welcome to Blender Stack Exchange!

Blender actually has a tool that does exactly what you're looking for. It's called Inset, and can used by selecting the section you want to inset, and pressing I.

Basically what this tool does is create an extra edge around the perimeter of your selection then slide the new edge inwards (towards the selection). Thus, it has a few limitations to know.

First, you will need an edge to select that is exactly where you want the split to be. It looks like you have this already.

Second, since the new edge will slide along existing edges, the thickness of the new face loop (what you were using Bridge Edge Loops to make) will be limited by how long the connecting edges are. If you have a really dense mesh for example, the new edges can't slide very far before colliding with existing vertices. What I'm trying to say is that you want to make sure that you mesh has "room" for the "path" that you're trying to add. The Inset tool only adds faces, it won't remove them.

Proper topology will help a lot, but it should work regardless. You might just have to do a bit of trial and error to see what you need to tweak.


You may achieve this type of topology (although it is not perfect) using the Remesh Modifier.

First extrude yout text mesh a bit.

Go to Object Mode and enable the Remesh Modifier

In Object header, in the Display panel check the Wire checkbox. It'll allow you to see how the modifier works in a realtime.

Uncheck the Remove Disconected Pieces checkbox (if you don't some of the letters may dissapear) and play with the modifier's settings.

At the end delete the previously extruded vertices.


How to put an object at the outer end of each branch of a sapling?

With help of lemon's initial comment, which pointed me in the right direction, I arrived at this solution.

Once you happy with the shape of your tree, select it and hit AltC then M to convert it to a mesh, then Tab into Edit mode. Hit A once or twice if needed to select all.

Hit CtrlV then D to remove doubles. Reduce the Merge Distance in the options panel in the lower left corner. Set it as low as it will go.

Select the end vertex of one branch, the hit ShiftG then O to select every vertex that has the same number of edges connected to it as the already selected one.

Instead of creating a vertex group, I duplicated the selected vertices (ShiftD) and then separated them into a new object (P then S). Now Tab out of Edit mode and hide the complete tree by clicking the eye next to its name in the Outliner.

Select the other "tree", which is just a cloud of unconnected vertices. You should see something like this.

Add a sphere (or whatever object you want at the ends of the branches). Hold Shift and select the vertex cloud. Now the sphere and the vertex cloud should both be selected, with the vertex cloud being the active object. Hit CtrlP then O. The vertex cloud is now the parent of the sphere. Select the vertex cloud and go into the Object tab of the Properties panel. Under Duplication, click Verts.

Scale the sphere (select it and hit S, drag the mouse until things look good, then hit Enter). You should now have something similar to this.

And if you unhide the original tree, by again clicking the eye next to its name in the Outliner, it should look like this.

The spheres in the tree are now just copies of the original sphere. The original sphere and the vertex cloud need to be left. They will be visible in the 3D view, but not in the render.
The duplicates can be made real, if you want or need to, by selecting the vertex cloud (i.e. the parent of the sphere which is being duplicated) and hitting ShiftCtrlA. After that you can delete the vertex cloud and the original sphere.


What I'm understanding is that you'd like to bring the vertices of the back face of your object to be directly behind the corresponding vertices of the front face, down global Y (since you are in Front view)

If the back faces are the same shape as your front faces, and shifted, (not rotated) with respect to the front faces, you can set your snap to Active and Vertex, select all the vertices you want to move, making a convenient vertex the last selected (and therefore active) and GShift
Y the vertices, snapping the active vertex to its counterpart in XZ.

If not, another possible move -

Select the back vertices, and (without Automatic Merge switched on)   G G slide them down their edges until they meet their front partners. (You may have to do this in more than one bite). Then  GY them to your required depth.

Or.. it may be more economical to delete the back faces, and make a brand new  extrusion in Y (EY).

It's possible that the result is not the one you're looking for..


Convert files from console using Blender

This is untested, but too much to write in comment.

Would say the gltf addon is default in 2.8 the dxf not.  Here is a test script to enable both and set as default and persistent.

If you look at addon info for the two addons in question will note that the folder name in addon folder for each is

"io_export_dxf", "io_scene_gltf2"

this is the key used to enable them using the addon_utils helper method enable, and check if already default and enabled with check

import bpy
from addon_utils import check, enable
bpy.ops.wm.read_factory_settings(use_empty=True)
for addon in ("io_export_dxf", "io_scene_gltf2"):
    default, enabled = check(addon)
    if not enabled:
        enable(addon, default_set=True, persistent=True)

#bpy.ops.import_scene.gltf(filepath="/somepath")
#bpy.ops.export.dxf(filepath="/somefilepath")

Note commented out the operator calls.

See the output in the python console to find and check what properties can be set for operators.

For example export to dxf. Will reflect those in UI panel when manually exporting.

>>> bpy.ops.export.dxf(
dxf()
bpy.ops.export.dxf(filepath="",
    projectionThrough='NO',
    onlySelected=True,
    apply_modifiers=True,
    mesh_as='3DFACEs',
    entitylayer_from='obj.data.name',
    entitycolor_from='default_COLOR',
    entityltype_from='CONTINUOUS',
    layerName_from='LAYERNAME_DEF',
    verbose=False)
Export to the Autocad model format (.dxf)

Note properties listed in long winded operator call above are defaults, and only need to be set when non default (eg filepath)

As mentioned untested.


As the others have said change your normal map image from "Color" to "Non-Color Data". Also your normal map should be hooked up to the diffuse through the normal dot AND the normal dot on the glossy shader.


First, create a 6 step animation of your character moving forward. Don't move or keyframe the root bone for the moment, keyframe all the other ones. The fifth pose needs to be the same as the first one, except a step forward of course. The sixth pose is a duplication of the fifth so that your character makes a pause like in your animation. Don't forget to choose interpolation > linear.

Now animate the root bone only: Keyframe it at frame 1 as it is, then at the last frame make it go backward so that all the other bones are at the exact same position as at the first frame.

In the Dope Sheet switch Dope Sheet to Action Editor. Save your animation, push it down into the NLA. In the NLA, repeat the strip several times. Make the whole armature move from point A to B, make sure again that the interpolation is linear, move the second keyframe (or move the point B position) so that the speed of the armature in the scene synchronizes with the speed of the walk cycle (or play with the strip scale in the NLA N panel). You can also use a Follow Path to make the armature move, same thing you'll have to synchronize the speeds.


place bone-armature given selection of faces/vertices/edges for cursor

The user @batFINGER solved my problem:
"If you are selecting a face / edge / vert then the mesh will need to be in edit mode. eg select a face, shift-S cursor to selected, moves cursor to face. Exit edit mode of mesh, go into edit mode of armature select bone and shift-S snap selection to cursor. (the snap options are pretty intuitive)"
There are special selection tools available when you use the Shift-S hotkey that enable the fine-comb control required to move the 3d cursor to place objects.


How can I render a very large image in cycles?

Use the "Precise Render Border Adjust" addon.

It allows you to easily split the render into smaller tiles which you can combine later in an image editor.

When rendering just make sure that cropping is enabled, otherwise blender will try to construct the complete image, which may freeze or crash the program upon completion or while exporting.


Unfortunately there is no way to create a group node exactly like the Color Ramp, where you can add and remove color swatches at will.  To get around this I have created a node with two movable swatches, you can then combine multiple of these nodes together to have the functionality of multiple swatches.

The theory:

The two input colors are plugged directly into a Mix RGB node.  The two Pos inputs need to be sent through a function and plugged into the mix factor.  The position of the first swatch needs to be mapped to $0$ to get just the first color out of the mix node.  The position of the second swatch needs to be mapped to $1$ to get just the second color out of the mix node.

The math:

Here's a graph to visualize what we are trying to do, on the x-axis is the input factor of the color ramp, on the y-axis is the desired output, $a$ and $b$ are the positions of the two swatches.

With some simple algebra we can find the equation of the line to be:

$$
y = \frac{1}{b-a}x + \frac{a}{a-b}
$$

The math nodes below are simply replicating this equation.  The final Add node also has Clamp checked to clamp the output to the interval $[0,1]$, which is what the mix node accepts.


On second read, I think I understand better. You are exporting a mesh with a modifier to an engine that doesn't support the same modifiers. Most realtime engines only support bone animations - a lot of them don't even support shape keys.
Basically, you can't do what you are doing :)

You have a couple of options:

1: animate it in a way that doesn't use curve modifiers, only bones (might not be easy though)

2: save your mesh animation as an MDD (mesh cache) and load that into your engine, if possible.

3: See if you can set up an equivalent to a curve modifier in your engine. For example, you might be able to make a script that makes the wire traverse through a series of null points. This depends on the engine you are using though.


How do I paint a texture onto an already textured object?

Repeated Image Mapping

The slot named Textures near the cursor in the Tool Tab is relative to the Brush

The slot in where you can choose which is the acticve texture to paint onto can be found in the Slot Tab in the Slot panel. The active texture is the one highlited with blue color.

As you can see on the right you are probably painting a texture with a brush that paint other textures, maybe sometime the same, and may be one of the causes you have repeating features spreading all around.

But the main cause of that relies on the Repeating settings of your Skin texture.

Those values alter how the texture is placed and sized on the UV space. You must set them to 1 an 1 to get the UV unwrapped island to stay in place.

If you want to paint just plain colors, remove Brush Texture by hitting the X button. If you want to paint texture from an image, be sure to use diffrent textures.


How to script a gizmo that would be transformable(move, rotate, scale) independantly from the object it would originate at?

Gizmos require a target to act upon.

Manipulating the gizmo will act upon either:

Property
Operator
Callback

These are set by calling one of the following methods:

target_set_prop(target, data, property, index=-1)

target_set_operator(operator, index=0)

target_set_handler(target, get, set, range=None)

The second of these return an Operator Properties object which you can then set.  Still researching this and need to run some tests but I believe that the second one is what you are looking for.  Please see the documentation for these methods

See the gizmo_operator_target.py template for an example using the transform operator.

See the gizmo_operator.py template for an example that performs a more complex operation using the callback method.

Callbacks made easy

It's quite difficult to see what's going on in the template example so I have prepared a simpler version:

def setup(self, context):

    arrow = self.gizmos.new("GIZMO_GT_arrow_3d")

    def move_get_x():
        return context.object.location.x

    def move_set_x(value):
        context.object.location.x = value

    arrow.target_set_handler("offset", get=move_get_x, set=move_set_x)

    arrow.matrix_basis = context.object.matrix_world.normalized()

    self.x_gizmo = arrow

def refresh(self, context):
    self.x_gizmo.matrix_basis = context.object.matrix_world.normalized()

In order to manipulate a gizmo independently you will have to look at the matrix_basis property.

Simply commenting out the last line in the refresh method will leave the gizmo where it first instantiated:

#self.x_gizmo.matrix_basis = context.object.matrix_world.normalized()

If you want to keep the gizmo with the object then you need to update matrix_basis accordingly.

Subclass Gizmo

Another option is to subclass gizmo, unfortunately I haven't had time to write up an example of this but it is another avenue to explore.

You might also want to look at using the matrix_offset to retrieve information about the change.

If this still isn't quite what you're looking for then you can consider using an empty and attach the gizmp to that instead.

You might also want to look at this question.


Use generated coords, drive the scale.

Nodes aren't particularly my strong point.  Looking at the question setup can make minor alterations to get the effect of gradient across array

change the texture to generated (modified)

and drive the scale with the array count of object.

The driver


Is it possible to set rotation to the current meshes face?

Particles
Duplicate Settings
Explode Modifier

Particles with Rotation setting shown. Image Above.
Particles also has a billboard setting.  Particles can be made in real ... meaning into separate objects.


Why is my Blender UI glitchy when using rendered preview?

I just found this thread on reddit (https://www.reddit.com/r/blenderhelp/comments/6h7aoh/blender_constantly_crashing_and_freezing_on/), where somebody asked a similar question. And the answer was to turn off nvidia shadowplay, or instant replay or whatever it's called. And it worked!

Case closed!


Bought a book and it says when you select an edge and press ctrl+alt+r it creates 2 parallel edges but nothing happens

They've got the default shortcut wrong. It's CtrlShiftR, which creates two loops on either side of the selected loop, interpolated between it and the ones on either side.

You can hit E while sliding the new loops to make them parallel either to the original loop, or the ones which bound it on either side. F flips which. Hitting E again returns to interpolation.


Going from an area of low information density to high density

I think there's no scientific way to learn how to do it, at least in my case I'm still learning day after day how to do it, I guess you just need to try how to join, merge vertices, use the knife to create edges, etc... and keep quads as much as possible, then tris if you don't have choice. Actually each case is a particular puzzle.

Duarte has given you links and it explains how to go from 3 edges to 1, etc... I guess it worth a look.

Anyway, to begin I've separated the eye mesh, then I've used the Knife Project tool to print the eye shape on the rocket mesh.


2.78 - switching between current shading mode and rendered one not work

There have been some recent changes in the default keymap for 2.78, Shift + Z now toggles between the current mode and Rendered mode, as opposed to before where it toggled always between SOLID and Rendered according to the release notes in the wiki.

Unfortunately Blender key map editor is not that good with merging changes between custom keymaps and changes to the official one.

My advice advice to you is to check out the new default keymap and manually copy the relevant operators like view3d.toggle_render and their corresponding key maps from there and paste it into your own custom key map with whatever new key binding you want, making sure you delete the old ones and eliminate any conflicts.


Using an imported model: Why does my mesh look like this?

The mesh imported did indeed use custom normals. The solution as posted worked perfectly:

You have Custom Split Normals Data added to the geometry, to fix this, while selecting the object, go to Data Tab in Properties Panel, scroll to find Geometry Data, and click Clear Custom Split Normals Data.
enter image description here
More information about this issue: Strange black shading. Cannot fully light mesh. (Cycles)


Just for fun, you could do it procedurally.

Add Array modifier
Add Simple Deform Modifier > Bend > 360°
Add Weld Modifier to merge the start/end vertices.

You can also non-destructively adjust the radius by moving the Origin point.


How to correct shading when connecting faces?

When you add faces using F to a mesh they default to Flat shading - even if the rest of the object is set to Smooth shading. To set all faces to Smooth shading in Object mode, simply click 'Smooth' shading in the toolshelf (T). Alternatively, in Edit mode, simply select those faces, press Control-F to bring up the Faces menu and select 'Shade Smooth' (or 'Shade Flat' to set individual faces back to Flat shading).


How to create a simple extruded box model?

What you are asking for is not one tool but a workflow. There is no one set way to do this, curves can be better for getting rounded edges but mesh modeling can be just as good.

However, this is fairly simple and you can achieve the majority of what you ask by just extruding. You can extrude faces, edges and vertices in Blender with the Extrude tool. Just select a face, vertex or edge and press E.

(Alternatively, you can constrain your extrusions to extruding along the object normal with Alt + E), you can experiment with this.

I will use the image you provided as a quick example here..

First, get as close as you can to the shape of the object, (I create the outline of the object from top view). I add a plane  and just grab the edges and subdivide a few times using W > Subdivide while in Edit mode to get some more geometry. I then move the new vertices to fit the shape of the image as closely as possible. To make it more detailed and organic as you ask, you can add more vertices to round out the curved side.

If the face has not been filled, you can use F to make a face from several vertices. I then extrude and delete the top face to give it some depth. To get the lid, I just duplicated the object with Shift+E and moved the sides down.

You can take it anywhere from here now.. I have also quickly added a Solidify modifier to give it some thickness. Also another note, I wouldn't worry too much as a beginner on getting accurate units etc, If you insist however, you can change the units using the Scene tab under Units.

To carry on, I recommend that you see these:

How can I make sharp geometric 3d models look more realistic?
Most efficient way to round edges
When should N-Gons be used, and when shouldn't they?


The first thing you want to do is to have a starting object that is more than just a line. The array modifier will take your object and duplicate it with some offset. Thus, what you would've ended up with (in the case that the array was setup properly), would be 48 lines without any planes.

Add a Mesh > Circle with 48*4 = 192 vertices. Then, select all of the circle's vertices except for two adjacent ones (that you want to keep) in Edit Mode, press ALt+M > Merge at Center. This will create the center vertex. Join the two perimeter vertices by selecting them and pressing F, then select everything with A, and press F again to fill in the triangle.

Then, add in the Array modifier to the triangle. Disable the Relative Offset, and enable the Object Offset as you did in your attached file. Add the Empty Axis, and rotate it in the Z-axis by 90/48 = 1.875 degrees.

Use the empty for the Object Offset in the Array modifier, and you've now gotten a quarter circle made up of 48 triangles.

Edit:

From your blend file, the reason why your array isn't working properly is that you have an unapplied rotation to the "Circle" object. Select the circle object and press Ctrl+A and select Apply > Rotation. Your array works fine after that step.


How can i find the python triggered by the GUI?

The API documentation should be your primary reference when implementing Python scripts for Blender.

Additionally you can enable the Python Tooltips and Developer Extras in the preferences (Edit > Preferences > Interface > Display).

The Python Tooltips will be displayed when hovering over a UI element with your mouse and show what Python command would be executed when interacting with it. The Developer Extras add helpful options such as Edit Source or Online Python Reference to the context menu (RMB).

Using the references provided above it's fairly easy to see why your script doesn't work properly.

bpy.ops.import_scene.gltf() expects a file path as argument, not a file object. Therefore you shouldn't use open() at all. Instead pass the file path as named argument:

bpy.ops.import_scene.gltf(filepath="/path/to/your/file")


are you using cycles, BI, or something else?

For cycles, you might have to add a texture coordinates node.
For BI, you might have to switch the coordinates to be UV in the image mapping section.


How translate an object with a constraint vertex position without deformate the mesh

This method may not work for some cases since your question is not detailed enough (just in my opinion :) )

I am selecting 2 vertices (1 from the Cube and 1 from the Plane) that I assumed to be alligned by looking from your sight (as you see in the blender scene ) and getting their world coorinates. After that I am taking the difference of them to slide Cube. (Also I am assuming our objects are not rotated after created.)

import bpy, bmesh
from mathutils import Vector

bpy.ops.object.select_all(action='DESELECT')

# set active object to Cube
bpy.context.scene.objects.active = bpy.data.objects["Cube"]
# go to EDIT mode
bpy.ops.object.editmode_toggle()

# get Cube's updated vertex data
obj = bpy.data.objects["Cube"]
bm = bmesh.new()
bm = bmesh.from_edit_mesh(obj.data)
bm.verts.ensure_lookup_table()

# get world coordinate matrix for that object
mat = mat = obj.matrix_world

# get the right-bottom-closer vertex's world coordinates and save it to v1. By your sight , this vertex must have minimum x, y and z coordinates among the others.
# Additional info : if it is that vertex, its x coordinate is lower than upper adjacent , its y coordinate is lower than left adjacent ,its z coordinate is lower than further adjacent so I am searching these in the if and elif statements
for vert in bm.verts:
    minx = False
    miny = False
    minz = False
    for edge in vert.link_edges:
        vert2 = edge.other_vert(vert)
        if (mat*vert.co)[0]<(mat*vert2.co)[0]:
            minx = True
        elif (mat*vert.co)[1]<(mat*vert2.co)[1]:
            miny = True
        elif (mat*vert.co)[2]<(mat*vert2.co)[2]:
            minz = True
    if minx == True and miny == True and minz == True:
        v1 = mat*vert.co
bm.free()
# switch object mode and set active object to the plane to get its vertex data
bpy.ops.object.editmode_toggle()
bpy.ops.object.select_all(action='DESELECT')
bpy.context.scene.objects.active = bpy.data.objects["Plane"]
bpy.ops.object.editmode_toggle()

obj = bpy.data.objects["Plane"]
bm = bmesh.new()
bm = bmesh.from_edit_mesh(obj.data)
bm.verts.ensure_lookup_table()
mat = mat = obj.matrix_world

# get the left-closer vertex's world coordinates and save it to v2. By your sight , this vertex must have minimum x and maximum y coordinates among the others.
# Additional info : if it is that vertex, its x coordinate is lower than upper adjacent , its y coordinate is higher than left adjacent ,its x coordinate is lower than further adjacent so I am searching these in the if and elif statements
for vert in bm.verts:
    minx = False
    maxy = False
    for edge in vert.link_edges:
        vert2 = edge.other_vert(vert)
        if (mat*vert.co)[0]<(mat*vert2.co)[0]:
            minx = True
        elif (mat*vert.co)[1]>(mat*vert2.co)[1]:
            maxy = True
    if minx == True and maxy == True :
        v2 = mat*vert.co
bm.free()
# switch to object mode to move all cube at once , since we got every information we need
bpy.ops.object.editmode_toggle()

# move cube by their difference vector, so it will slide just by their difference value
bpy.data.objects["Cube"].location+= (v2-v1)

EDIT:
I changed my code according to specifications now it gets 4 indexes (2 from cube(or glass), 2 from plane(or face) is enough to allign them)

import bpy, bmesh
from mathutils import Vector
import numpy as np , math

index_1_from_cube = 4
index_2_from_cube = 6

index_1_from_plane = 2
index_2_from_plane = 3

bpy.ops.object.select_all(action='DESELECT')

# set active object to Cube
bpy.context.scene.objects.active = bpy.data.objects["Cube"]
# go to EDIT mode
bpy.ops.object.editmode_toggle()

# get Cube's updated vertex data
obj = bpy.data.objects["Cube"]
bm = bmesh.new()
bm = bmesh.from_edit_mesh(obj.data)
bm.verts.ensure_lookup_table()

# get world coordinate matrix for that object
mat = mat = obj.matrix_world

# get world coordinates of 2 vertices from cube that is planned to allign

v1 = mat*bm.verts[index_1_from_cube].co
v1_for_rotate = mat*bm.verts[index_2_from_cube].co
bm.free()
# switch object mode and set active object to the plane to get its vertex data
bpy.ops.object.editmode_toggle()
bpy.ops.object.select_all(action='DESELECT')
bpy.context.scene.objects.active = bpy.data.objects["Plane"]
bpy.ops.object.editmode_toggle()

obj = bpy.data.objects["Plane"]
bm = bmesh.new()
bm = bmesh.from_edit_mesh(obj.data)
bm.verts.ensure_lookup_table()
mat = mat = obj.matrix_world

# get world coordinates of 2 vertices from plane that is planned to allign
v2 = mat*bm.verts[index_1_from_plane].co
v2_for_rotate = mat*bm.verts[index_2_from_plane].co
bm.free()
# switch to object mode to move all cube at once , since we got every information we need
bpy.ops.object.editmode_toggle()

# move cube by their difference vector, so it will slide just by their difference value
# but after this operation only the 2 vertices will be alligned,
# so we need to rotate it according to second set of points.
bpy.data.objects["Cube"].location+= (v2-v1)

#select the cube again
bpy.context.scene.objects.active = bpy.data.objects["Cube"]
bpy.data.objects["Cube"].select = True

# we will rotate the cube around the first point since the first points are already alligned (we don't need to change this coordinate of cube)
bpy.context.scene.cursor_location = v2
bpy.ops.object.origin_set(type='ORIGIN_CURSOR')

# get unit vectors in order to find a angle and rotation axis
unit_vec1 = (v1_for_rotate - v1 ) / np.linalg.norm(v1_for_rotate - v1 )
unit_vec2 = (v2_for_rotate - v2 ) / np.linalg.norm(v2_for_rotate - v2)

rotation_axis = (np.cross(unit_vec1, unit_vec2))
rotation_degree = np.arccos(np.clip(np.dot(unit_vec1, unit_vec2), -1.0, 1.0))

# rotate the object around first alligned points
bpy.ops.transform.rotate(value=rotation_degree, axis=rotation_axis, constraint_axis=(False, False, False))


Disabling loop slide on the last bevel modifier seemed to do the trick, it doesn't look very smooth though so if anyone has a better answer please post it


How can I create a single image texture from several different, overlapping image textures?

I would create low res versions of the image textures, then bring them all into Blender and apply them to the object material with the various UV maps. (If you bake out the combined low res image you'll have a starting point for after the next step when you have all your high res texture bakes.)

Then bring in the high res image textures (one at a time) and bake out the high res UV texture as applied to the image.

Once you've baked out all the applied high res textures, you should be able to combine them all in an external image editor (alphas included if baked out properly). You can use the previous combined low res bake as a reference.

Then you'll have a single high res image texture. If Blender still cannot handle working with this single high res texture image, you'll have to lower the resolution until Blender can work with it. It should be fine on shots that are not too close to the object in your scene.


Why hair particles not showing the result

In the very bottom of the Particle Settings you will see a section called Cycles Hair Settings. Change the 3 options:

Root
Tip
Scaling

These should make your hair thinner to your choice.

Settings section:


I see 2 problems. I believe you are following Blender Guru's doughnut tutorial. That was the first one I followed as well.

Make sure to use a "Texture Mask"

In the drop-down titled "Brush", choose "Brush Mask - Texture"

After these adjustments your brush should match Blender Guru's brush.
EDIT:
Here is a screenshot of most of my screen:


Glass Volume Material with Caustics and Colored Shadow

You're getting a glow because you're adding two transparent BSDFs, so transmitted light is getting doubled. If you want transparent tint with the fake caustics, you would just multiply the transparent color and the fake caustics mask.

However, normally you wouldn't want to apply any color tint to the transparent BSDF, just the fake caustics. The volume absorption shader will take care of tinting the fake caustics. You can fix both of those node setups by just deleting the add shader and the transparent BSDF connected to it.

Adding color to any surface shader represents a color change that happens at the surface, while the interior is clear. This is usually not the case with glass unless the surface has been covered by a transparent paint. Normally the color is within the glass and the surface is clear, so all color should be in the volume shader.


I finally got it working by adding a "Transform" constraint to the blue bone (target: yellow bone, x: 0-360° -> x: 360-0°). It doesn't work perfectly, but its good enough for my purpose :)


Can an update function common to more than one property reveal which property is using it?

def update_function(self, context, origin):
    if origin == 'firstProp':
        #   do this
    elif origin == 'secondProp':
        #   do that

class MyCollectionProperty(PropertyGroup):

    firstProp = BoolProperty(
            name = "Fisrt",
            default = False,
            update = lambda s, c: update_function(s, c, 'firstProp'),
            )

    secondProp = BoolProperty(
            name = "Second",
            default = False,
            update = lambda s, c: update_function(s, c, 'secondProp'),
            )

use a lambda, which passes the 'origin' to the update_function.

An update_function that prints out the value of the property

def update_function(self, context, origin):
    # - use "origin" argument to pass the member variable being modified
    # - "self" will refer to the instance of the MyCollectionProperty
    print(origin, ':' , getattr(self, origin))

    if origin == 'firstProp':
        #   do this
    elif origin == 'secondProp':
        #   do that


Property Update function for properties inside a collection

I can't tell whether it's a known limitation or bug, but it definately returns the reference to the CollectionProperty only.

You need a concept of one element in the collection being "active", e.g. have an IntProperty alongside and use it for a template_list() for instance. Then use that number to get the right item:

self[context.scene.ppp_index].pfloat = 1.23

There's actually a reference to the CollectionProperty item returned,
see https://developer.blender.org/T39798


Creating mesh on a surface with two variables

The Python function 'acos' has a parameter's domain between -1 and 1. If the parameter is out of this, you get a 'domain error'.

So for instance, you can set the following formula:

acos( (1-sin(x)-sin(y)) % (1 if (1-sin(x)-sin(y)) >0 else -1 ) )

or more simple (using 'fmod' which is C style modulo as Python's native modulo sign rely on the divisor sign)

acos( fmod( (1-sin(x)-sin(y)), 1 ) )

which is limiting the parameter's values.

Or alternatively to have a linear transition, limiting the parameter value like this:

acos( ((1-sin(x)-sin(y)) + 1) / 4 )

The result is the following:

or:

For your information, the math functions available in the addon:

safe_list = ['math', 'acos', 'asin', 'atan', 'atan2', 'ceil', 'cos', 'cosh',
    'degrees', 'e', 'exp', 'fabs', 'floor', 'fmod', 'frexp', 'hypot',
    'ldexp', 'log', 'log10', 'modf', 'pi', 'pow', 'radians',
    'sin', 'sinh', 'sqrt', 'tan', 'tanh']

And these links to stack overflow:

About acos.
About modulo.


Use Multicam Selector Effect in VSE

Add Scene strip
Make as many copies as your cameras (Shift + D + Y + move the strip to a different channel)
Assign a different camera to every Scene strip in the Properties Panel (N)

Add a Multicam Selector Effect and assign the channel of the desired strip

You can either add multiple Multicam Selector Effects, or cut one Strip by placing the cursor at the right frame and pressing a "Cut to" button (1, 2...)

Check Sequencer in the render Panel


How can i make a sort of cloth/leather object?

Example with Cloth Simulation ...

add Cylinder, add horizontal Loop Cuts Ctrl+R 10, to get square net
Invert Selection I
Assign these top/bottom loops (vertices) to a Vertex Group under Properties Editor > Dara > Vertex Group
Add Cloth Simulation and under Cloth Sim Properties > Shape > Pin > choose vertex group
I animated top part with a Hook modifier assigned to Empty, but you can parent Cylinder's top (or bottom) vertices to any specific part of your character
For a final touch I added Subdivision Surface modifier


Offset animated color change over many objects?

(01) (Difficult the first time) A color texture influence driver can be used ... with a numeric [custom property] .. 24, 48, 72 and so on ... on the objects ... object data.  This would not be a lengthy script.
You must locate the target of the script in the outliner datablocks view with great care as depicted below.  This requires effort because it is deep hierarchy .  Most people I  suspect have rarely used the datablocks view. The Blender UI debug info  will not behave as desired. Object location x, y, z scripts have better debug info.  If you attempt to write a texture driver from the properties window it will fail.  Blender will not give warning.  Note the driver is located on the Cube object not its material.  Below I typed a distinctive numeric value of .678, not 0 or 1,into the field to help me locate it in the datablock view.  Note the absence of the driver in the texture panel.

The final render will be correct.
Code

frame > 20

(02) Special case .. if the objects are static and identical with simple color... you may be able to join them and UV Map them together. Use a single texture that is an [image  sequence] to slide the color across them.  Your image sequence may need to be structured as twelve logical strips or color.

(03) Materials and textures are not the same .. I would consider 12 textures ... perhaps copying colors ... and keyframe the color influence of the texture. I am assuming you will not have more than 12.  (I am supposed to avoid asking for clarification according to the yellow box text).  This would avoid a lengthy script.

(04) The more objects you have the more utility of the driver or script.


Why does smoke render as transparent in the OpenGL render?

I would consider that a bug.

It appears that when the smoke flow object is set to Fire or Fire+Smoke it renders transparent with opengl render.

The fire simulator uses it's own material settings to preview in the 3dview - not the material settings that we configure. It would appear that this preview material works in the 3dview but not the opengl render.


It is in fact really easy. Select all the geometry of the object with too many vertices in edit mode by pressing A. Press delete or X, depending on which you prefer, and click limited dissolve.

After that, your mesh will look clean.


Can't get my icosphere to render as a halo

You are using Cycles Render mode. Switch it to Blender Render and the options you want'll apppear.


First of all, select the first button. Then, ensuring you are on frame 1, go to the material tab, and set the colour to it's normal state (the colour you want for when the mouse is not over the button) and press I.

Then, if you want the change in diffuse of the button to be instantaneous, move onto the next frame. If you want there to be a longer transition between the two different states, however, move to a later frame, eg 5. The later the frame you change to, the longer the transition between the two states of the button will be when the mouse is over the button.

Now you are on a different frame, change the colour of the button to what you want, and press I, with your mouse over the diffuse slider.

Now, when you scrub through the timeline with the mouse, in between the beginning and end of the animation you have just created, you should see the colour in the material tab changing (this will not work if watching the animation using AltA)

Now, you can open up the game logic window. Add a "mouseover" sensor, connect it to an "and" controller, and then connect that to an "action" actuator. Just under the button that is currently set to play, there is a box that allows you to chose the animation to run. Clicking on that box opens a drop down box that allows you to chose the animation to play - there should only be one as you have only created one animation thus far, so simply choose the only animation in the box (if you already have more than one animation in your scene, you will have to make sure you chose the animation that you just created for that button - you can see the names of animations in the top left window if switching to the "animation" view instead of "default" or "game logic" at the top of the blender window.)

Next, there is the action playback type. This is above the animation box, currently set to "play". Changing the animation type to "flipper" means that when the mouse moves over the button, the animation will run and the colour will change, but when the mouse is moved off the button, the colour will change back. If it were left on play, it would not change back when the mouse moves off the button.

Next there is the start frame and end frame. Set the start frame of the Action to 1, as this is the frame of the start of the animation you made earlier. Then, set the end frame to the frame when the diffuse animation ended.

Now, when the mouse is over that button in the game engine, the colour should change, and when the mouse is no longer over the button, it should change back.

Once you have tested that works, repeat the process for your other buttons. Make sure they all have different materials, as, otherwise, when one button changes, they may all change.

Note: this will not work if there is a texture on the button plane, that would require you to have an orange and a white button (one on top of the other) and to fade between them with a similar method to above, but changing the opacity instead of the colour of the slider.

Finally, something to be aware of is the animation you choose in the action actuator. Make sure you choose the animation for the button you want to change, because there will be more than one animation in the drop down box once you have created different animations for different buttons.


How to assign different faces of the same object different materials?

Click "+" to add a new material slot
Set the material
Select the desired face(s) and make sure the added slot is selected
Click "Assign" button

You should see it in the viewport (solid) now


The problem is mostly a result of aspect ratio of the zodiac image - ie, being much wider than it is tall.

Image Texture coordinates run from 0.0 - 1.0 in both the horizontal and vertical direction, regardless of the actual resolution of the image. Since the 'blur' acts on these image texture coordinates this means that the effect of the blur in one direction is much more pronounced than that in the other direction. To address this, you need to scale the texture coordinates before the 'blur' (in this case by a factor of 12) and 'un-scale' them after. This can be easily achieved by using Mapping nodes with the X-scale set to '12' and '1/12' respectively.

I also simplified the blur node as the original seemed to also introduce an offset.

This produces the following result :

Note that for this I also changed your mesh lights into Area Lamps. These produce better lighting and allow the number of samples to be considerably reduced with the same resultant quality.


Yes, this is possible, although you will need to use the tripod solver. Also, you will have a difficult time doing a 3d scene reconstruction, because blender can't track depth in a panning-only shot. Also, make sure there is no zooming, as blender doesn't handle that correctly as of yet. Finally, make sure you have a decent number of solid keyframes (10ish) at each frame, and that the trackers are getting disabled AS SOON AS they begin to deviate (or be "obscured" by the edge of the screen).
Here are is the "Ultimate" BSE answer on motion tracking (required reading for anyone interested in blender's motion tracker):
https://blender.stackexchange.com/a/42332/28015


One work around for the problem of not being able to see which mesh is selected (because the  edges are blocked from view); is to turn on display Wire.

In the Properties window on the Object tab, under the Display category there are several options for different things that can be displayed in the 3D view along with the object. Check the button for Wire and Draw All Edges, then the edges will be overlaid on on mesh, which when selected will change to be the selection color.

I have created an addon called Selected Wireframe that will turn on Wire and Draw All Edges for all the selected objects. It will respect the object's wire and Draw All Edges settings, and leave the object unchanged when not selected.

Usage is simple, after installing and enabling the addon, just click the Show Wire button in the Tools tab of the Tool Shelf. Then when you do not want the wirefrmes displaying on the selected object, click the Hide Wire button in the same place.


Maybe you turn off the render in the outliner tab?


How to add a seam to my cloth bag? Can't get edge loop to shrink in the right way

did you check this tutorial? youtu.be/Ebx2qbBlvh0?t=555 – sanbaldo 10
  mins ago


You can select one of the vertices in the UV editor and press CTRL + L to select that patch of your mesh. Then you can move it slightly to correct the position.
To mirror simply scale by -1 on one axis.


Before your Wave node, put in a Texture Coordinate node (using generate) and this goes into a Mapping node. You can then modify the rotation (depends on your orientation) but here is my setup with a before shot and after shot

Before:

After:


UV mapping - nothing shows in UV / Image Editor

When I have this problem, I simply just have to create a new image (named whatever you like) in the UV/Image editor window. After you've done so, try unwrapping your model again from the 3D view.

Also, selecting all of your model in edit mode (A key) helps to see the map reflected in the UV/Image workspace.


How to correctly LOCK motion tracking points so they don't move after reloading movie clip?

As I remember; from the introduction of the tracker, it was always suggested to export a movie to an image sequence. This is to prevent decoding changes/errors to frames when scrubbing through, skipping and reversing direction, as all these conditions can affect the decoding process.
The symptoms of the problem you describe sound exactly like this problem.
I would suggest you convert your movie into individual frames, and then work on that image sequence.


Constraints and Inverse - Needs Some Explaining

If you use set inverse:

the object get parented as it is
the child won't be affected by the initial transformation of the parent

If you use clear inverse:

the parent transformations get cleared (momentarily)
the object get parented
the transformation of the parent get is restored (as if you have parented then transformed the parent which will effect the child)

all this is just setting the matrix that relates the child to the world space

To keep the object transformation inherited from the parent, apply the visual transformation and set the influence to 0 (or remove the constraint).

Example: two cubes one at the center (will be used as parent)
initial state: (no constraints yet )

the parent transformed: (no constraints yet) the cube moved scaled and rotated

after this we add the child of constraint to the smaller cube

child of constraint with set inverse: child is not affected by the parent initial transformation

child of constraint with clear inverse: child is affected by the parent initial transformation


Oh, that's weird.
This typically happens, when you check ✓ Filter Add-ons in the Tool tab.


I think you are looking for Fluid Control.

I recommend reading the fluid simulation documentation in it's entirety.  It's not long, but covers the topic well and highlights some things to watch out for i.e making sure your obstacles are within the domain.

There are also endless tutorials on youtube and clones.


How to make square sides curved like Cylinder?

Start with a plane.  Tab into Edit Mode, select the face and press X and select Only Faces.  This leaves you with 4 verts connected by edges.

Tab out of Edit Mode and go to the menu item Object > Convert To > Curve.
Then in Object Data Properties expand Geometry and give it a Bevel Depth.

This should work for any continuous loop of verts.

It is possible to do this with more complex meshes, but they will require some work to look good since the corners only connect up on the longest continuous path.  Every other edge will be its own curve with disconnected control points.  Example:


What's right topology for a concave polygon?

If I understand you correctly you want to get rid of the soft edges that are produced by the subsurf/multires modifier? You may want to look if you can fix that by setting the mean crease in the object's option bar to 1.

You possibly need to play around with the value for different edges but usually it gets the job done.


How can unused tracks be removed from the NLA?

This behavior has been changed after 2.66a. Just tried to discuss with the designer. As explained, it is one of the main ways to prepare some places to add NLA strips from pre-made actions, and got its advantages, too.

To make them invisible, click the third toggle on the header to exclude them from displaying.


Put picture from imported pic as vertex paint and engrave / extrude the shape from other object

Usually this is how I do it....

Convert the Jpg or Png into SVG format. You can find a
free online converter on google search. Keyword to search
is "Converter Jpeg to SVG" or "Converter Png to SVG".

You can then import the SVG format as a spline. With the
spline, you could then convert it to mesh. Fill those faces
and extrude those faces.

To cut the words into a cube, you would use the boolean or
booltool ( An easier and a better way to work) in Blender
to accomplish the task.

NOTE:

You may have to watch a few topics on youtube on the subject
I have pointed you to. Else there will be too much instruction
to write up.


The best way I'd do this is by mixing different noise textures with a Mix RGB node, and using a high contrast noise texture as the fac of the mix RGB node. I'd the add a color ramp at the end to get the colors you want.

The image below is a simple node setup mixing the two noise textures with a high contrast noise texture fac.

The image below is a bit more complicated, but is creates more detail in the texture, and more can be changed and customized.

This final one is to show how much you can do to modify the texture to your needs.

There is no specific hack to making certain textures. It is mostly just using what you have properly to make what you want. I hope I helped. If you have any questions let me know.


Cycles - Skybox using 6 projected images

Blender's environment texture in Cycles only supports Mirror Ball and Equirectangular image map types. You cannot use a skybox texture directly.

Some of your options are:

Convert the skybox image to one of the other 2 formats in a third party image convertor.
Set Blender native environment to pure black. Create a large cube object that surrounds your scene, UV unwrap and add the skybox image texture to that object.
Find a new sky image in Equirectangular or Mirrorball format and use that instead

Blender's internal render engine (BI) does seem to support additional mapping types (Object, Tube, Sphere, Global). Perhaps you could use the Object mode to base the mapping on a cube object but displayed as the world environment. I've not tried or tested that technique though.


UV Faces Proportionally Incorrect After Unwrap

Jachym was correct.  Selecting the Conformal method in the UV options solved it.


Marks to @3pointedit for likely getting close to the answer. The rest appears to be a stream of complificationingeering.

In all likelihood what you are seeing as “saturation” is actually a byproduct of an incorrect curve. The source of the problem is likely that your “source” reference analysis was being decoded incorrectly. Where that is entering the chain is going to be tricky as heck to diagnose.

Any codec is transformed to the YCbCr domain. In doing so, the RGB values should remain (quantization errors aside) very close to your source file RGB.

I can see that the “Source” file looks much more contrasty, which suggests to me that your player you are evaluating the material in is likely not decoding your footage correctly.

Any transform from RGB to YCbCr is typically done to the specification, which stipulates a broadcast range scaling. This scaling changes the 0-255 RGB values to 16-235 and 16-240 range on the YCbCr planes respectively. Those scaled values are, assuming players behave correctly, scaled back to their proper positions on decode.

What I suspect is happening is that the original “source” decoder is likely assuming, absolutely incorrectly, that your Nikon footage is broadcast scaled and chopping off a significant range of values and scaling the remaining values. This ends up making your image much more contrasted, as well as being incorrect.

DSLRs and some pocket cameras introduced a nonstandard “full range” YCbCr encoding which uses the full 0..255 range of the YCbCr stream. Sadly, many decoders decode it incorrectly, and you end up seeing hyper-contrasted images. See that “Range” tag in the data dump? Frequently too, the decoder will use the wrong set of luminance coefficients to decode the footage, which results in colour skew.

There are also a plethora of other areas where an encode to decode chain might go wrong. I outlined some of those tricky steps in another answer here.

Best advice is to check your source footage decode in a few different players. I suspect that, while potentially not perfect, the FFMPEG libraries Blender is using are trying to give you the full range of your shot’s data, as it is decoded from the raw YCbCr values. The result will be a slightly flatter image with much more dense data, which ends up being much more optimal for grading and a better resultant image.

All of that said, how to match a look?

Creative grading is most optimally achieved using a nodal system, frequently non-realtime. Assuming the guess above is correct, you can figure out what portions of your footage you intend to use and grade them in the compositor. It will be a little tricky because of some colour things that are beyond the scope of this answer, but should be achievable. Try an ASC CDL node with a slight increase in Power, and possibly a very slight decrease in Slope.

Bottom line is that there is a better than average chance the decode you are seeing in Blender is closer to the intention of your source stream than what you are seeing in Random Video Player. Test against VLC, FFPlay, or even the free version of DaVinci Resolve.

Your curve is not delivering the result you appear to desire because you have applied a simple arc to it. What it sounds like you are wanting is a subtle ‘S’ shaped curve that rounds off the lower left to a hump towards the upper right.


Python script not working beyond a certain line in the code

I have copy-pasted the code in blender and with few changes, same variable wrong names like TObjIRM and TOBjIRM for the same var, include import bmesh at beginning,... the code works now without errors.
This is what you want? ;)

import bpy, bmesh
from mathutils import Matrix
from math import pi

class OrientLocalAxis(bpy.types.Panel):
    """Orients Local Axis to another Object without changing current
Structual view"""
    bl_label = "Orient Local Axis to object"
    bl_idname = "OBJECT_PT_OLAxis"
    bl_space_type = 'PROPERTIES'
    bl_region_type = 'WINDOW'
    bl_context = "object"

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

        row = layout.row()
        row.label(text="Active object is: " + obj.name)
        layout.prop_search(scene, "Epty", scene, "objects")

        row = layout.row()
        row.operator("object.align_local_axis")

def main(context):

    #-------------Obj = Object we want to change----------------------------
    #------------TObj = Target Object we want to Align to-------------------

    scene = bpy.context.scene
    TObj = scene.objects[scene.Epty]

    TObjIRE = TObj.rotation_euler
    TObjIRM = TObjIRE.to_matrix()

    ObjIRE = bpy.context.active_object.rotation_euler
    ObjPos = bpy.context.active_object.location
    # We will need this later for rotating the mesh
    ObjIRM = ObjIRE.to_matrix()

    #We Find out the Rotation Matrix to transform TObj to Obj---------------
    # We will use this transform the mesh back to its original orientation--

    ITM = ObjIRM  #ITM is for Inverse Transformation Matrix

    # We set the orientation of the Object to the target

    bpy.context.active_object.rotation_euler = TObjIRE

    #Now we go to Edit Mode and select all Vertices

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

    mesh = bmesh.from_edit_mesh(bpy.context.active_object.data)

    for v in mesh.verts: # Not sure if selection is needed Check Later
        v.select = True

    bpy.context.scene.objects.active = bpy.context.scene.objects.active

    bmesh.ops.rotate(mesh, cent=(0,1,0), matrix=TObjIRM, verts=mesh.verts)

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

# Operator Definition

class AlignLocalAxis(bpy.types.Operator):
    """Tooltip"""
    bl_idname = "object.align_local_axis"
    bl_label = "Align Local Axis"

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

 #--------------------------------------------------------------------------
def register():
    bpy.utils.register_class(AlignLocalAxis)
    bpy.utils.register_module(__name__)
    bpy.types.Scene.Epty = bpy.props.StringProperty()

if __name__ == "__main__":
    register()


Blender 2.9x
There are four locations that show the version in varying level of detail.
Splash screen

Status Bar

About Blender

Export System Information

===========================================
= Blender 2.91.0 Alpha System Information =
===========================================

Blender:
===========================================

version: 2.91.0 Alpha, branch: master, commit date: 2020-08-06 17:52, hash: 9a1ff4445b98, type:
build date: 2020-08-06, 21:59:05

Blender 2.8x
There are three locations that show the version in varying level of detail.
Splash screen with the name of the release

Status bar with the version number

Help > Save System Info detailed information including the commit hash

Excerpt from the system-info.txt
============================================
= Blender 2.80 (sub 75) System Information =
============================================

Blender:
============================================

version: 2.80 (sub 75), branch: master, commit date: 2019-07-29 14:47, hash: f6cb5f54494e, type:
build date: 2019-07-29, 09:44 AM


Is there a list of the node names for the node_tree.nodes.new() function in blender 2.82?

I think this will give a list of all names. Note that which ones you can add depends on the type of node tree eg. you can't add "CompositorNodeXXX" nodes to a shader node tree.
[
  name
  for name in dir(bpy.types)
  if issubclass(getattr(bpy.types, name), bpy.types.Node)
  if getattr(bpy.types, name).is_registered_node_type()  # exclude base classes like Node
]

An easier way to find them, IMO, is if you have "Python Tooltips" turned on in prefs, you can hover over the items in the "Add" menu to see the name to use.


radially equidistant "melting" of image onto spheroid (head) - reverse of equidistant azimuthal projection

A solution based on Python (image and svg found here) :

The script :

import bpy
import bmesh
from math import *
from mathutils import Vector

#Reposition the mesh vertices calculating a 'reverse of equidistant azimuthal projection'
def reverseOfEquidistantAzimuthalProjection( model, propFactor = 1 ):

    rad90 = radians(90.0) #A way to have pi / 2

    modelData = model.data

    #Calculates vertices boundings (relative to vertices coordinates, because of the case of a not centered mesh)
    minX = min( [v.co[0] for v in modelData.vertices] )
    maxX = max( [v.co[0] for v in modelData.vertices] )
    minY = min( [v.co[1] for v in modelData.vertices] )
    maxY = max( [v.co[1] for v in modelData.vertices] )

    #Center in X and Y, we consider here a flat mesh in Z
    centerX = (minX + maxX) / 2.0
    centerY = (minY + maxY) / 2.0
    center = Vector( [centerX, centerY, 0] )

    #Radius of the projection
    baseRadius = (maxX - centerX)

    for v in modelData.vertices:
        pos = Vector( v.co )

        #Position relative to center
        posXY = pos.xy - center.xy

        #Proportionality of the vertex relative to the radius
    #Between 0 and 100% where 0 corresponds to north pole and 100 to south
        prop = posXY.length / baseRadius

        #Conversion to -90 (south) / +90 (north) (in rads)
        angle = rad90 - (prop * pi)

        #Relocation in X and Y : cos(angle) gives the radius of the cut
        posXY.normalize()
        posXY = posXY * baseRadius * cos(angle) * propFactor

        #Set the vertices new coordinates
        v.co[0] = center.x + posXY.x
        v.co[1] = center.y + posXY.y
        #In Z : keeps the eventual Z value and place the point relatively to that
        v.co[2] = v.co[2] + sin( angle ) * baseRadius * propFactor

model = bpy.context.object

reverseOfEquidistantAzimuthalProjection( model )

The first experiment is based on a circle extruded and cut :

I have also try to use the svg symbol of the United Nations. Some difficulties :

The curves are in a lot of parts (you may have to select them all, convert to mesh and join them)
Edges are made 'as they come', so applying the script gives some unwanted results (some edges may have to be removed manually)


How to create mesh surface using csv datapoints?

You could try MeshLab is free. Here is a video: https://www.youtube.com/watch?v=38mt3kpsxd4


import bpy
override = {}
override['window'] = bpy.context.window
override['scene' ] = bpy.context.scene
override['screen'] = bpy.context.screen
override['area'  ] = bpy.context.screen.areas[2]

for region in [r for r in bpy.context.screen.areas[2].regions if r.type == 'WINDOW']:
    override['region'] = region
    bpy.ops.view3d.view_all(override, center=True)


When Project onto Self is disabled, you can only snap to geometry of other objects.
It's useful when you go to Edit mode with multiple objects at once.
Notice I can only snap to the other object's vertices unless I enable Project onto Self.


Reacting to changes to a Python defined RNA Property

Yes, for any property, you can define a set and update callbacks.

These are functions you define, passed as an argument and called by Blender whenever the property changes.

get - you can return the value and store it wherever you like.
set - you're responsible for making sure the new value is stored/modified.
update - is called after setting, often used to ensure related data is updated.

See: http://www.blender.org/api/blender_python_api_2_75_release/bpy.props.html#bpy.props.EnumProperty

In the example above, you would have to set the callback on the hdri property definition.


How to rotate individual objects in an array modifier around their own origins

No.

Modifiers operate on mesh data, so the array modifier must take an initial mesh and output a resulting mesh which another modifier can operate on.
This means that the array modifier copies every vertex, edge, and face in your initial mesh for every duplicate it creates (storing the same data multiple times). Also see Applying Array Modifier - Still instance? and What techniques have been used to repeat geometry or other detail to the infinite horizon?

TL;DR: The array modifier doesn't operate on an object level, so there are no "objects" to rotate without applying the modifier and separating loose parts.
Essentially modifiers are stuck with working in edit mode.

The closest you can get is destructively rotating the initial mesh, however this will change the dimensions of the object (unless the object is a sphere), potentially giving unwanted results if you are using Relative Offset:


I think it's because your object is closed (so it's dark inside).

And it looks like IkariShinji gives the solution in blenderartists.org: "Making the backfacing faces transparent for the camera doesn’t automatically make them invisible to shadow rays."

So here is the kind of node organization you need to have to make your object transparent again, please tell me if it works:


How can a RGB color value be copied from reference image or render?

Blender can copy any color value from the 3D viewport directly into the color widget.
The little icon "Sample data block from the 3D view" allows to pick a color value:


Flat surface sculpts along length, not evenly

try appllying scale by hitting ctrl-A apply scale  blender works weird when scale of object is not 1


Check your output setting in the render tab:

after the image has rendered it will be in your UV editor, then you just need to save as: