How can I generate an object from a mathematical function?

Have used the equations found here http://www.econym.demon.co.uk/isotut/real.htm#heart1
The first can be crunched into XYZ surface.  Notice the use of fabs(...) in the A helper function.  The abs(...) method is not in the list of allowable methods and creates an error.

Here is some code for the second. Which required a mapping from spherical coordinates.  Run the code to produce a heart mesh.  Change the line h = heart(1.0, 1.0, 0.2) to produce other hearts.
import bpy
import bmesh
from math import degrees, radians, sin, cos, tan
from mathutils import Vector
from bpy import context

class SphericalCoordsPoint:
    @property
    def xyz(self):
        theta = self.theta
        zi = self.zi
        x = cos(theta) * sin(zi)
        y = sin(theta) * sin(zi)
        z = cos(zi)
        R = self.R
        return R * Vector((x,y,z))

    def __init__(self, R, theta, zi):
        self.R = R
        self.theta = theta
        self.zi = zi
        #self.xyz = self.point(theta, zi)

    def __repr__(self):
        return "SphericalCoord(%.4f, %.4f)" % (degrees(self.theta),
                                               degrees(self.zi))
# define the heart method.
def heart(a, b, c):
    def heart(v):
        x = a * v.x
        y = b * (v.y -pow(abs(v.x),0.8))
        z = c * (v.z)
        return Vector((x, y, z))
    return heart

# make the heart bmesh
bm = bmesh.new()

# TODO come up with a nicer way to do this.
sphere_rings = [[SphericalCoordsPoint(1, radians(theta), radians(zi))
                 for theta in range (0, 360, 10)]
                 for zi in range(0, 181, 10)]

h = heart(1.0, 1.0, 0.2)

verts0 = [bm.verts.new(h(p.xyz)) for p in sphere_rings[0]]
verts0.append(verts0[0])
for ring in range(1, len(sphere_rings)):

    verts1 = [bm.verts.new(h(p.xyz)) for p in sphere_rings[ring]]
    verts1.append(verts1[0])

    faces = [
        bm.faces.new((
            verts0[i], verts1[i],
            verts1[i+1], verts0[i+1]
        ))
        for i in range(len(verts0) - 1)
    ]
    verts0 = verts1

# create mesh link it to scene etc
mesh = bpy.data.meshes.new("heart")
bm.to_mesh(mesh)
obj = bpy.data.objects.new("heart", mesh)
scene = context.scene

context.collection.objects.link(obj)
context.view_layer.objects.active = obj
obj.select_set(True)
obj.location = scene.cursor.location

which produced this result filled like the UV sphere (the node is in the middle of the heart

Can change the shape by tweaking the scalars in the heart equation. For example
def heart(v):
    x = v.x
    y = v.y -pow(abs(v.x),0.8)*1
    z = v.z * 0.5
    return Vector((x, y, z))

EDIT: this can now be done with h = heart(1.0, 1.0, 0.5)
produces

Samples of both using Spherical and Toroidal spaces

Another similarish object is the cardioid


Rendering image causes zoom in and texture turns the scene black

Based off of these images, this is a simple matter of your outdoor scene being unlit.  In Blender 2.79, press spacebar type "add lamp", and choose "Sun" in the resulting menu.  Feel free to add other lights as appropriate.


How to move forward or any movement which has surface deform modifier

In your case, the idea is to take what can be "the main" object to drive all the other ones. If we take the force field and make it parent of the plane (flag like) then the force field will be the parent for all:

Select the flag plane then Shift select the force field and CtrlP then choose 'Object'.

Now add a curve, make the force field follow a path, adding this constraint:

The minus X is due to the force field orientation (rotated).

And...

To change the speed, select the curve and change "Frames" (the greater the slower):


In Blender 2.8. If you don't want any glow effect, don't enable it.

Disable the Bloom here.

Now if you want to keep the white highlight on your model, this will be done with either the material, either by cranking up the main light's strength, either both.

This could be an example of material:


How to fix and reshape messed up shapes in sculpt mode

What exactly are you trying to fix with the hands? From what I understand after reading your question, I assume you want to fix the right hand of the fetus since there are only four fingers, right?

If the fingers were the problem then I would go ahead and delete them. I would then create new geometry to fill up the holes where there used to be the fingers ( using the boolean operator Union to join the new geometry to the fetus's hand). After that, I would use the "snake hook" brush to pull out new fingers (enable Dyntopo when doing this step so that the brush can pull out enough geometries to form new fingers).


Bevel modifier doesn't work with imported LEGO brick mesh (OBJ file)

The topology is bad:

You have overlapping vertices, you need to select all and AltM > Merge By Distance.

Transform your tris to quads with AltJ

Your top cylinders are not part of your base cube, so there won't be any bevel on their bottom, you need to correct your geomatry if you want that.

Also their top and bottom are not perfect circle, select each circle and right click > LoopTools > Circle.

In the Properties panel > Object Data > Geometry Data, clear the Custom Split Normals Data to have correct normals.

Give your object the Bevel modifier.


There are several approaches to 'add' more polygons

Subdividing

You can open the menu 'specials' by pressing W while beeing in edit-mode, where you can find 'Subdivide' and 'Subdivide Smooth'.

https://www.blender.org/manual/modeling/meshes/editing/subdividing/subdivide.html

Note: In the Toolbar (toggle with T) options will be displayed.

You can press Ctrl + R to cut edges. This will add more polygons.
https://www.blender.org/manual/modeling/meshes/editing/subdividing/loop_subdivide.html

Mesh adding

By pressing shift + A you can open up the mesh-menu, where you can select and insert a mesh.

Extruding

By pressing E you can extrude your selected vertices, edges or faces.

https://www.blender.org/manual/modeling/meshes/editing/duplicating/extrude.html

There are multiple extrude-modes that you can find pressing space and tiping 'extrude'. That will display all actions with 'extrude' in their name.

Insetting

By pressing I Takes the currently selected faces and creates an inset of them, with adjustable thickness and depth. If several faces are selected you can choose to inset them individually.

https://www.blender.org/manual/modeling/meshes/editing/duplicating/inset.html?highlight=inset

Knife Tool

By pressing K you can open the 'Knife Tool' where you can cut faces, what will create more polygons.

https://www.blender.org/manual/modeling/meshes/editing/subdividing/knife_subdivide.html?highlight=knife

Joining

Although this can't be made in edit-mode. In Object mode select multiple meshes and join them pressing Ctrl + J


Shadow from texture not showing up because of a transparent shader

Transparency Shadows

While the Blender Manual page says:

  For direct light sampling, use transparency of surfaces in between to produce shadows affected by transparency of those surfaces.

the tooltip is perhaps more clear:

With that option disabled, as in your case, the alpha channel of the texure won't be considered for shadows so you'll get the light occusion from the actual geometry (a plane).


Update a custom data field created with an addon

On load handlers.
One way to approach the load event is with a persistent load post handler. However many side cases will be missed by it. Addon first enabled.  An appended object with the old prop.
bl_info = { # fill in to test as addon
}

import bpy
from bpy.props import PointerProperty, BoolProperty, FloatProperty
from bpy.types import PropertyGroup

class Foo(PropertyGroup):
    bar : BoolProperty()
    foo : FloatProperty()

classes = (Foo,)

@bpy.app.handlers.persistent
def convert(dummy):
    old_key = "prop"
    new_key = "foo"
    print("Convert")
    obs = [o for o in bpy.data.objects if o.get(old_key)]
    if obs:
        print("Converting...")
        for o in obs:
            if o.get(old_key):
                o[new_key] = o[old_key]
                del o[old_key]

def draw_test(self, context):
    layout = self.layout
    layout.prop(context.object.foo, "foo")

def register():
    for cls in classes:
        bpy.utils.register_class(cls)

    bpy.types.Object.foo = PointerProperty(
            type=Foo,
            )
    bpy.types.TEXT_HT_footer.prepend(draw_test)
    bpy.app.handlers.load_post.append(convert)

def unregister():
    for cls in reversed(classes):
        bpy.utils.unregister_class(cls)
    bpy.app.handlers.remove(convrt)

if __name__ == "__main__":
    register()

Copy Custom Properties from one object to another  Can ignore the '_RNA_UI' in this case, since its members are emulating those defined by the bpy.props property for drawing the prop in the UI. (name, min, max, soft_min etc).
Consider wiring into panel code.
Instead could roll back the panel to do no more than alert that an old property is set on an object and the fix button.
Example below, a red splash screen button is displayed if an object in the file is given a custom prop named "prop".
import bpy
### hacked in by way of example
class AS_placeholder_properties(bpy.types.PropertyGroup):
    foo : bpy.props.BoolProperty()
    pass
bpy.utils.register_class(AS_placeholder_properties)

bpy.types.Object.AS_placeholder_properties = bpy.props.PointerProperty(
        type=AS_placeholder_properties,
        poll=lambda self, obj: obj.get('AS_placeholder') is not None,
    )
####
class HelloWorldPanel(bpy.types.Panel):
    """Creates a Panel in the Object properties window"""
    bl_label = "Hello World Panel"
    bl_idname = "OBJECT_PT_hello"
    bl_space_type = 'PROPERTIES'
    bl_region_type = 'WINDOW'
    bl_context = "object"

    @classmethod
    def poll(cls, context):
        old_prop = "prop"
        if any(ob.get(old_prop) is not None for ob in context.blend_data.objects):
            cls.draw = cls.convert
        else:
            cls.draw = cls.draw_normal
        return True

    def convert(self, context):
        layout=self.layout
        layout.alert = True
        layout.operator("wm.splash") # convert op

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

        obj = context.object
        row = layout.row()
        row.prop(obj.AS_placeholder_properties, "foo")

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

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

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

if __name__ == "__main__":
    register()

The poll method above could instead test if your convert operator polls
if bpy.ops.object.convert2newpropname.poll():

intrigued by the poll method used for property group above. Would seem to always poll unless class is totally passed in which case will be boolean False. (eg comment out foo boolean above)  In as much as the bpy.props is defining the class and creating the custom prop, IMO always safest to use
ob.get("custom_prop_name")

or
ob.get("custom_prop_name", some_fallback_other_than_None)


You actually don't need any addon for it in 2.8. You just select Loop Cut on the left side bar and each time you click, new loop cut appears. Then you can hold down the mouse button to slide new loop but as a default it stays in place and you can keep clicking and adding loops.


How to combine two objects? Blending a face into an apple?

With these many vertices, aligning the verts is difficult. If you know how to scupt, try to sculpt the meshes first. Otherwise, make the vertex count the same on both meshes first, then bridge the edge loops and use the shrinkwarp modifier to create a good shape. Attach the blend file if you can, so that we can help you better.


how to know which pivot object is using (Local/World)

Snap Cursor to Selected to see the coordinates.  Then look at the cursor coordinates.
Shift S

That cursor information is already showing in your images in your original question.


This (poorly lit) example manages to get the kind of effect you're after. This is a question where a screenshot of your node setup for the glass material would really help.
The first thing to understand is that your bowl is not ceramic. Ceramic is neither transparent nor translucent. The effect you're after comes from translucent/opaque glass. But before you go diving for the Glass shader think about combining a Glossy and Translucent shader for volume, with SSS to further scatter light over the surface area.
Also key is the light source. I positioned a Sun lamp behind my bowl to give me the shadow through the bowl as you have done. I can also adjust the Sun's size to increase or decrease the shadow's edge within the bowl. (There's also a little Ambient Occlusion in the scene but this shouldn't affect the bowl shadow).


What are the parameters event and full_event of UILayout are for?

'event' and 'full_event' parameters allow to get a keystroke value.

'event': a key with no modifier
'full_event': a key with modifiers

Here is a sample code:

import bpy

class HelloWorldPanel(bpy.types.Panel):
    bl_label = "Hello World Panel"
    bl_idname = "OBJECT_PT_hello"
    bl_space_type = 'PROPERTIES'
    bl_region_type = 'WINDOW'
    bl_context = "object"

    keymaps = []
    keymapitem = None

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

        obj = context.object

        #Allow to get a key on a locally defined property
        layout.row().prop( obj, "myProperty", event = True )
        #Allow to get a key: no, does not work
        layout.row().prop( obj, "myProperty", full_event=True )

        #Allow to get a key on an existing property
        layout.row().prop( context.scene.game_settings, "exit_key", event=True )

        #Allow to get a full event key on a keymap item
        layout.row().prop( HelloWorldPanel.keymapitem, "type", full_event=True )

def register():
    #Enum property to define the allowed keys for this property
    bpy.types.Object.myProperty = bpy.props.EnumProperty( items=[('A','A',''),('LEFT_CTRL','LEFT_CTRL',''),('LEFT_ALT','LEFT_ALT','')] )
    bpy.utils.register_class(HelloWorldPanel)

    #Create a keymap and a key
    wm = bpy.context.window_manager
    km = wm.keyconfigs.addon.keymaps.new(name='Test', space_type='EMPTY')
    kmi = km.keymap_items.new(HelloWorldPanel.bl_idname, 'LEFT_SHIFT', 'PRESS')
    #Store them here
    HelloWorldPanel.keymaps.append(km)
    HelloWorldPanel.keymapitem = kmi

def unregister():
    bpy.utils.unregister_class(HelloWorldPanel)
    del bpy.types.Object.myProperty
    wm = bpy.context.window_manager
    for km in HelloWorldPanel.keymaps:
        wm.keyconfigs.addon.keymaps.remove(km)
    del HelloWorldPanel.keymaps[:]

if __name__ == "__main__":
    register()

Some explanations and remarks:

For a locally defined property (myProperty in the code above): the property is an enum which defines the scope of the possible values. But it seems that the user will not be warned if she/he choose a not wanted value.
You can use it for built in properties, like 'context.scene.game_settings' above.

But in both previous cases, I've found no solution to use 'full_event'.

Last example using a keymap item. Here choosing its type as attribute allows the usage of 'full_event'.

I don't know why some are working with 'full_event' and not others, as the enum described in the documentation seems to be the same. See the documentation here.


How do I assign drivers with the eyedropper?

You click with the left mouse button on  the eyedropper and then with left mouse button (yes both times with Left mouse button) on the mesh, which you want to be driving one. If that doesn't work, reinstall your Blender, cause there is no way it shouldn't.


Both must be aligned.

The automatic weight will find the closest mesh to deform.

See the test below.

The first test: I aligned the first and make parenting with authomatic weights. It deforms perfectly.

The second test: I just apllied the same parenting but with armature and object not aligned. It will deform just the mesh closed to the bones.


You can get it using bpy.app.binary_path

Blender's API docs say:

  bpy.app.binary_path:
  The location of blenders executable, useful for utilities that spawn new instances`


Models extracted from gamre (LOL) get "mirrored"?

You could simply scale the object. In this tab, go down to "Scale:" and set the X value to negative.


Version control for blender
There is no special version control system for blender. Your three main choices are git, Mercurial, and SVN.
While I have used git for blender projects and it works (here is a game that was created in a group and was version controlled in git) it is not the best suited because git does not handle binary files, think images and blend files. There is an addon that integrates git in to blender, and let you see and save versions of your file.
SVN is svn and you need a server set up to run that. (The Blender institute has used SVN for their open movie projects).
Mercurial (while I personally have not used it) is best suite to use for Blender. It has the simplicity of git, and (somehow) it can diff binary files.
CG cookie has a good video about setting up version control for blender.
Project Structure
File linking in blender is a pain, but it is the only way to work together in a group.
Say you have one main file, then you will link in the assets that are all separate files. Being separate files enables each person to work on a different piece of the whole at the same time.


Blender Material Preview Transparent Objects Bug (2.91)

This is an AMD Radeon drivers issue. Roll back to July's update (20.7.2) and you'll be back in business.


You probably can not add an armature (bone) because you may be in edit mode. If you are in edit mode, then exit, and go to object mode. Then you can add an armature, and use it to rig the sphere. Could you please add an image? That would be very helpful.


How to fade out loudness of an audio track?

highlight the strip, open panel (press N  if closed), find the Volume field and change the value.

You can animate the value, set to zero at the last frame and keyframe it by pressin I while hovering it, than $1$ (or any other) several frames earlier.


recalculate keyframe position after moving an animation

Hi solution is very easy - add empty "Shift+A" -> "Empty" - choose one. And make this empty as parent of this objects: select all objects (with shift) and as last select empty (empty must be active object). Press "CTRL+P" -> "Object (Keep transform)". Now you ca move/scale empty and all object will follow it. Works also for animation.


Given location(x,y,z), check if object exists at that position

If purely creating the random objects...

Here is a test script that places 100 cubes  in scene with integer location components x, y, z selected randomly from range [-10, 10]

Each random location could be added to a list or set when assigned and its contents checked x in [0, 1, 2] Instead I've chosen to use  defaultdict(list), which behaves like a dictionary that returns an empty list() if there is no value for that key.   An empty list is Boolean False ie there is no object in that location..

>>> dd = defaultdict(list)
>>> dd["missing"]
[]

The tuple (x, y, z) is used as a key.    If the key is taken, choose another random number combo, otherwise append to the list of that key marking as taken,  until all cubes placed.

import bpy
import numpy as np
from collections import defaultdict

ncubes = 100
locations = defaultdict(list)
i = 0
while i < ncubes:
    loc = tuple(np.random.randint(-10, 10, 3))
    if locations[loc]:
        continue

    locations[loc].append(i)
    bpy.ops.mesh.primitive_cube_add(location=loc)
    i += 1

Without checking against already existing objects in a scene this is pretty much purely a python problem. A good place to find answers to python questions is https://stackoverflow.com


how to use external values as input for color ramp shader node?

You can loop over every vertex after initializing different arrays for each of your vertex color layers. You can parse the init data from a file (eg .csv) with python but this is not covered in this answer.

import bpy
import bmesh

obj = bpy.context.selected_objects[0]  # Get the currently selected object

vertex_colors = obj.data.vertex_colors
while vertex_colors:
    vertex_colors.remove(vertex_colors[0])  # Remove all vertex color layers form the mesh data

bm = bmesh.new()  # Create new bmesh object
bm.from_mesh(obj.data)  # Init the bmesh with the current mesh

verts_count = len(bm.verts)  # Get the number of vertices in the mesh
# Not obligatory, I just use this to populate the vertex color layers)

# This dictionary will map each vertex color layer name to the data for each vertex
data_layers = {
    'Temperature':  # vertex color layer name 1
        [
        (1, 0, 0, 1),  # Color of vertex index 0
        (0, 1, 0, 1),  # Color of vertex index 1
        (0, 0, 1, 1),  # Color of vertex index 2
        (1, 1, 1, 1),  # Color of vertex index 3...
        ],
    'Velocity':  # vertex color layer name 2
        [(i / verts_count, i / verts_count, i / verts_count, 1) for i in range(verts_count)],
    'Salinity':  # vertex color layer name 3
        [(i / verts_count, 1 - (i / verts_count), 0.5, 1) for i in range(verts_count)],
    }

color_layers = {}
for layer_name in data_layers:
    # Create the vertex color layers and store them in a dictionary for easy access by name
    color_layers[layer_name] = bm.loops.layers.color.new(layer_name)

for layer_name, layer in color_layers.items():
    # Loop over each vertex color layer
    for v in bm.verts:
        # Loop over every vertex
        for loop in v.link_loops:
            # Loop over every loop of this vertex (the corners of the faces in which this vertex exists)
            try:
                loop[layer] = data_layers[layer_name][v.index]
                # Get the value from the init dictionary
            except IndexError:
                loop[layer] = (1, 0, 1, 1)
                # Set a placeholder (magenta) value if the mapping array is not long enough

bm.to_mesh(obj.data)  # Give the data back to the actual mesh

Then to acces the vertex colors in your material, use the vertex color node :

Note that the "Temperature" layer was initialized with only 4 values, so only a few vertices in the right eye got colored and the rest of the vertices got mapped to a magenta color.

Also note that you can store 4 values in each of the 4 channels of your color. Example with the 'Velocity' vertex color layer used before :


Compositor: Uncontrollable glare and noise artifacts

Well, I spent this morning investigating (another time) this issue and finally found out!
To make glass more interesting I need base color > 1, with some color. I know this is not physically correct, but it looks nice. However it also produces this artifact.
A lot of time wasted on this... but now I know. Thanks Allen and susu for your input!


nevermind i found the answer, was my own mistake

in the compositing texture nodes, i directly connected the color to the output without connecting it to a material node first. smh.


Keyframing some object properties doesn't work

In Scene > Time remapping I left Old on 100 and New on 300, so I put New on 100 and problem solved


I think most .PLY object come very big.
The object is here but you need to scale it down a lot and center it.
This is my process with this sample file :
http://people.sc.fsu.edu/~jburkardt/data/ply/airplane.ply

file import .ply
CTRL-ALT-SHIFT-C to set the Origin to Geometry or in the menu

ALT-G to make sure your object is in the center
scale S to something like 0.02
I would suggest to immediately Apply Scale (CTRL-A) to ensure correct scaling.


UV unwrapped object showing unwanted lines in Substance Painter

The problem is that there are there are overlapping areas in your UV map.  Thus, when you paint on one area in the texture, it affects the other portions of the UV map that overlap that same point.  You'll probably want to try using a different UV projection for the model.  Try out several options until you get a nice UV map that doesn't overlap.  Just note that some projections are view dependent.  So try going into a view that makes sense (like front view) before unwrapping.  You can also try electing edges in problematic areas and selecting Ctr+e -> Mark Seam so that the UV map disconnects along that edge.  Once you got something that looks pretty good, you can head over to the "Texture Paint" mode to get a basic idea of how good the UV map will work before importing it into Substance Painter.
Hope that helps!


How to stretch 120 seconds of animation over 270 seconds?

Select the object and open the Dope Sheet. Set the frame scrubber (the green line) to the starting frame, press A to select all and then press S to scale the keyframes apart up to the required frame. This should stretch the animation to whatever length you want. If you have multiple keyframes, Blender will even these out for you. You can also hold Shift when scaling to snap in small increments.

Note of course that since you are making a short animation longer, it will most likely playback slower.


I figured it out!!!
It was because I had an edge selected in my root vertex group I had to deselect it from that group for it to work properly.


Is there really a way to make a true toon shader material in Cycles?

OSL + Solidify (Irie's Technique)

Results:

Pros:

The toon shader has seven customizable parameters for creating many different looks
Edge strokes taper off with a natural look, like hand-drawn strokes
It renders quickly
It responds to lighting (can be lit with lamps)

Cons:

Some additional geometry must be generated to create the outlines
It won't look right if you make the outlines too thick in the modifier
The toon shader does not react to emitter meshes or other non-lamp light sources

Download here.

This technique I found demonstrated on BlendSwap by Shinsuke Irie is pretty clever. It uses OSL to get the shading, so make sure you have OSL enabled if you append this into your blends. Also you will need to make one edit to the "toon.osl" script because Blender's code has changed since this file was published: speculartoon() closure has been renamed to glossytoon() so just find and replace that text, then refresh the Script node.

The outlines are generated by a Solidify modifier that has its normals flipped (is back-facing). This part is kind of hackish, but looks good because the strokes taper off to a nice sharp point. You can adjust the edge thickness by adjusting the Solidify modifier's Thickness slider, but only a little, as changing this too drastically gives strange results.
The object uses both a "Skin" and "Edge" material to achieve the end result. The outline color can be changed in the "Edge" material.

Of course you can decide to use Freestyle instead of the Solidify technique, if you prefer.

Note that with the Solidify technique edge thickness is local to the object, but it could be linked to camera distance via a driver so that strokes remain the same thickness even in close-up shots. (This is the case for Freestyle as well.)

A look at the customizable parameters in Irie's toon shader:

Conclusion:

This technique can produce very pleasing results! The way edge strokes are generated is a bit unconventional, but it's worth taking a few minutes of studying the .blend to understand how it works. At first I had apprehensions about using a technique that requires a Solidify modifier since extra geometry must be generated, and I wasn't sure if it would cause issues with the deformations of rigged meshes. But then I found this video demonstrating this technique used in production on an animated character and I am convinced this is the best way to do toon shading in Cycles at this time.


Eyebrow bone is detached from the head mesh

That's easy! All you have to do is add a "Shrinkwrap" constraint to each bone and set the target to the mesh with the head. It'll stick to the surface. One of my favorite modifiers


How to bake one texture for one mesh with multiple textures blender 2.8

Due to changes in Blender 2.80, the Texture Atlas add-on might have become obsolete.

In Blender 2.7x it was only possible to edit one object at a time, thus you were only able to see one UV layout at a time.
In Blender 2.80 it is possible to edit two or more objects at the same time.

Start with UV-unwrapping the individual objects, just don't move or place the UV islands to minimize texture space.

When both objects are unwrapped, select both objects, go into edit mode, move your mouse to the UV Editor, select everything and go to "UV - Pack Islands".

Now every UV island from every object should have its own UV Space and also roughly the same texel density.

You can now either modify the UV layouts further (optimizing texture space, sorting UVs, etc.) or you can continue to bake your materials.

As for now (Blender 2.80 Beta), baking textures only works in Cycles. Go to "Properties - Render - Render Engine" and switch to Cycles.


Where is the Z in my Render Layer node in composite?

In 2.79 Z renamed to Depth

So, here it is:


If, in 2.79. you hit CtrlAltU, you can bring up User Preferences. In the Add-Ons tab, you will find 'Add Mesh: Extra Objects', shipped with the application. Activate it, and save the settings.. it will enable you to create an object like this:

.. which might be a good starting point for your object. Note not all the faces are hexagons. ( You can't tessellate the surface of a sphere with regular hexagons, there need to be 'pleats': here, intrusions of pentagonal faces)

If you have surplus triangulation, you can use X > Limited Dissolve to remove coplanar edges.

If you delete the pentagonal faces from a copy of the base object, you can use the Duplifaces mechanism for distributing your hexagonal object onto the remaining hexagonal faces. (If the pentagons are acceptable, you could repeat the process to distribute a pentagonal sculpted object.)

Throughout modeling, you may find ShiftG > Select Similar, is a good way to select sets of elements across the surface of the base object.


For your first problem, try pressing Z to switch to wireframe or solid mode. You are in material mode, which does do the shadows. See here for all of the modes.


Follow Active Quads gives me disorted, streched UV

If you unwrap again (U) but choose Reset, then again U > Follow Active Quads, it seems to work fine. You must have unwrap wrongly at a moment, and as you didn't reset it kept it wrong (don't know why we have to reset though).


Ok I have no idea what is going on, but I played with your blend file and got it to work again. It must be some kind of bug.

Collapse your windows on the left like I did
Then Collapse your side window with your main 3D window
Click the bottom window pane to get back to your 3D view
Notice it changes what layer you are on at the bottom
Click back to the 2nd layer with your object on it
And all of a sudden dupliverts started working again.

WEIRD!!


It is not called a mainframe, it is called the Outliner. This took me a while to figure out what you meant, but that's fine.
Look very closely at the top right corner inside where the outliner should be. See that gray arrow pointing down? Click it or drag it down. A bar should slide down. Go to the left side of that bar, and there is another dropdown. Click it, and from the window types select Data->Outliner.
Click the arrow to unhide the header and switch to Outliner.


Expression Language for Compositing Purposes?

Sorry Tyler,

this is currently not possible. Someone might be able to create an add-on that converts the expression to a node setup. But I don't think this has been done yet. It was on my mind to implement this, but haven't got time to do this yet.


Hide custom properties in the UI panel with python

options={'HIDDEN'} prevents operator properties from being auto-drawn. If you define a custom draw() method, nothing will be hidden.

import bpy

class SimpleOperator(bpy.types.Operator):
    """Tooltip"""
    bl_idname = "object.simple_operator"
    bl_label = "Simple Object Operator"
    bl_options = {'REGISTER', 'UNDO'}

    prop = bpy.props.BoolProperty(options={'HIDDEN'})

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

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

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

if __name__ == "__main__":
    register()

To hide global properties, simply don't draw them. You may use conditions to draw properties in certain circumstances:

class HelloWorldPanel(bpy.types.Panel):
    """Creates a Panel in the Object properties window"""
    bl_label = "Hello World Panel"
    bl_idname = "OBJECT_PT_hello"
    bl_space_type = 'PROPERTIES'
    bl_region_type = 'WINDOW'
    bl_context = "scene"

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

        if context.object is not None:
            layout.prop(context.object, "name")


Does a mesh need UV if there is no texture?

You don't need to UV unwrap the mesh if you can use the procedural texture coordinates like Generated or Object to get the material you want. This applies mainly to within Blender. If you are exporting to another app, like a game engine, you'll need to use the most compatible texture coordinate mode, which may in fact, be UV.


Python 2.8 - why does linking the image texture node throw an error?

This happens because there is no Diffuse BSDF in your material. If you create a new material with bpy.data.materials.new() it will contain only as Principle BSDF and Material Output Node. You need to create the Diffuse BSDF node first.

nodes.get("Diffuse BSDF") returns None because it can't find a node with that name. The error occurs when you try to access input[0], which as the errors says, is no attribute of NoneType.


Animating my character's leg brings part of the other foot with it

The problem is caused by the fact that your foot is not correctly weight painted:

The red bits will follow the bone, and the blue bits won't. to fix your problem, it should look like this:

To perform the fix, select the foots vertex group, enter wait paint mode, then paint the parts of the foot you want to follow the bone red.


Objects created with a specific size aren't coming out at that size when exported

I had the exact same problem.

First, make sure your scale on the object is 1:1.

I Highly (x10!) recommend you abandon all thoughts of using English/Imperial units and go to millimeters.

In Properties Panel, Scene, Units, set Metric Unit to 1.000.  Length=Milimeters

The second image is the key that will open the city.   That little "Scene Unit" checkbox (Always check to make sure this is ON!).

Me?   I save these settings as a default startup file so I have these settings are correct to begin with.

Oh!   On the second figure... don't forget to also inspect the "Include, Selection Only checkbox"!

I use the Measure-It tool (to aid in displaying key dimensions 'say' overall height and width for example.

I personally export to Stl files.    On the 3D printer side of things, I recommend Simplify 3D .   It's good investment.  I forget the $ but it isn't much.    Stay clear of nylon filament (strong but doesn't stick to the build plate) but choose Raptor and other "Print in place" type filaments.   Raptor is stronger than ABS.  PLA is weak but good for practice runs.


Animation smoothness and correctness when exporting

I resolved the first issue by deleting all of my auto-generated keyframes as they'd recorded positions and angles for all of my model. I then re-created four keyframes manually (right-click the relevant property, in this case the W of the rotation, and select 'Make single keyframe'). Selecting them all in a graph editor window then allowed me to:

a) Make a cycle (Shift-e)
b) Apply linear interpolation (T)

This produced a smooth rotation in Blender, although something strange happened to make the direction the opposite of what I'd configured, so I reversed the slope in the graph editor.

Exporting the result still produced only linear interpolation between the four keyframes in SceneKit, so I used the graph editor again to make an actual keyframe at every interpolated point (a total of 40). I'm sure this isn't the ideal solution, but it does work.


Either separate by render layers or use a separate RGB in the compositor to create a mask that only select the blue.


Designing suit by cutting cloth from a model

You can try the Knife tool: in edit mode, press K, then clic ond the start point, end point, enter to confirm.
Start and end need to be on a pre-existing vertex or edge.


Make sure the parent bones are set correctly


How to optimize a mesh by merging objects and/or reducing faces

I noticed that your file was made in 2.49. This is a very old version of blender, and I very highly recommend that you update to a new version if possible.

Using some rather aggressive decimate modifiers, I got it down to 75k while still looking fairly reasonable:

There are a few dark spots where there seems to be some weirdly positioned vertices messing with the normals, but these should be pretty easy to fix with a touch of the smooth brush or the simplify brush.

What I did:

Joined the two side curtains into one object.

To join objects, select them and press ⎈ CtrlJ. The selected objects will be joined to the active object (yellow outline):

Applied the scale by selecting the objects and pressing ⎈ CtrlA> Scale.

It's usually a good idea to apply object transforms as a rule of thumb.
The objects have a scale of .001. The object scale defines an offset which can be confusing and even cause precision problems in some cases.
Merged double vertices on each of the objects to close the small gap in the middle of the main curtain and the side curtains.

To remove doubles, enter edit mode (↹ Tab), select the part which should be operated on (selecting everything with A should be fine), and press W> Remove doubles:

I found that a threshold of about .003 worked pretty well in this case.
Added decimate modifiers to each object.

Note that you can copy modifiers between objects with ⎈ CtrlL> Modifiers.

Here is the resulting .blend. I've applied the modifiers, so it should open in 2.49 just fine.


The Domain Resolution is the key here since it defines how large the cells of the fluid simulation are - and it is those cells that you are seeing as the ‘blockiness’.
Is is important to Apply Scale to ensure the dimensions of the cells are regular (otherwise the simulation will be skewed) but then the size of the cells it determined simply by dividing the longest dimension (width, height, depth) of the domain by the Resolution - so, for example, doubling the Resolution will result in twice as many cells in each dimension.
If your previous simulation was Baked the you’ll need to Free Bake to allow the simulation to be re-baked with the new settings.
Note that doubling the resolution will result in 2x2x2 = 8 times the number of cells in the simulation (so 8x the cpu effort to simulate and 8 times the memory overhead) but a more accurate and detailed simulation.


Plane image gets smaller when in render view

The issue you are having is the image texture node is set to clip, not repeat (fourth menu). This means that the image will not be repeated to fill up the rest of your UV map, since your UVs don't cover your entire texture (which is fine). It appears that the viewport automatically tiles the images, but the render will use the node settings.


You're in pose mode. Parenting must be done in edit mode.


Check if your vertex indices match on both objects.
To display them enable as Overlay > Developer > Indices


Thank you for your help. On reviewing the post suggested, I found the solution.

It appears that the 3D clipping property needs to be within reasonable ranges, otherwise the edit mode display will be deformed; my viewport clipping ranged between 1 cm and 10 kilometers at the time I experienced the problem; when I dropped the end-clipping to 1 km, the problem with the weird display in the viewport disappeared.

It is interesting to note that exactly the same happens with camera view; if the camera clipping settings are outside a certain range, the geometry will show the double-border in edit mode, although only in camera view.

I found that The clipping range 1cm to 1km in metric (or .001 and 1000 in generic blender units) works well for both viewport and camera views.

I hope this information is of use.

Regards,

Sept


You could do it using breath made from smoke, but it might be challenging matching up all of the elements. Not simply in terms of footage, but in terms of performance and nuance of your actors.

Lock Your Picture

You don't want to be sinking in effort until you are certain of which frames you will be performing surgery on. Once your edit is locked, drop the raw frames into a 16 bit half EXR per shot. Assuming you have shot this on a DSLR or like camera, isolate your final cut from the VSE and render out.

If you have several to many shots, maintain solid control over your organization. One directory per shot, with versions as subdirectories or an alternative approach that works for you. Bear in mind that if you are performing a dissolve or an over where two shows are displayed at the same time, you will need to make sure that you have a full series of the entire frame count, including the overlapping portion, in your half EXRs.

Gather the Plates

Ideally you would have a library of plate shots, shot against black. Consider a back light to bring just enough lift into the breath to give distance between the lower black of your background and your foreground breath. You could capture these using a DSLR without much effort, assuming you can find a cold enough area to work in for a bit. Gather up many plates so that you can combine them in ways that suit the breath required in your shot. If in doubt, capture more rather than less.

If shooting is unrealistic, consider rendering out plate elements with variations using your smoke concept or gathering up found footage that might be available online with permission to use.

Alpha Technique

Use associated alpha (sometimes sarcastically referred to as the One True Alpha) on the plates based off of a luminance key pull, making sure to bring up your lower end enough to threshold out the black you are photographing against. If grading is required, make sure to unpremult the alpha otherwise you will incorrectly skew the RGB to alpha relationship leading to glowing or darkened fringes.

Tracking

Depending on the nature of the breath element, you might be able to get away with a 2D manually tracked element with an empty and some scaling. However, if you have a shot that warrants it, consider tracking it and laying in your elements as it shouldn't be too complex and potentially add tremendously to your work. You gain the ability to add subtle depth of field and possibly some depth cuing for free.

If you do track your shot, consider adding a subdivide or two to your floating plates and subtly warping them with a quick sculpt or curve. This will add some perceptual parallax as the camera moves and more greatly sell the effect.

Matching Footage to the 3D View

  I'm not sure how to see the video so I can position exactly frame by
  frame a simulation either.

From the Properties panel (hotkey N) you should see "Background Image". Set accordingly. To keep your sanity, position the camera at a perpendicular position to the grid and position your elements accordingly. If you are going to attempt a 3D effect, make sure to set your camera lens to roughly what your shot was conducted on, and set the sensor size to APS-C or whatever gate size you shot on. If you are going to do a strictly 2D approach, this isn't an issue.

If you are attempting something strictly 2D, where you are using an orthogonal camera and floating 2D planes,this can be a little tricky if you aren't careful. First, make sure that your render dimensions match the dimensions of your footage. Second, if you are seeking to perfectly match a plane to the viewport, you will need to set the scale of your pla such that it matches the ratio of your frame. That is, for 1920x1080 footage, your scale would be 1.920 by 1.080. If you don't use the fractional values, you will end up triggering some cubic scaling on your images and the result will end up a blurry soup, so be aware.

If plausible, try the 3D approach for fun.

Further Reading

Here is one approach, loosely summarized above, from a larger budget production:
https://www.fxguide.com/featured/the-thing-a-matter-of-life-and-breath/


Issue with lighting and rendered environment map

I believe your issue is that you are using the Blender Render engine instead of Cycles (much newer). This would definitely lead to the darker bottom faces because Blender Render does not utilize bounce lighting (in real life, if you have a desk with a cavity under it and a white carpet floor for example, when photons hit the carpet, they bounce and also hit the underside of the desk, illuminating it). Blender Render also cannot do proper environment maps.

To fix all of these problems, go to the top bar and where it says Blender Render, instead select Cycles Render from the dropdown:

 -->

Select the camera and go to the Camera Object Data tab in the Properties panel. Change the settings under Lens to Panoramic and Equirectangular. This will create a true world image.

Go to the Render Settings tab in the Properties panel. Under Light Paths, change the settings to these. These are the optimal bounce lighting settings that I use in almost every render. While on the subject of lighting, I would highly recommend repositioning your lamps and changing their strength and color so that the image looks better.

Go to Properties panel > Render Settings > Sampling and change the Render: samples to 250. Also change the Clamp Indirect: value to 3. Both of these will improve your image's clarity.

Go to Properties panel > Render Settings > Dimensions and change the X: and Y: dimensions to 2000x1000. Up the percentage slider to 100%.

Lastly, since I assume you want a panorama like this:

...and not like this:

...change your camera positioning in the 3D View Properties panel to this:

After adjusting the lighting as well, I was able to make this:

Also, here is the adjusted .blend file:


The direction of the Normals determines how the objects combine when using a Boolean Modifier:

On the first image the cube and the torus have their normals facing out:

On the second image the Torus has the normals facing in:

On the third image both objects have their normals facing in:

Quote from the manual:

  Difference

  The modified mesh is subtracted from the target mesh.

  If the target Mesh has inverted normals, Blender will Intersect the modified  mesh.

  If the modified Mesh has inverted normals, Blender will add both meshes (Union).

  If both Meshes use inverted normals, Blender will Intersect the target Mesh.

  Union

  The target mesh is added to the modified mesh.

  If the target Mesh has inverted normals, Blender will Intersect the target Mesh.

  If the modified Mesh has inverted normals, Blender will subtract the target Mesh.

  If both Meshes use inverted normals, Blender will Intersect the modified Mesh.

  Intersect

  The target mesh is subtracted from the modified mesh.

  If the target Mesh has inverted normals, Blender will subtract the target Mesh.

  If the modified Mesh has inverted normals, Blender will intersect the target Mesh.

  If both Meshes use inverted normals, Blender will add both meshes (Union).

To recalculate normals enter Edit Mode (Tab).

Select all faces and press CtrlN To have the normals face out

Or CtrlShiftN to have normals face inside the mesh.

For an explanation on Face Normals please read:

What are face normals?


Why can't I select bones in weight paint mode?

In 2.91 this is no longer working. Selecting a bone in weight paint mode throws both the mesh and the armature into object mode. Then we have to switch back to pose mode in the armature, then back to object mode, then select the mesh, then switch it to weight paint mode.


Here's a simulation of the situation (Blender 2.75).

The parameters that I cosidered in this "catalogue" are:

Resolution of surfaces (unsubdivided-> first row; Collision object subdivided-> second Row; Cloth object subdivided-> third row; Both subdivided-> fourth row)
Friction (0.1 or 80)
Repel Distance (0.001 or 1)

By comparing the elements of the first row, I can say that it seems to be at least a little difference of the behavior when friction jumps from 0.1 to 80 (but is not that strong as one expect)

Look at the last element of the matrix (4-4): it is the one where friction reveal itself in a more convincing way..but there's another, which has the same behavior: 2-4. This led me to think that is also important to consider how many faces your collision object has.

Now compare 2-4 with 2-2... also the max Repel distance influence the behavior.

Conclusion

It seems that changing only the Friction factor is not enough to run the sim as expected, but you have to deal at least with other two parameters:

resolution of collision object (should be enough detailed, but more subd won't give more frictional effect apart from the contribute given by the fact that the faces are in range for a longer period)
repulsion distance (act as a sort of detecting thershold, but more rep dist won't give more frictional effect)

Friction is the value that drives the pover of frictional effect, but it must be supported by other variables in order to affect the sim.

Here's the blend of where the gif comes from:


How do I adjust animation easing in Blender?

You can use the Graph Editor for this. The Graph Editor allows you full control over the animation curves, including options to vary the Easing Type (menu Key/Easing Type or Control+E), setting the Interpolation Mode (menu Key/Interpolation Mode or T) - which includes additional Easing options, or by manipulating the curve bezier handles.


Create a sphere, move the pivot point to the point where you want the mouth to open.

Duplicate. On one sphere delete the top half. On the other delete the lower half.

Animate both objects by rotating them in opposite directions.

Optionally create a cycle by extrapolating the keyframes in the curve editor (Channel->Extrapolate->Make cyclic).

Add an empty and parent both hemispheres to it.

To move the object just move the empty.


How to texture paint only one part (normal map)?

At the bottom of the viewport next to the pivot options is a toggle for face select masking in Texture Paint mode. Turn that on, and either in Edit mode select the faces that are the offenders here, or in Texture Paint use the rmb to select the faces. You can sample the color from the normal map with the S key, and then paint it in masked by the face selection.


Blender is unfortunately very limited for use in precision modeling and CAD like operations.
It's snapping tools and precision transforms are very lacking. Dupligroup handling is one of it's many shortcomings, this is a know limitation of the system, you can't really control what to snap to and from with empties.
You can still snap to the linked geometry, but when transforming the empty itself with a dupligroup you can only use the empty's center as base snapping point.
Workaround 1 - Don't link as group, link as object.
If it's just a single object we are talking about link it as an object instead.
After linking make it a Proxy with Ctrl + Alt + P or make it Local with L > Selected Objects.

Upside is you get the unexpected benefit of overriding several types of data locally while maintaining the linked geometry, like materials, and even modifiers

Downside is it only really works well if it's a single object. (you wont be able to easily add new objects to the linked instance unless you merge them all together into a single bulky mesh.

Workaround 2 - Use a dummy mesh object.
Note: This has been deprecated for Blender 2.8+ mesh objects can no longer have Collection Duplications
By default when you link a group instance it links through an empty object, which limits it's snapping options. Instead use it as a dupligroup on a 'dummy mesh'.
A dummy mesh is a purpose created unrenderable mesh object that is used solely for the purpose of snapping.
You can custom create it's geometry exactly with only the points you exclusively want to snap to. That will give you a 'custom snapping cage' with only the relevant points for freely snapping to/from.
Just create a mesh object, model it regularly as you see fit, and in the end select all with A then delete all with X > Only faces.
That will render the object invisible to rendering, in theory not weighting down the scene performance, but give you a valid snapping geometry tailored to the specific object.
Then just go to the Properties Window > Object > Duplication > Group and pick the previously linked group.

The Downside of this technique is that you have to model extra an snap cage, for each relevant object, it's extra geometry weighting in your scene and slowing the viewport down. Also if you want to add more instances of the group easily you'll have to duplicate the existing mesh, so it always keeps the relevant cage.
Upside is you get a custom tailored snap geometry, with exclusively the points you want to snap to/from. Should not affect rendering performance, and it can additionally hold materials for easy overriding if necessary.


How do I manipulate curves of animated textures?? (not showing in graph editor)

Think I figured the issue out.
Normally if I select an object, it's animated properties show up in the animation editors (graph/dope/timeline)... but it seems that to access animated attributes of an object's shader nodetree, both the object AND it's animated shader node has to be selected.

I selected the object in a 3d viewport, and also clicked on the animated shader node in the shader editor.... and the animated channels where available for editing in the graph/dope sheet/timline.


Low-poly animation: Water clips through bottom of my floating boat?

(Blend file below)
The problem with boats is that they sit down in the water and require the water's mesh to be displaced or booleaned which doesn't always work as planned.  An alternative is to apply a simple mask.
This was first done as an experiment ages ago using OpenGL masking, and yesterday using Blender's internal masking system to confirm that it works just as well.

The details -
For the experiment the water is a plane textured with a water movie.  The boat is sunk down fairly low into this.

Without a mask the water naturally swamps the boat so a mask (another plane) shaped as a lid that sits on the open area of the boat and down a little from the top, cuts a hole in the water when rendered in OpenGL, or if  using Blender's masking, cuts a hole through everything, the water and boat.
For Blender's render, two videos are produced and later mixed in the VSE.
The 1st, the entire scene with the mask active, so when rendered, the scene will have a hole cut into it.
The 2nd, rendered without the water or mask so we have the boat and nothing else.
With the mask...

.
.
Without it...

The masked version needs  Blender's "Shading" in the Output properties to be set to "Transparent" and the rendered output set to a series of .png images with their alpha layer included.
The lone boat version (no mask) doesn't need an alpha layer, but DOES need the shading returned to "Sky".
This is also rendered as an image series and with the same .png format as before.
-=================-
Shaping the mask is best done in Ortho View so you're looking straight down without parallax error.
Drag the masking plane's edges out to match the boat's open top and lower it a little below the boat's upper surfaces.
Expand the edges enough to be inserted just inside the boat's thickened sides and dashboard.
This will ensure there are no gaps. Nor should it be protruding beyond the boat's exterior.

Parent the mask to the boat so they move in synch.  (child = mask)
Armed with the two videos, the 1st version is simply laid over the 2nd in the VSE.  The holed version (top strip) has to be set to "Alpha Over" in it's properties panel at right. (press N)
It's best to fire up a new instance of Blender for this.
When mixed, the masking cuts the hole but under that and showing through is a perfectly matched and synch'd boat, with a dry floor.

Blender file Notes -
...has been set up for Blender Rendering. (F12 for preview snap)
For masking methods see here - Masking


What is the reason to make quad or triangle faces on a surface?

There are several reasons to use only quads in your models.

some modelling tools only work with quads. eg Loop cut will cut quads but stop at a triangle or ngon.
triangles and ngons can deform badly when animated.
ngons are automatically broken into triangles to be drawn to screen, particularly on non flat ngons, these may not be cut in ideal locations causing noticeable shading artefacts.
the subsurface modifier also doesn't subdivide ngons very well.
generated textures can also suffer from bad co-ordinate generation on ngons.

For flat surfaces shaded in a single colour you can get away with leaving ngons in your final model if you want to.

To get quads you need to cut your mesh up where you want the new edges. you can select two vertices and press J to cat a new edge between them or you can use the knife tool K to cut new edges and vertices where you want them.

An easy way that can work under some conditions is to use the remesh modifier. Once you are happy with the settings you can apply the modifier to make the new mesh permanent.


Make sure your orientation of petals is the same for the successful and unsuccessful petals.  In [Edit] mode examine the [XYZ] axis.


Particle emitter / initial velocity of emitted particles

one way to solve this you could increase your z - speed to -50 m/s.
and change damping and friction of your plane to 1.
then you get this:


I'm not sure what exactely was wrong.
I clicked "Load Factory Settings", and it worked again.


Modelling with Curves using a bevel object

It is a bit counterintuitive, bevel objects are used along the curve's local Y axis. Create both curves using the top view.

then use the bevel object.


Node won't appear even when I search for it

I believe the AI/NN-based Denoise Node is new in Blender 2.81. Blender 2.81 is still in Beta / experimental development, so if you have the current stable version of Blender (2.80), you will not yet have the Denoise Node. You can download Blender 2.81 Beta under the experimental builds download section of the Blender page, if you'd like:

https://builder.blender.org/download/


Enter Edit Mode, switch to Edge selection mode, select any edge, go to the Transform Orientations panel and press the + button to add a new transform orientation while that edge is selected.

You can name your new transform orientation whatever you want, and then use it afterwards. There will additionally be created a new transform orientation named "Edge" that will hold the orientation you want.

You can then move along that edge direction, or perpendicularly to it, relative to the surrounding faces normals.


BPY, how to select and separate one side of a road-like mesh with Python script?

Bmesh version

Most edges in the middle of the road have 2 linked faces, and each edge vertex 4 linked edges. (as pointed out in other answer the non-non-manifold)

middle = [e for e in bm.edges if len(e.link_faces) == 2
        and all(len(v.link_edges) == 4 for v in e.verts)]

for e in bm.edges:
    e.select = e in middle

Which gives this result, the middle of the road selected without the ends.

Use middle edges to rip the mesh with bmesh.ops.split_edges. If there are any vertices left that have 5 link edges they are on the tip of the rip.

The two rip edges in the verts link edges will also be in the ret['edges'] list returned by the operator.

An edge vector is made from one of the rip edges. The edge to rip is chosen as the one with the smallest angle to rip edge vector. Could possibly use a mesh select operator here, feel I'm missing something as seems overly complicated

Here is a bmesh script to run in edit mode for testing.  After running the road mesh will be ripped down the centre line.

import bpy
import bmesh

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

middle = [e for e in bm.edges if len(e.link_faces) == 2
        and all(len(v.link_edges) == 4 for v in e.verts)]

ret = bmesh.ops.split_edges(bm, edges=middle)
edges = set(ret["edges"])
ends = []
for v in bm.verts:
    if len(v.link_edges) == 5:
        link_edges = set(v.link_edges)
        cut = edges.intersection(v.link_edges)
        link_edges -= cut
        e = cut.pop()
        v = e.verts[1].co - e.verts[0].co
        def angle(edge):
            return v.angle(edge.verts[1].co - edge.verts[0].co)
        ends.append(sorted(list(link_edges), key=lambda e: angle(e))[0])
if ends:
    bmesh.ops.split_edges(bm, edges=ends)

Seeing this test script is for edit mode can now run

bpy.ops.mesh.separate(type='LOOSE')

To avoid any edit mode operators (so the script can be used on multi meshes in object mode) try the get_islands(...) method.


Lines come up in rendering after adding hair

Try changing the dropdown menu in Hair BSDF from Reflection to Transmition. This helped when I downloaded the .blend file.

You could also try lowering the samples, as you said the problem only appeared when the count got up high. In the image rendering from the .blend file, noticable changes stop around 300-400 samples. More than 250, in general, just makes you feel better without actually changing anything.

Hope this helps and happy Blending!


Why is Blender moving objects with locked locations on the Y axis after exporting to FBX?

Well, when I imported the FBX into Unity, it was the object called "rig" (the armature object generated by Rigify) that was being moved around. Checking that object for strange translations in each Action, I found nothing.

But I did notice a stray "LocRot" channel that didn't seem to be attached to any particular object. At least not by name. This was what was moving the rig around.
So removing this channel fixed my problem.


Best way to color only the faces that are not debossed

If you want something quick and dirty, you could create a mask based on the axis co-ordinates of the faces of your "lettering" (I used X axis in my example). An unfortunate side effect, however, is that it leaves a black stripe around the edge of the object at the same X-position:

If instead, you want to select the letter faces and assign them a different material (ie: you just need a quick way to select all the faces at a certain "depth"), select one of the faces at that depth and then select > similar > co-planar. You can then assign a different material to the selected faces:


My UV map isn't wiring Properly with my normal direction

You need to add a "UV Map Node" and connect it to the "Vector" of your image texture. While in the "Node Editor" Press "Shift + A" and find the "UV Map Node" under the "Input category.

Also, make sure that you have selected your image in the UV Editor.

Try this simple node set up.


How to add extrapolation functionality in Blender 2.69?

In 2.69 this was in the Channel menu (⇧ ShiftE):

However I recommend updating to the latest version (2.75). See Is it advisable to update Blender to the newest version as soon as possible each time?


Generating height map of group of objects

Set your camera above the objects looking straight down. In the Render Layers tab of the properties window make sure the Z pass is enabled.
The rest of the settings are just to speed up the rendering. I used a plain emission shader as the override material. I set the samples to 1, turned off the denoising and the "Use" options: "Use Environment," "Use AO," and "Use Hair."

Now If you look at the rendered depth pass it will look all white. However all the data is there. (A 32bit exr would show you it in other programs.)

In the compositer drop a Normalize node between the Render Layers Depth output and a viewer node to see what is really there.

Little side note. Notice the banding on the cube in this gif. That is why you should save the depth map using a high bit depth. If you use a normal 8 bit image it will not be able to store all the information and you will end up with stepped ridges instead of a smooth gradient along the different heights.


Particles: Setting object's origin is not fixing it not passing through the middle of the surface

Objects used as hair particles do not view Z+ as "up".  They must have a different orientation, for some legacy reason coming from the particle system's beginnings, afaik.
Model and texture your object, align it at the origin as though you were aligning a regular object on a ground plane.  Exactly as you have in the image you've presented.  Then, with the object selected, press R + X + -90 to rotate the object -90 degrees on the X axis, and then press Ctrl + A and apply the rotation.


How to model wavy pattern on the surface?

Sketch curve, convert to mesh and then refine.

Sketch pattern main feature:

I would start from the sketching the main lines of the pattern using a bezier curve. First thing to place are the start and end point. Grab them around upon a reference image. Then adjust the handles orientation to match the reference curve's tangency (vertical) like the image below is showing:

.

Create main geometry

Now that we have the curve, set a bevel object (the black arrow in the picture is pointing mine) to place some faces to work with. At this point you can temporarily add modifiers to the object to get an idea of the final apparence of the pattern:

Convert to mesh and edit the object

As for the final model I plan to use the subdivision surface modifier, I kept the curve's resolution low before converting the curve to mesh. After this, run the symmetrize command to mirror and duplicate the mesh around the origin. Then clean up a bit the model by deleting unecessary faces:

You'll have to repeat the operation to take care of the border in order to achieve a fully tileable mesh. Fill the voids with the faces paying attention to not work outside the imaginary boundaries of the figure. You should come up with something similar to the image below:

Final retouches and modifiers

Now that the basic shape is ready you can tweak each vertex position manually, with proportional edit enabled, or even with the sculpting tools, or using the smooth vertex command... in order to achieve the right shape. You can also alter the topology with the knife tool, edge collapsing, deleting and creating faces... till you reach a satifying result.


How to get a repeating, progressing forward backward sequence of a video file?

Perhaps try this:

import os

from bpy import context
scene = context.scene

path = "C:/Users/Admin/Documents/Projects/VIDEO/atabilized/timelapse"
files = os.listdir(path)
files.sort()

# create the sequencer data
scene.sequence_editor_create()

seq = scene.sequence_editor.sequences.new_image(
    name="MyStrip",
    filepath=os.path.join(path, files[0]),
    channel=1, frame_start=1)

# add the images. forward and backwards
amplitude = 25
i=0
while i <= files.len() - amplitude:
    for f in files[i : i + amplitude]: #forward
        seq.elements.append(f)
    for f in files[i + 2 : i + amplitude - 1 ][::-1] #backwards
        seq.elements.append(f)
    i += 1


Script - remove multiple material slots - Blender 2.8

This script will delete the n_to_remove last material slots of your active object in reversed order (from the last material slot down).

import bpy
o  = bpy.context.object
ms = o.material_slots

n_to_remove = 3 # Change this number to decide how many material slots to remove
for i in range( len(ms) - 1, len(ms) - n_to_remove - 1, -1):
    o.active_material_index = i
    bpy.ops.object.material_slot_remove()


The Anisotropic shader works using a Tangent to control in which direction the reflections get squashed.

If you don't specifically tell it which tangent to use, it'll compute a tangent from the geometry itself. I assume because your model is perfectly flat, it had a bit of trouble doing this predictably.

So instead, pick one of your UV maps and plug that into the Anisotropic shader's Tangent input:

The reason those artifacts appeared to come from geometry that doesn't exist is because you're using an Explode Modifier that modifies the mesh.


Select the object in object mode and turn on smooth shading for the whole object.


How to introduce an edge where two faces intersect

The simplest solution would be to select one of the planes and use Intersect(knife) that can be called from the search menu(F3/space) or Face menu(ctrl+f):


By default Blender interprets input at the base unit measurement in that system. All you need to do is to input a unit as well as a quantity and this will work as expected (i.e. 12m or 12cm etc.)

As you have noted in your question, changing the Scale option changes what this base unit is. In your case the base unit is cm, so for any other unit of measure, you must input that unit after the numerical input.


How does Blender know which faces and edges to automatically select when doing a multi-vert selection?

Flushing select mode.

Recommend naming a bmesh representation of a mesh bm and reserve mesh or me for a mesh.

bpy.ops.mesh operators manipulate the mesh.  A bound bmesh, ie from_edit_mesh is still not the mesh.  An edit mode mesh is what we don't have a handle on via python.  Can set me.vertices properties in edit mode, but will have no effect on the "special" edit mode instance of the mesh.

Flushing selection, or updating the bmesh will ensure the mesh used by the operator has the changes. Put it in a fit context to be operated on

If the intention is using bound bmesh to select the geometry required by  bpy.ops.mesh operator, flush the selection before the operator call.

As mentioned in prior answer, the results of your script will change depending on selection mode. It is part of the context bpy.ops.mesh operators use. This sets it to all.

>>> C.tool_settings.mesh_select_mode = (True, True, True)

Result of running the script in prior question in only vert, only edge, and only face selection modes.  No prior selections

Will also get the desired result if we select face in face selection mode, then switch to vert select mode and run script.  The simplest fix of all to use bpy.ops.mesh with face selection from verts selection is to set one or both of faces and edges to True.

In the bmesh docs

  Selection / Flushing

  As mentioned above, it is possible to create an invalid selection
  state (by selecting a state and then de-selecting one of its
  vertices’s for example), mostly the best way to solve this is to flush
  the selection after performing a series of edits. this validates the
  selection state.

In Keeping a Correct State it states that vertices belonging to edge are selected when edge selected. Similarly for edges, (and hence verts) of a face.

It does not mention the converse is true.  Selecting verts selects their edges and / or faces. (Speculatively This works from the UI since it has a handle on "special edit mode mesh" ie select 4 verts in UI, vert select only,  then on running script to check,  face is selected)

To set a face to selected, makes sense to select the sub-elements.  Work like an update method. Face sets edges, edges set verts.  To conversely select a vert then check all its linked edges and faces, and set to selected would fire off our update reelecting the selected.  Or similarly as a property getter  checking all the selection of sub-elements, could prove expensive.

Instead select_flush is used to sanitize state.

Akin to setting the context tool select mode calling bm.select_flush_mode() will flush the states according to those set in bmesh.select_mode.

Test scripts. both designed to select face and extrude even in select only vertex mode. context.tool_settings.mesh_select_mode = (True, False, False),

Selects verts,  flushes mode, extrudes face.

import bpy
import bmesh
context = bpy.context
me = context.object.data
bmesh.select_mode = {'VERT', 'EDGE', 'FACE'}
bm = bmesh.from_edit_mesh(me)
for v in bm.verts:
    v.select = v.co.z > 0
# flush the selection
bm.select_flush_mode()

bpy.ops.mesh.extrude_region_move(
        TRANSFORM_OT_translate={"value" : (0, 0, 2)}
        )

If we use faces can  skip the flush call and select the faces  based on the vert selection

    for f in bm.faces:
        f.select = all(v.select for v in f.verts)

but, IMO if you are going to extrude regions, generally only want faces, not edges or verts, so rather than diddle around with vertex selection, select faces instead (and vertex edge selection is done for us)  The so called brute force approach

    for f in bm.faces:
        f.select = all(v.co.z > 0 for v in f.verts)

Test script.

import bpy
import bmesh

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

for f in bm.faces:
    f.select = all(v.co.z > 0 for v in f.verts)

bpy.ops.mesh.extrude_region_move(
        TRANSFORM_OT_translate={"value" : (0, 0, 2)})

As mentioned in prior answer, recommend using bmesh.ops operators over bpy.ops.mesh...  The geometry is passed to the operator, rather than manipulating context and selection.

Leave selection to the user, or a selection operator.

Can use the tag property

for v i bm.verts:
    v.tag = some_long_winded_test_bool_func

for f in bm.faces:
    f.select = all(v.tag for v in f.verts)

to avoid calculating per vert per face, and verts not part of a face.


Why do I have to use negative solidify values when the tutorial does not?

It must be because his faces normals point inwards while yours point outwards, you can check the faces orientation if you enable the Face Orientation option in the Viewport Overlay panel, the blue face means normal positive orientation, red face meaning normal negative orientation. To recalculate inside, select all in Edit mode and press ShiftCtrlN, to recalculate outside, ShiftN.


Click on the mesh and go to vertex tab and click auto smooth


Left click selection deselect object (2.8)

I'm not sure if this is what you are looking for, but if you:

*Left Click and drag = Select the objects.

*Ctrl + Left click and drag = Deselect.

*Shift + Left Click = Add Objects to the selection.

*Shift + Double Left Click on an object = Deselect

Hope that helps.

Good Luck.


How do I make a square hole in a cube, and then save it as one mesh?

In edit mode, select the top face of your cube.
Press I and resize the new face till it is the size you need.
Press E to extrude the hole inward.
Press Delete or X and choose Faces to delete the bottom face of your hole.


NLE - Workflow for editing one big video clip containing many sequences

Try adding another scene named after the clip then import the long clip. Soft cut it or metastrip the parts as you wish. Then copy paste these elements back to the master edit scene.
You can have as many additional clip scenes as you wish.


Blender python, what design pattern the Operator class is designed

The HelloWorldOperator derives from the bpy.types.Operator base-class.
The self variable is a Pythonic class pattern, it is similar to this in C++ like languages. The class variables declared in the class header, e.g. bl_idname and bl_lable, are shared across all instances of the class. The self dictionary contains the per-instance variables and is always the first argument in a Python class method. It is automatically supplied on method calls.
The context comes from the Blender environment and contains pointers to the active object, collection, GUI mode and other things.
Classes deriving from bpy.types.Operator are high-level functions designed to be used as GUI callback functions. As such they only return GUI status.


I realized there was a double edge on one of vertical edges. So there was a disconnection between the edges. I used W > Remove Doubles operator however it didn't solve the problem so I should have deleted those vertices manually.


Fading out particle system from one side

I apologize if I did not explain the problem thoroughly. I found a rather simple way to achieve the effect. I first made a gradient and mapped it to a plane.

By setting the particles to use the uv map of the plane and checking "From Instancer", I used the gradient to determine the factor used for transparency.

By animating the location of the gradient I achieved this sweeping effect.


You copied the armature OBJECT, not the armature data.  The copied object referred to the same datablock (armature.data).  If you look at the properties panel in the armature tab (as opposed to the object or materials tab) you will see a [2] next to the name of the armature datablock

Instead:

ao = ob.find_armature()
a2 = ao.data.copy()
a2.transform(conversionMatrix)

This copies the armature datablock instead of the object datablock.


Move meshes of several objects without affecting relative position

I would suggest one of two methods.

Method 1

Move your 3D cursor to the center or your objects (that you want to move)
Set origin of all the objects to 3D cursor.
Now move the objects. (movements are based on origin. You can also set transform to "individual origins for a different effect.)

Note: Selecting all objects and making a group will make things easier. This way you can select the whole group easily by selecting one of the objects and pressing shift+G then selecting "group".

Method 2

Create an empty
parent those objects to the empty.
Move the empty to the location you want.

Note: put the empty in the center of the object before parenting.

Method 3

This method is for moving the vertices of different objects to the same place, when the origins are already in the desired location.

Select all the objects you would like to edit.
Snap 3D cursor to selected (shift+s)
Set origin to geometry. (ctrl+alt+shift+c or toolbar)
Snap "selection to Cursor (offset)". (this operation is based on the origins, which are now at the centre of the geometry [mesh].)


Blender keeps wanting to use my CPU instead of my assigned gpu

FIXED! I had to enable CUDA in my user preferences under |system| in "cycles compute device.
Thanks for answering tho! I would not have looked as closely if it was not for you.


What is the difference between Reference and Background image in 2.8

Both of them are different presets for an image used as empty.

There are a couple of key differences between reference and background images.

Reference images essentially act as objects. like standard objects they aren't transparent so if you pass an object behind the image then it will be obscured by the image.

Background images will show behind objects regardless of which view you see it from

Both reference images and background images will show in wireframe or solid view

Background images have backface culling

Unlike reference images if you create a background image while in orthographic view you cannot see the image in perspective view.


Separate preview/render border settings possible?

No. However, as of blender 2.65 you can use Render Border (CtrlB) while not in the Camera view, which will only affect the viewport:


Keep sharp edges when using subdivision surface

You have two options:

Add supporting geometry (Loopcuts CtrlR and beveling CtrlB both work well):

The Subsurf modifier demonstrates why good, clean topology is so
important. As you can see in the figure, the Subsurf modifier has a
drastic effect on a default Cube. Until you add in additional Loops
(with CtrlR), the shape is almost unrecognizable. A mesh with a
deliberate topology has good placement of Edge Loops, which allow the
placement of more Loops (or removal of Loops, with X » Edge Loop) to
control the sharpness/smoothness of the resultant mesh.

Use Creases (ShiftE):

Weighted edge creases for subdivision surfaces allows you to change
the way Subsurf subdivides the geometry to give the edges a smooth or
sharp appearance.
The crease weight of selected edges can be changed using Transform
Properties (N) and change the Median Transform slider. A higher value
makes the edge “stronger” and more resistant to subsurf. Another way
to remember it is that the weight refers to the edge’s sharpness.
Edges with a higher weight will be deformed less by subsurf. Recall
that the subsurfed shape is a product of all intersecting edges, so to
make the edges of an area sharper, you have to increase the weight of
all the surrounding edges.

Creases tend to produce a sharp, hard edge which tends to look less realistic (and also tends to require an Edge Split modifier if used with smooth shading), while supporting geometry tends to give a subtly rounded edge which looks more realistic and does not require an edge split modifier. However, using supporting edge loops also tends to add a lot of extra geometry.


Imported short clip with obscenely high framecount

There is a hard coded frame count in Blender. You could recompile it with a larger frame count and see if things work, as I believe your piece is over the maximum. While I cannot remember the number, you shouldn't have too much trouble locating it.

It might be more optimal to chop the piece into smaller portions using another tool and reassemble them.


Materials Turned Black When I Opened Blender

You saved your .blend file in a newer version of Blender and tried to open it in an older version.

In this case the Principled BSDF was introduced as of 2.79, while version 2.78 was used on your screenshot to open the file and load that material.

Since Blender 2.78 doesn't know the Principled BSDF, it is behaving as if no shader were present (indicated by the red coloring of the node). Hence no color of the surface, which equals black (same as muting or removing a shader plugged into the Material Output).

To continue working with Principled BSDF, open the file using Blender 2.79 or newer.


How to get vertex coordinates after modifier in Python in Blender 2.80?

Using bmesh and the dependencies graph, you can get an evaluated bmesh:

import bpy
import bmesh

depsgraph = bpy.context.evaluated_depsgraph_get()

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

bm = bmesh.new()

bm.from_object( obj, depsgraph )

bm.verts.ensure_lookup_table()

print( "----" )
for v in bm.verts:
    print( v.co )

bm.free()

Edit:

obj.to_mesh should work too (have not tested) but if you don't want to create a mesh, this is not needed.


Baked texture map shows weird distortions, is it mistake or not?

You are subdividing your UV map with a subdivision modifier.

Go to the subdivision modifier and uncheck UV Smooth, if you don't want to subdivide the UV map.

From the manual:

  UV Smooth
  How to handle UVs during subdivision.


Scripting Grease Pencil and choosing data layer to be linked

I'm not sure if this is what you are looking for but:

bpy.context.scene.grease_pencil = bpy.data.grease_pencil['GPencil']

will set the scene's active grease pencil datablock to be 'GPencil'.

I found this by using autocomplete in the Python Console to see properties of the Scene.

As with other datablocks in blender you can also set scene.grease_pencil to be None to have no active grease pencil datablock.


Automatic select vertices by given coordinates

If the indices no longer correspond, you can:

use a brute-force proximity check
use spatial search structure (K-dimensional-Tree).

  Template for getting a bmesh in Object or Edit mode can be found in:
  TextEditor > Templates > Python > Simple Bmesh (EditMode)

Brute Force

For each coordinate listed in coords_to_find it will select the first vertex which has a similar 3d location. Due to numeric imprecision of 32bit floats we might use an Epsilon as a fuzzyness factor, and say "Any vertex coordinate found within linear distance Epsilon of a given coordinate is the one we want", then skip on to the remaining verts and coords.

Below is a slight modification of the Bmesh template, it assumes we have a mesh object in edit-mode, i happened to use a Suzanne model.

import bpy
import bmesh
from mathutils import Vector

coords_to_find = [
    (0.3203125, -0.734375, 0.7578125),
    (0.0, -0.2890625, 0.8984375),
    (0.453125, -0.234375, 0.8515625),
    (-0.6328125, -0.28125, 0.453125),
    (-0.796875, -0.125, 0.5625),
]

# Get the active mesh
obj = bpy.context.edit_object
me = obj.data
bm = bmesh.from_edit_mesh(me)

Epsilon = 0.00001

"""
Here we iterate over the lists of verts and coords. We remove
the coordinate from the 'coords_to_find' once it's found. this
decreases the number of comparisons on the remaining vertices.
-- it might also make sense to _break_ when 'coords_to_find' is empty.
"""

for v in bm.verts:
    for idx, coord in enumerate(coords_to_find):
        if (v.co-Vector(coord)).length < Epsilon:
            v.select = True
            print(v.co)
            coords_to_find.pop(idx)
            break

# Show the updates in the viewport
# and recalculate n-gon tessellation.
bmesh.update_edit_mesh(me, True)

KDTree

An alternative, which might be faster (especially noticable on larger objects) uses the built in KDTree module. There are 3 search functions find, find_n and find_range.

import bpy
import bmesh
from mathutils import Vector, kdtree

coords_to_find = [
    (0.3203125, -0.734375, 0.7578125),
    (0.0, -0.2890625, 0.8984375),
    (0.453125, -0.234375, 0.8515625),
    (-0.6328125, -0.28125, 0.453125),
    (-0.796875, -0.125, 0.5625)
]

# Get the active mesh
obj = bpy.context.edit_object
me = obj.data
bm = bmesh.from_edit_mesh(me)

size = len(bm.verts)
kd = kdtree.KDTree(size)

for i, vtx in enumerate(bm.verts):
    kd.insert(vtx.co, i)
kd.balance()

for idx, vtx in enumerate(coords_to_find):
    co, index, dist = kd.find(vtx)  # dist is the distance
    print(idx, vtx, index, co)
    bm.verts[index].select = True

# Show the updates in the viewport
# and recalculate n-gon tessellation.
bmesh.update_edit_mesh(me, True)


Locking an object's pivot point in game engine

If I understand the question correctly, the needle is holding the arm up, as it cannot move, only rotate. (locking the translations does let it rotate, but it gets held whereever it starts.)

If that is the case, then you need Rigid Body Joint constraints.
Then the needle will be able to move, but only in relation to the arm.

Here is a quick setup:


Add a circle or any other object (could be an empty) to the position of the sun and parent the planet to it. If you rotate the center object, the planet will rotate too, you can then animate its rotation via the center object's rotation (or just let it rotate on its local axis via Motion Actuator). Its important to create a new center object for every other planet so that their rotations can be different.

Object Relations:

Sun
Orbit Object

Planet (Origin at sun)

Example (Circles used as orbit objects for demonstration):


Mirror an object via modifiers on a point(instead of a plane)

Create an empty at the origin of your object.
Rotate it 180° relative to the object's rotation.
Add an Array modifier to your object, and disable all offsets.
Enable Object Offset and select the empty from the list.

Using the Object Offset can be a very powerful tool

Another Solution to this would be to use a linked copy, created with AltD and rotate that 180°. Linked copies share the same mesh.


Topology

First of all if you need to bend a mesh you will need proper quad based topology. This will allow also to add Subsurf Modifier later on if needed.

Here is an example how it can look:

You can make it as you want, just keep quads.

Bending:

In this method I'm gonna use Bezier Curve and Curve Modifier.

Add to your scene Bezier Curve and place it accordingly to your leaf mesh. For example:

After that add Curve Modifier to leaf mesh and select Bezier Curve as Object.

Now you can move leaf mesh or in Edit Mode change Bezier Curve shape as needed.

Blend file:

You can check my answer here for similar method:
 Bending a ping-pong racket


Subsurface Modifier on a cube versus just adding a sphere itself

Catmull-Subdividing a cube does not result in a sphere. You will need to cast to a sphere with ⇧ Shift⎇ AltS To Sphere operation or a Cast modifier. This question covers that.

The sphere and the spherized cube may look similiar, but the topology is different.

The key advantages of the subdivided, spherized cube are

Even Topology The sphere has dense topology at the top and much less dense topology at its equator. If you want to sculpt or otherwise modify the spherical shape, you want to have similiarly sized faces everywhere.
A 90° rotated sphere would also not give the same results as a sphere with no rotation.
Only Quads In organic modeling, which uses subdivision, we strive for topology which main uses quads. The sphere has many triangles at it's poles. Triangles will produce unnatural creases in combination with the subdivision surface modifier.


Vertex normal issue after separating and re-merging

First off:
Yes this is normal behaviour.

When you split a parts off of a mesh, then you get more vertices. Those new vertices have their own normals and the normals of the old vertices change a little.

Why? Because vertex normals are calculated by averaging the normal for all adjacent faces of a vertex.

You can see the change of the vertex normals in this image:

You use tangent space normal maps so you'll have a problem in your game engine, because tangent space normal maps change the normals of your mesh based on the existing normals. Maybe it still looks ok in your engine, the difference of the normals is not that big, then just leave it as it is.

If it doesn't look ok and you can see a sharp edge, then you have these options (that I know of):

Rebake the normal map to the new split mesh (that's probably going to be complicated because projections are also based on mesh normals ...)
Use the Normal Edit Modifier and create a vertex group and an object to point the normals to for every single vertex you need to adjust (hopefully your exporter accepts the info correctly, because applying the modifier doesn't work and you will not see any changes on the normals in edit mode)
Use the Data Transfer Modifier to transfer the normals from your old, unsplit mesh to your new split mesh (check "Face Corner Data" and "Custom Normals" and hope that your exporter accepts the info correctly, because applying the modifier doesn't work and you will not see any changes on the normals in edit mode)

I know that Maya allows manual editing of individual vertex normals and 3ds max has smoothing groups which is a weird way to almost set vertex normals manually, but not quite (and it wouldn't work in your case).

Sorry to leave you with bad news. Good luck!


How can I create a texture that looks like a woven strands of metal?

I would try doing this with a procedural texture on a torus.

Using a simple voronoi texture and scaling it so that it creates a texture for the vertical strands. And feeding that to control the mix between a transparent and glossy shader.

Then use the same kind of setup but rotated 90 degrees for the horizontal strands.

Then mix the two textures (with a multiply operation), and use the resulting image to control the mix between glossy and transparent, but also use that to create some displacement. Adding a Brightness/Contrast node will give you control for the transparency and the amount of displacement.


Ok. i did find. how i will do that. you can look that image:


When set to median and face as target an objects median (center) will snap to a face.
This example shows how snapping works with different objects and snapping an edge of the same object.

When you use closest as snapping target then objects will snap to the top of the face.

Snapping doesn't work by pressing Enter by itself.

Using Face|Closest|Project individual elements on the surface of others you can achieve the following results but you should press g before pressing Enter.


Baking a Path Animation for Export, Deleting the Path

You probably missed Visual Keying selection part.You need to select it, cause when you check Transforms for the object animated this way, it's position is actually not changing, so by baking action, you get only 2 frames - for start and the end animation and both have the same value. You need to bake visual transforms instead, then everything works. There are two ways to animate object along the path. One with parenting.Then this set of options needs to be selected for everything to work smoothly for baking action:
You are using second way, with use of constraint. Then you need also select Clear Constraints option.


How to extrude a face parallel to another?

The fast, inaccurate way

Select one of the upper edges and the lower edge, which you want to connect.
Subdivide W > S
Use the edge / vertice slide by pressing G > G
Enable the Even checkbox in the edge slide operation settings.
If necessary enable the Flipped checkbox in the edge slide operation settings.
Adjust the Factor slider estimating the slide position closest to the upper vertex.
Merge the upper vertices.

The slow, accurate way

Delete the face, which you want to split with the edge (loop).
Select the edge, which you want your new edge to be parallel to.
Go into Normal transform orientation mode, then (in the Properties Panel under Transform) press the + icon.  This will add the orientation of the edge as a possible transformation orientation.
Place a new vertex by subdividing the lower edge.
Snap the 3D cursor to the upper vertex, from which you want the edge loop to start.
Enable 2D Cursor as Pivot Point.
Select the vertex on the lower edge and scale it to 0 (with the 2D cursor as a pivot point). Limit the scale operation to the X and Z axis. Select the transform orientation of the edge, which we added earlier.
Make the new faces.


Horizontally rotate the Viewport in 180 degrees to see the back side?

Numpad 7 is the shortcut for top view, Ctrl+Numpad 7 is the shortcut for bottom view.

Same for Numpad 1/Ctrl+Numpad 1 (front/back), Numpad 3/Ctrl+Numpad 3 (right/left)


What you want is most likely the sun light: https://docs.blender.org/manual/en/latest/render/lights/light_object.html?highlight=light#sun-light


Applied boolean modifier leaving shading artifacts with flat shading

Another way is to use the Auto Smooth option in the Mesh Context.

Set your object's shading to Smooth first to see the effect.

One advantage this has over the Edge Split modifier is that it won't cause problems if you add certain other modifiers subsequently in the stack, such as SubSurf. Another is that it doesn't increase your vertex count.

Note that any edges that have been marked as "sharp" (Edit Mode: CtrlE > Mark Sharp) will remain sharp even when the Auto Smooth angle value is at its maximum 180°. Knowing this, you can manually specify which edges should be sharp instead of relying on an automatic calculation by angle, if you need to be precise.

So you can choose between the Edge Split modifier and Auto Smooth depending on which is most appropriate for your needs.


How to Reopen the 3D Viewport along side the UV Edit Window

I have created a hotkey for performing this most frequently needed operation with areas.

RMB click on the edge between two areas
Choose Split Area
Right Click on it again.
Choose Add Shortcut
Press the hotkey you would want to use for splitting areas (I used CTRL+ALT+SHIFT+X)
Then press the hotkey to initiate the split.
Pressing MMB button can change the direction of split.
Click the mouse when satisfied with the proportions of split.

References

Arranging Areas in Blender


Why do I get black dotted lines on my mesh when switching to look dev mode?

(Assuming Blender 2.80)
Looks like there are two edges at (nearly) the same place. Go edit mode and "Merge Vertice->by Distance". Play around with the distance value a little bit. Make a backup of the file before.


How to create this effect of embossy surface and repeated pattern with scale?

Make a plane and Bend it

The object has two main features: it's cylindrical and it's cover with a pattern. A possible way to approach the problem could be to focus first of all on the pattern and then repeat it on a planar surface that we are going to bend.

The pattern's tile

First step is to model a "tile". I started from the main loop: an half circle. I built the following shape by extruding and ajusting the vertices manually keeping an eye on the flow of the edges. Then I duplicated the single petal around and cut with the knife tool the pieces outside the "ideal" square box in order to obtain a perfect match of the instances borders of the array. Mirror modifier will ensure the symmetry on the X axis. It's important to keep in mind that when a bored ends, the other should start: that's wy the scale is a little rotated and not parallel with the XY plane.

I kept it low poly because I planned to use SubSurf and to be able to make changes quickly.

Note: there are surely better topology for the mesh; I'll present here just a sample. Keep in mind that we are going to bend it on the X direction, so there should be a good amount of edgeloops running from top to bottom.

Deforming a plane

It's now time to add a few modifiers to the object:

An Array modifier that replicate the object in X (set Merge option enabled)
Another Array modifier that replicate the object in Y (set Merge option enabled)
A Simple Deform modifier with Bend mode , 360 degree of rotation and a custom object (an empty previusly created) to manipolate the center of rotation
A Subdivision Surface modifier with Catmull Clark option to smooth the edges and increase the resolution before the final tapering
A Lattice modifier to control the deformation of the cylinder along its revolution axis. It also helps in making the scales smaller toward the end once enabled Proportional edit mode.

The main body of the object can be said inished. You should now proceed to create the top and the bottom pieces and refining the object (removing doubles, building the inside shell, assing different materials...) once you are satisfied with the result of the modifiers. In order to edit the resulting geometry you must apply the modifiers before entering edit mode.

This approach that heavily take advantage of modifiers it's quite flexible and non-destructive, but it is successsuful be used only because your geometry has a polar symmetry.

Tissue add-on cannot be helpful in this case because of the roundness of the shape in combination with the low number of repetition of the pattern (you'll have to rely too much in the subsurf smoothing), while Simple Deform modifier does instead a great job on this aspect.

Result: