PoseBone local rotation values to global with axis changed

Not sure what you need. Try this for rotation between local space and world space
for pbone in context.object.pose.bones:
    # This is the transform from bone local space to world space
    world = context.object.matrix_world @ pbone.matrix

    # If there are non-uniform scalings or shears in `world`, this won't work...
    _loc, rot, _scale = world.decompose()

    print(rot.to_axis_angle())

If you want the relative rotation from the rest pose to the current pose in world space, maybe this
for pbone in context.object.pose.bones:
    world = context.object.matrix_world @ pbone.matrix
    world_rest = context.object.matrix_world @ pbone.bone.matrix_local

    _loc, rot, _scale = world.decompose()
    _loc, rot_rest, _scale = world_rest.decompose()

    print(rot.rotation_difference(rot_rest).to_axis_angle())


How to smooth or blur a procedural texture?

To blur such a procedural texture, you can't simply add a 'blur' node or similar at the point you indicate. Instead, you need to manipulate the input Vector to distort the texture and then rely on the Render Samples to produce the blurring.

One easy way of achieving this is to add the nodes shown.

Use the relevant output of the Texture Coordinate node (Generated, Object, UV, etc) depending on how you want the texture (and blurring) to be applied. The 'Subtract' node is set to its default (mid-gray) with factor set to 1.000 - this is to adjust the Noise texture to ensure the blurring is even. The Noise texture is set to a very high scale and the Factor of the Add node can be adjusted to change the strength of the blur (0 = no blur, 1.0 is maximum blur).

As mentioned, you should set your Render Samples (on the Render properties) to a higher value so as to allow the rendering enough samples to produce a clean 'blur'.

Examples showing no blurring and blurring :


I marked the first correct answer as accepted. This is indeed a problem with network drives. But it seems I found a workaround, so I post it here.

The workaround removes all network drives from Blender, so it doesn't hang while trying to access them. It will also kill the possibility to save / load files to network drives in Blender. I do not need this feature so this is fine for me.

Before you start with this, try running Blender as Administrator (right click on its shortcut and choose 'Run as administrator'. I heard it might remove network drives on some systems. It did not work for me however. Verify by going to File> Open in Blender and see if network drives are still there.

Steps which resolved this for me:

Create a new user in Windows. I named it "Blender". Set administrative rights to it so it can access all the files and create a valid, strong password for it so nobody will login to the PC with it.
Create a shortcut somewhere (ie. desktop) to start blender. It can be a copy of the blender shortcut which is in the start menu (Start -> find blender -> right click -> copy, then right click on desktop -> paste).
Change the target of this shortcut, so it is not:

C:\Program Files\Blender Foundation\Blender\blender.exe

but instead:

runas.exe /savecred /user:Blender "C:\Program Files\Blender Foundation\Blender\blender.exe"

If your path to blender.exe is different, adjust accordingly. If you username is different than Blender, also change it.
Now double clicking new shortcut will start Blender on this different user account. At first run it will ask for the password - enter the password set for the Blender user.
Blender will start instantly, because this new user doesn't have any network drives mapped.
If caring for look, you can change the icon for the shortcut, because now it doesn't look like anything Blender like. Just find 'Change Icon' button in shortcut properties, navigate to:

C:\Program Files\Blender Foundation\Blender\blender.exe

and set a proper icon.
Blender is now like fresh install without user settings. You can copy your current settings by copying:

C:\Users\\AppData\Roaming\Blender Foundation\Blender\2.76\config\userpref.blend

to

C:\Users\Blender\AppData\Roaming\Blender Foundation\Blender\2.76\config\userpref.blend

This path might different on your system or different Blender version. Do the same with other files in this folder: 'bookmarks.txt' and 'recent-files.txt'. If you have more files there, consider them as well (I only had those).


How to have editor panes in the workspace be different editor types

Ok this isn't possible.  What's being show in the video is opening a different Editor Type which is possible.  What the question is asking for is opening the same Editor Type but with a different Editor Mode.  And this isn't possible: perhaps because the contextual interface on the right would be confusing as it would depend on which editor pane you were in.


How do I connect these meshes correctly?

You should begin with the circular shape because it's the most convenient to do, then make a series of extrusions.


I'm not sure but it might be in Object> Transform> Align Object. You should have a popup right under your screen titled "Allign Object"
e.g.:

If I'm wrong, feel free to correct me!!
Note: select your object before aligning it


Your rendered video will always be rectangular.
But you can add a mask over it, using the compositor

Create a black and white image using Blender/Photoshop/whatever
Add an RGB node, using the Mix node
Connect your BW image into the FAC input

How to connect a mask in compositor.
The RGB node changes the background color.


I finally figured out why the icon paths are being lost, follow all the steps you're doing so far and then;

Save the blend file to where your custom brush Icons folder is (in my case I am modifying my startup file so I've put my custom brush Icons folder into %APPDATA%\Blender Foundation\Blender\2.90\config)
Then do File > External Data > Make All Paths Absolute.


As mentioned there are many possible causes but I had this problem because of some mysterious activation of the setting Only Show Selected, "Only include channels relating to selected objects and data." I do not know exactly why this gets set (besides obviously clicking it) but clicking its button (so that it is not the active blue color) brings back the keyframes.


Randomly populating procedural shape (or Image Texture) in Cycles

The solution I am proposing is very similar to that proposed by Rich Sedman. But it is more automated and I believe gives more natural results. The final result is:

The main idea is to compute multiple layers of scattered non-intersecting objects and then combine them at the end using some methods that we shall discuss forming a random intersecting scattered objects.

I would like you to study this article first as we will be using concepts discussed in it: Introduction To Texture Mapping

First, we use modulo to create a grid sub-coordinates plane, if you use the output as the coordinates for some image texture or a procedural texture, you will see the shape repeated on the grid:

By flooring the result of the multiplication of the coordinates with the value, and evaluating noise at the output, we get constant random value for each cell. Floor is performed by rounding after subtracting $0.5$.

Assuming the absolute of the bounding locations of the computed shape will never exceed one in all axis, we can scale the sub-coordinates by dividing them by the random values we computed. The random values has to be between zero and one so as not to get too big and become out of the bound of its cell.

We now move each of the sub-coordinates by some random amount putting in consideration not to move it too far so as to keep it in bound. Since we know the maximum scale of each shape (The random values used for scale), we know our translation limits, smaller shapes have more freedom while bigger shapes don't, the limiting equation can be derived by looking at this illustration:

Lets say we have a frame with width $200$ and a box with width $25$, how many steps can we move the box such that it touched the edge? We can count $7$ in this case, which is the ratio between the frame width and the box width minus 1, that is, $\frac{200}{25}-1=8-1=7$. So by applying this in our node tree:

Then we perform random rotation, using yet another noise output multiplied by $2\pi$ used as the angle of rotation, you already know how to perform the rotation, so I shall not show it here:

Even though we randomized every transformation, it still doesn't look very random, to make it more natural, what I am going to do is remove some of the shapes if some noise value is less than some value:

And I am going to group what we just did, where the seed is the distortion of the noises:

Now is the time to create multiple layers of this and combine them, but before doing that, lets assign some colors to the shapes to see them better using one of the noise outputs as the color channel:

To create the layers, we are going to use a loop, the loop structure is provided by the ShaderNodesExtra Addon:

In the loop, we offset the coordinates plane by some random amount, mix the old color with the new one and reassign, very simple. This gives us the result:

Here is the blend file:


Rotation as far as drivers are concerned are in the Radian Units not Degrees, even though on the interface, this is probably what you are used to seeing.

so for the scale (x/y/z) formula it would probably have to look something like the following:

var / (2.0 * 3.14157)


How to use the Rigify building blocks for non-human rigs?

Create an armature and enter its edit mode. Delete the bone to start fresh.

You can build a custom metarig from "samples" that you can add in. Later this metarig is used to generate the rigify rig.

To know what samples to use for your use case try them out and see what they do.

Each sample will be added in the scene origin. Position the samples like you want, align them to your character. Parent them to form the metarig. You can create the human metarig that you can add as a whole from samples or you can create your own metarig (one with 4 arms for example). There are also animal parts available.

You can mix them how ever you like.

You can also add your own bones and make them 'Rigify-able'. In Pose mode select a bone and inside Rigify Type tab in bone properties you can change the parameters:

You can change on which armature layers will Rigify generate bones and customize other settings. This can be changed on the sample metarigs and on the individual samples as well.

You can see what the options do in the addon documentation (Advanced usage section).

Then generate the Rigify rig from your metarig.


Blender doesn't support rendering armatures directly.

This is intentional and there is no plan to add support for this feature. ~ @ideasman42

However, I've come up with script to convert armature into mesh or skin.

Implemented as blender addon, only BBone armature style is supported (bezier bones, subdivided bones etc are untested).

Creates mesh if armature in "pose" mode. Creates SKIN if armature is in "skin" mode.

armature_to_mesh.py

bl_info = {"name": "Armature To Mesh", "category": "Object"}

import bpy
import mathutils

class ArmatureToMesh(bpy.types.Operator):
    """Armature to mesh/skin conversion script"""
    bl_idname = "object.armature_to_mesh_skin"
    bl_label = "Armature to Mesh/Skin"
    bl_options = {'REGISTER', 'UNDO'}

    def decomposeMatrix(self, matrix):
        return [x.to_3d() for x in matrix.transposed()]

    def processArmature(self, context, arm, genVertexGroups = True):
        print("processing armature {0}".format(arm.name))

        if genVertexGroups:
            #because setting pose_position ot 'REST' manually doesn't work for some reason.
            genVertexGroups = arm.data.pose_position == 'REST'

        meshName = arm.name + "_mesh"
        meshData = bpy.data.meshes.new(meshName + "Data")
        meshObj = bpy.data.objects.new(meshName, meshData)
        meshObj.location = arm.location

        scene = context.scene
        scene.objects.link(meshObj)

        armMatrix = arm.matrix_local.copy()

        verts = []
        edges = []
        faces = []
        vertexGroups = {}

        for bone in arm.pose.bones:
            poseBone = bone
            boneName = bone.name
            armBone = arm.data.bones[boneName]
            #print(poseBone.matrix)
            #print(armBone.matrix)
            #print(boneName)

            boneMatrix = poseBone.matrix
            boneStart = poseBone.head
            boneEnd = poseBone.tail

            decomposedMatrix = self.decomposeMatrix(boneMatrix)
            #print(decomposedMatrix)
            xSize = armBone.bbone_x
            zSize = armBone.bbone_z
            #print(xSize, zSize)
            xSizeAdd = bone.x_axis
            zSizeAdd = bone.z_axis
            xSizeAdd = decomposedMatrix[0]
            zSizeAdd = decomposedMatrix[2]
            ySizeAdd = decomposedMatrix[1]
            origin = mathutils.Vector((0.0, 0.0, 0.0)) * boneMatrix
            xSizeAdd *= xSize
            zSizeAdd *= zSize
            ySizeAdd *= bone.length

            baseIndex = len(verts)

            verts.append((boneStart - xSizeAdd + zSizeAdd)*armMatrix)
            verts.append((boneStart + xSizeAdd + zSizeAdd)*armMatrix)
            verts.append((boneStart - xSizeAdd - zSizeAdd)*armMatrix)
            verts.append((boneStart + xSizeAdd - zSizeAdd)*armMatrix)
            verts.append((boneEnd - xSizeAdd + zSizeAdd)*armMatrix)
            verts.append((boneEnd + xSizeAdd + zSizeAdd)*armMatrix)
            verts.append((boneEnd - xSizeAdd - zSizeAdd)*armMatrix)
            verts.append((boneEnd + xSizeAdd - zSizeAdd)*armMatrix)

            base = baseIndex
            newFaces = [
                (base+0, base+1, base+3, base+2),
                (base+5, base+4, base+6, base+7),
                (base+1, base+0, base+4, base+5),
                (base+2, base+3, base+7, base+6),
                (base+3, base+1, base+5, base+7),
                (base+0, base+2, base+6, base+4)
                ]
            faces.extend(newFaces)

            if genVertexGroups:
                vertexGroups[boneName] = [(x, 1.0) for x in range(baseIndex, len(verts))]

        meshData.from_pydata(verts, edges, faces)

        if genVertexGroups:
            for name, vertexGroup in vertexGroups.items():
                groupObject = meshObj.vertex_groups.new(name)
                for (index, weight) in vertexGroup:
                    groupObject.add([index], weight, 'REPLACE')

            modifier = meshObj.modifiers.new('ArmatureMod', 'ARMATURE')
            modifier.object = arm
            modifier.use_bone_envelopes = False
            modifier.use_vertex_groups = True

        meshData.update()

        return meshObj

    def processObject(self, context, obj):
        if (obj == None):
            return False
        if (obj.type != "ARMATURE"):
            print ("invalid type {0} of object {1}: armature expected".format(obj.type, obj.name))
            return False
        self.processArmature(context, obj)
        return True

    def execute(self, context):
            scene = context.scene
            selected = context.selected_objects
            processedAnything = False
            if len(selected) > 0:
                print ("selected objects present, processing selection")
                for obj in selected:
                    processedAnything |= self.processObject(context, obj)
                pass
            else:
                print ("processing active object")
                obj = context.active_object
                processedAnything |= self.processObject(context, obj)

            if not processedAnything:
                print ("no objects processed")

            return {'FINISHED'}

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

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

##register()


can you check if the falloff of the brush is set as sphere and not "projected"?


You could do it this way:

Create your star (10 vertices cylinder, scale 5 of them). Extrude it with altE > Region (Vertex Normals). Click the Offset Even option in the operator panel (bottom of the T panel in 2.9, bottom left box in 2.8).

Delete the faces with X > Faces.

Extrude all and again with altE > Region (Vertex Normals) and click the Offset Even option. You could as well use the Solidify modifier.


How can I use the "Fill" in texture paint on only a single face instead of the entire uv map?

select your object

choose texture paint from the menu

tab -> edit mode

choose "face select mode"

select the faces you want to paint on

tab -> texture paint mode

click this button: paint mask

paint what you want -> now you just paint on that faces you selected

you can select the faces in the texture paint view too...just tap on select and choose your favorite selection mode

you can check a tutorial video here:
https://youtu.be/TYq49SLlot8.  (just be a little bit patient, my internet is not fast)


Custom Toggle Shortcut (for an operation that doesn't normally toggle)?

As you are a veteran here, I will point you in the right direction and when you have it you can post it here as answer:)

You need an operator that doesn't simply do a thing, but does a thing based on condition. That means you will have to script your own operator, and assign a custom shortcut to it:

How to register custom operator
In the execute function, you will have to check the active object and all it's faces and see their smooth attribute:

How to get Bmesh from active object
Bmesh faces: BMFace.smooth

Based in which state the mesh is, execute

shade_smooth operator
shade_flat operator
How to run an operator: refer to point 1 last line of example code

Assign a custom shortcut to your operator:

Adding a custom shortcut

Turn it into an addon, so you don't have to run the script every time (or also save it in the startup file, check register and enable auto run scripts):

Simple addon example with operator


Perhaps a shrinkwrap modifier on the shoe? But to be honest this might be a slightly more complex setup.

Some others ideas:
Use a driver linking shapekey influence to a shapekey on the shoe.
Use shrinkwrap but with a simpler mesh, that in return influence the high res shoe through a mesh deform.

Got to see your file for more help.


Open the N Panel in the graph editor and go to the F-Curve sub-panel.
Change the Easing Type of the left keyframe from Ease In to Ease Out.
Alternatively, while the left keyframe is selected, Right-Click > Easing Type > Ease Out.
Another solution, use the shortcut Ctrl + E > Ease Out while the left keyframe is selected.
Ease In:

Ease Out:


So, the answer is. Instead of measuring the angles between camera direction and axis I should measure the angles between axes and the local axes of the plain aligned with the camera.


Working on small objects in MM but Add menu adds relatively giant objects

After adding new object press F6 and set acceptable size or radius of the object.

Next time, during session, then you add same object, blender will remember that size.


Try fcurves.find...you need to access it from object.data.animation_data instead of object.animation_data (since bevel start end are part of data block). You can find the data path by right clicking on the property in the edit properties panel.
for o in bpy.context.selected_objects :
    action = o.data.animation_data.action # Note: o.data.animation_data
    fcurve = action.fcurves.find('bevel_factor_start'):
    for keyframe in fcurve.keyframe_points:
        keyframe.co[0]=keyframe.co[0]+10

```


From link below: "By default handlers are freed when loading new files. In some cases you may want the handler to stay running across multiple files (when the handler is part of an add-on for example)."
You may need to use the persistent decorator:

import bpy
from bpy.app.handlers import persistent

@persistent
def my_handler(scene):
    print("Frame Change", scene.frame_current)

print("test")
bpy.app.handlers.frame_change_pre.append(my_handler)

see https://docs.blender.org/api/blender_python_api_2_60_6/bpy.app.handlers.html


Can I adjust the rendered view background?

You can change the checker size and colors in:
Preferences > Themes > User Interface > Transparent Checkerboard
To get rid of the checkerboard entirely, set both colors to be the same.


The issue is that the part with the label has a different material than the rest of the copper container.

Go into edit mode and make all of the object have the same copper material

Now that everything is copper then add the label texture and transparency to the node tree:

The texture should fall into place since the only faces that have a UV map are the ones you chose for the label.


Open blender, and select File > External Data > Pack All Into .blend.  This should pack all your game assets that are in use into the .blend.  Then, when you save it as a .exe, they should be in the .exe.


The video you mention is very old, it uses blender 2.49 which was before the major interface overhaul that started with blender 2.50. The mesh panel you are looking for had several things grouped together that are now in different places.

The retopology part that you are after is now better defined under snapping options. With transform snapping enabled set the snap element to face and you can have vertices you move snap to an existing surface.

Blendercookie has a more recent retopology video that you should find helpful.


Removing overlapping faces and internal edges from a 2d geometry

If you are on 2.79, you could use the TinyCAD addon:

Make sure that all your planes are on the same level on the Z axis, if not select all and press SZ0.
Keep everything selected and press W > TinyCAD > XALL
Only the edges remain, press W > Remove Doubles.
Delete the useless vertices with X > Vertices.
Fill the faces with F.
If you want to keep a central hole you need to have enough topology.


Is there a way to have my emission shader only affect the particle system?

What you want is light groups. Well, the light groups feature hasn't been implemented in Cycles yet. If you wanna separate lighting on different objects, including particles, using Cycles, you might use render layers. Here's a solution for a practically the same question as yours.


Volumetrics
X-ray images can be simulated with the use of a quite simple volumetric shader in conjuction with a very good modeling.
The information stored in such imagesis basically just one: how fare the X ray radiation goes far? The variations is caused by the different nature of materials. Each one of them let the ray pass more or less.
In Cycles engine, there is no X-ray radiations, but we can simulate the behaviour with light. The energy of the source will be absorption by passing through a volumetric shader like the following.

The hard part is that you must:

model everything with it's own, real, thickness in order to achieve a correct absorption calculation

create a different volumetric shader for each kind of material of your scene (one for glass, one for metal, one for filament...) and estimate the light absorption value (driven by the Density parameter).
The model in the above picture comes from a collection of CC0 Bulbs on Blendwap


How to make a truly smooth edges on low poly model?

A normal map (baked from a high poly for instance) can solve the issue. So if you were going to use normal maps anyway, the problem will most likely become less prevalant.

Anyway, my process for setting up smooth and hard edges in Blender:

Select all faces and press W and choose Shade Smooth. Then for the edges you want to hard edges: Select those, and Ctrl+E, Mark Sharp. Add an Edge Split modifier. Uncheck 'Edge Angle' and make sure 'Sharp Edges' is checked.
As far as I know that's all you can do.

The rest is down to the shader and how it interpolates the normals between two connecting vertices. And the only simple way to take control of those normals is with a normal map.


Blender 2.8.2 Crashes on Startup (Windows10) - Not enough video memory?

OK I figured it out. I was connecting my display to the motherboard's HDMI port instead of my video card!

I couldn't access my Nvidia Display Properties as I "Didn't have an NVIDIA GPU attached to my display" so I suspected that was related, and when I fixed that, Blender also worked like a breeze. No wonder it couldn't properly find video memory, etc.


What is the difference between the displace socket and a bump map?

Theoretically they are meant for similar purposes and functionally there is overlap when used in simple cases.

However, when used for extreme bump mapping, the bump map node produces much better results:

Left: Texture plugged into displacement output Right: Bump map node plugged into shaders

The other difference is of course that the displacement output can be used for actual geometry displacement (when when using the experimental feature set):

Left: Bump displacement Right: True displacement

Both spheres use the same material with the texture plugged into the displacement output. The sphere on the left uses the default Bump displacement method, while the sphere on the right uses the True method:

Note that the sphere on the right has a Subsurf modifier on level 4 to give it enough geometry to displace. There is a Use Subdivision option in the displacement settings, but I found this causes some wireframe artefacts.

Finally, using the Bump node allows you to choose not to have a bump map for certain shaders. For example you may want the gloss on the material to appear like a glossy coat or varnish, while still having a bump map for the underlying diffuse shader:

Left: Same displacement for all shaders Right: Different displacement for each shader

For reference, here is the sphere with no bump or displacement


Put an alpha channel on the texture where you want it to be glossy, then use a color ramp node to mix between your original shader and a glossy shader.


If object has mostly straight angles that need to be traced:

Create curve->Right click->Set spline type->Poly-> Just keep clicking E to extrude individual points. Because Object itself consists mostly of straight angles, its easier to do that.

If object need to have round angles in the end model:

Create curve->Right click->Set spline type->Poly-> Just keep clicking E to extrude individual points->CTRL+SHIFT+B on vertices in edit mode for accessing vertices bevelling.


Is subdivision surface modifier used only in blender?

This is a complicated question. The best general answer would be that yes, almost all 3D software has some sort of non-destructive subdivision function. It takes a lot of different forms though.

First of all, not all 3D software even has something that would be recognizable as a modifier stack. For example, in Maya, subdivision is an option on the shape node (equivalent to the object data block in Blender). Either via the "smooth mesh" function, or via render-engine specific settings.

The bit about renderer settings is probably worth mentioning, because subdivision is frequently applied by the renderer, rather than subdividing when building the mesh and handing the already subdivided geo to the render engine. By letting the renderer handle subdivision, you can export just the base mesh, which is generally faster since the renderer can optimize the subdivision while doing it's the other tessellating and pre-chewing that all renderers do when starting up. It also makes for smaller files when exporting the scene to disk since the scene file will store the base mesh and a subdivision flag rather than the subdivided mesh.

The "micropoly displacement" feature in Cycles is actually an implementation of render-time subdivision, among other things. (such as view-dependent subdiv, displacement of the subdivided mesh, auto-bump). When a subdivision modifier is at the bottom of the modifier stack and you check the "adaptive" checkbox on the modifier, the subdivision modifier will be skipped on export and Cycles will be given the base mesh with subdiv settings in its place. Cycles will then generate the subdivided mesh on the fly at startup. There's no reason this couldn't work with non-adaptive subdivision as well, but AFAIK it doesn't do this as of 2.79.

Something similar happens when exporting an Alembic cache and you check the "use subdivision schema" flag. The modifier will be skipped, and a flag will be left in the file that tells the importing app to apply whatever non-destructive subdiv function it has.


Yes you can. You can also pack the textures inside the blend file itself. All of these options are available in File>>ExternalData>>
(note: I'm on 2.9 alpha, can have slightly lesser options in previous versions)
See the following image:


Blender crashes when running custom operator EXCEPTION_ACCESS_VIOLATION

Kinda hard to answer this q in it's given format. As pointed out by @RayMairlot you are using property definitions incorrectly which is very a likely cause of your woes, possibly with the list bpy.types.Scene.hidden_objects, especially if you have removed (deleted) an object that is in the list prior to accessing it again.

When using bpy.props to assign properties to classes registered with Blender for example you assign the is_isolation_mode property to the Scene class.

bpy.types.Scene.is_isolation_mode = bpy.props.BoolProperty(default=False)

And access on each instance of the class, eg bpy.context.scene , bpy.data.scenes["Scene"] etc.

And definitely NOT by doing this

bpy.types.Scene.is_isolation_mode = False

which assigns false to is_isolation_mode for all instances and cannot be altered from the instance. Toggling above to true makes it true for all instances, which is not what you want.  Example code below from the console.

>>> C.scene.is_isolation_mode
False

>>> C.scene.is_isolation_mode = True
Traceback (most recent call last):
  File "<blender_console>", line 1, in <module>
AttributeError: 'Scene' object attribute 'is_isolation_mode' is read-only

Suggested Alternative Method

A suggested solution to having a pseudo-local mode is using an update method on the is_isolation_mode property assigned to the scene object.

Example code: when in isolation mode all visible objects, except the context object, are hidden and given an "isolation_mode" ID property.  They are unhidden and the prop is removed when not in iso mode.

import bpy
from bpy.props import BoolProperty

def hide_mode(scene, context): # standard to use self here to show it's a prop
    if scene.is_isolation_mode: # scene is also context.scene
        obs = [o for o in scene.objects if not o.hide and o != scene.objects.active]
        for o in obs:
            o["isolation_mode"] = 1 # could be anything (bool, int, float, string)
            o.hide = True
    else:
        obs = [o for o in scene.objects if o.get("isolation_mode")]
        for o in obs:
            del(o["isolation_mode"])
            o.hide = False
    return None

bpy.types.Scene.is_isolation_mode = BoolProperty(default=False,
                                                 name="Isolation Mode",
                                                 description="Blah Blah",
                                                 update=hide_mode)

# prepend a toggle button on 3Dview header

def draw_toggle(self, context):
    scene = context.scene
    layout = self.layout
    layout.prop(scene,
                "is_isolation_mode",
                toggle=True)

bpy.types.VIEW3D_HT_header.prepend(draw_toggle)

Toggle button on 3D header

Set via script in python console.


One way is to use 'daisy chaining' through the Normal input.

Daisy chaining bump maps.

Adding a different material to each part.


Python How to make pose bone rotation toward a point?

Matrices
The rotation difference returns how much to rotate from direction to direction. The result needs to be applied to current direction.
Setting the direction absolutely from the rotation difference result will only work for the case when initial value is 0.
By using matrices, will work for whatever rotation type the pose bone has.
Test script. Rotates the context pose bone to point to the head of the pose bone named "Target".
import bpy
from bpy import context
from mathutils import Matrix

rig = context.object
target = rig.pose.bones.get("Target")

pb = context.active_pose_bone

v = target.head - pb.head
bv = pb.tail - pb.head

rd = bv.rotation_difference(v)

M = (
    Matrix.Translation(pb.head) @
    rd.to_matrix().to_4x4() @
    Matrix.Translation(-pb.head)
    )
pb.matrix = M @ pb.matrix

Emulating the constraint.
Can roll the bone around its Y axis in result above and it will still point to target.
POSE space is one of the more "tricky" spaces since it is defined by the head, tail and roll of each bone as set in edit mode.
To get but one roll result
q = v.to_track_quat('Y', 'Z')

makes a quaternion from vector v that points its $Y$ direction to vector with $X$ axis up.
There is a handy convert_space method available on all objects.
>>> rig
bpy.data.objects['Armature']
>>> rig.convert_space(
convert_space()
Object.convert_space(pose_bone=None, matrix=((0, 0, 0, 0), (0, 0, 0, 0), (0, 0, 0, 0), (0, 0, 0, 0)), from_space='WORLD', to_space='WORLD')
Convert (transform) the given matrix from one space to another


"script.py" is the name of your script:

2to3 -w script.py

https://docs.python.org/2/library/2to3.html


Your character has 145k vertices, which is quite high for a rigged prop.
One possible optimization, as many parts are "rigid" and don't need deformations, is to parent them directly to bones, without weights (select the mesh part, shift select the armature, go to pose mode, select the relevant bone and press Ctrl P - bone).
But I think you should make a copy of the character, replace its parts with an ultra simplified and decimated version, and use this proxy to animate, then use the original one for rendering.
To have an idea, in my computer your file runs at about 6 FPS, and if I don't want speed problems I stay under 30k vertices when animating.


How to add external armatures to existing object

Before you parent with automatic weights, go into the armature edit mode and align all the bones with the mesh. So that each bone is where it is supposed to be.

Then go into pose mode and clear the location/rotation of all the bones.

Then apply the automatic weights.

here is a .gif of how to do it


Maybe this can be of help you.

you might use a solidify modifier to a certain seize, on a copy of your object.
Then in blender 2.82 in sculpting there is a remesh option. (top right main drawing window) this does do a voxel based remeshing of your model.
You then have a model that is a certain seize larger, thanks to that remisher it hasnt got wrong inner faces (its only the outside).

Then you can use this object in boolean operations (maybe first substract it from a cube, then use that cube shape to remove outsides from your object (ea double anti modelling).

Be aware though that boolean can have its own complexity errors (make sure to have normals recalculated outside before you start using it on all objects).


Is there a way to export an object to Unity 3D while keeping any applied textures?

Textures and diffuse colors are not assigned automatically. You have to manually assign them by dragging the texture onto the mesh in the Scene View in Unity

You don't have to export to .fbx, Unity supports .blend. To import a file into Unity,

Right-click in the Projects pane, choose 'Import new Asset', and navigate to the file
Move the .blend file into your project's Asset folder

You can read more here.


Is there a selection tool that will select everything towards the cursor?

I don't think there exists any selection tool that uses the 3d cursor in this manner but there are a few that work in a similar way.

There is Select > Side of Active.

  Selects all data on the mesh in a single axis

If you select at least a vertex or an edge, it will select all the faces to the positive (right) or negative (left) axis mode of that selection based on the axis you choose in the operator settings. You can also of course just invert the selection to get the other side.

There is also Select > Loop Inner-Region.

  Converts a closed selection of edges to the region of faces it encloses

I would say this is almost the opposite of select side of active. Depending on where you select, it will select all faces to the side that has the lesser amount of faces to the end of the mesh.


Is it possible to omit some objects in a scene from being affected by the environment texture lighting?

There is no way to render it all at once in Cycles. You can use 2 different View Layers with collections as masks to render twice and composite them in the compositor.


How can I get what I edited when I run the game engine?

It seems that you do not have your material display setup correctly. At the bottom of you Blender window,just above the Time Line, you will see a Box the reads, "Object Mode". Next to this box will be a white ball. Left click this white ball and select Texture. Now when you press P to view your animation you should be able to see everything. You may also press the N key to bring out your right panel. There is a section there labeled Shading. Click on Shading and put a check next to "Textured Solid". Then click the box just above this and select from the list GLSL. This should work for you! Everyone that uses Blender goes through these gates which is needed if you will progress farther into the use of this Great Free Software. Persistence is the key to becoming great at using Blender. So do not give up! Just move forward! :O)


Giving the same keyframe to multiple meshes

I can think of two ways: select all the objects you want to apply the animation to, then select the object whose keyframes you are copying last (to make sure that it is the active selected object) then press Ctrl-L to bring up the Link Menu. From there select "Animation Data", and all the objects you have selected should now have the same animation applied to them. Please note that if you have keyframed the active object's Location property that all of the selected objects will be moved to the same location as the active object.
If you don't want the other objects to match the location of the active object, but you do want them to "fly in formation" as it were, then select all your objects, again making sure the object whose animation you are copying is last, then press Ctrl-P for Parent, and select "Object (Keep Transform)" from the dropdown menu.


How do you calculate square root with nodes?

The square root of x equals x^.5, so use a math node set to Power and put the value whose square root you want in the upper socket, and set the lower value to .5.


This style is totally possible with a combination of 3d,freestyle render and grease pencil.
The whole process can be done within Blender itself...including the compositing.

Here is a link to "Hero" a Blender and Grease pencil film to give you an idea of some of the possibilities.
https://www.youtube.com/watch?v=pKmSdY56VtY

But really...the sky is the limit.


How to get edges and normal map from 3D model?

Ref: https://docs.blender.org/manual/en/latest/render/blender_render/textures/properties/influence/bump_normal.html#bump-normal-maps

Normal maps in Blender store a normal as follows:

Red maps from (0 - 255) to X (-1.0 - 1.0)
Green maps from (0 - 255) to Y (-1.0 - 1.0)
Blue maps from (0 - 255) to Z (0.0 - 1.0)

Since normals all point towards a viewer, negative Z values are not stored (they would be invisible anyway). In Blender we store a full blue range, although some other implementations also map blue colors (128 - 255) to (0.0 - 1.0). The latter convention is used in “Doom 3” for example.

If you want to achieve the default Blender normal map definition (z start from 0.0 instead of -1.0). You need to defined what will happen if -1 < z < 0
Below is two examples for how to calculate it by node editor:

Is the first one you are asking for?


The problem is very simple. The displacement in the materials you have given the base mesh of the room destroys your mesh. delete it, and the problem is resolved.


It appears to me that the normals should be recomputed. In Edit Mode select all vertices with "A" and recalculate the normals by Ctrl-N. In addition, you may use "Smooth" from the toolbar in Object Mode to "smooth" the object. But that depends on how it should appear in general.
The vertices appear to be slightly "shifted", such that this kind of artifacts can happen. For me, it's completely ok to use the subdivide modifier. This modified subdivides all faces and reduces the angles of each of the faces.


Blender closes/crashes everytime I open and close a window

The guys over at blender told me what the issue was.
Turns out the problem is caused by my wacom drawing tablet. I uninstalled the drivers and now its working fine again!
Hope this helps someone!


To fix the deformation when binding the mesh to armature you need to apply the pose to Rest position. Change to Pose Mode, then select all the bones and Ctrl+A shortcut and select Apply Pose as Rest Pose. Then Change to Object Mode, select your mesh then the armature and parent with Ctrl+P shortcut.


Determining the optimal suspension location for jewelry

Set the origin of your object at the center of its volume.

Create a passive rigibody.
Make the jewelry an active rigidbody.

Increase the positional and angular damping.

Connect both with a point constraint where the 'hook' is supposed to be.
Simulate the rigid body simulation.


linked mesh data without linking material data?

You can assign the materials on the object level instead of the data level. That way you can have linked mesh data and independent materials per object.


How to Unwrap project from view with script?

I bumped into the same issue and finally solved it!
you just need to have a 3d viewport opened with your desired view and run this script:

import bpy

for obj in bpy.context.selected_objects:
    bpy.context.scene.objects.active = obj
    bpy.ops.object.mode_set(mode = 'EDIT')
    bpy.ops.mesh.select_all(action= 'SELECT')
    for area in bpy.context.screen.areas:
        if area.type == 'VIEW_3D':
            for region in area.regions:
                if region.type == 'WINDOW':
                    override = {'area': area, 'region': region, 'edit_object': bpy.context.edit_object}
                    bpy.ops.uv.project_from_view(override , camera_bounds=False, correct_aspect=True, scale_to_bounds=True)
    bpy.ops.object.mode_set(mode = 'OBJECT')

Hope I helped you!

Cheers!


Tiller ploughing land. The tiller should leave marks on the sand materiel and while ploughing sand particles should emit from the tines of the tiller

Use Dynamic Paint to produce a Displacement.


Best graphics card for Blender Cycles rendering

This is hard to say, because there are not relevant benchmark for cycles. (If someone know one, please let us know).

You can look at http://blenchmark.com/gpu-benchmarks. Keep in mind than this is not accurate results, because results are affected by CPU speed quite enough.

And yes, you are right: more CUDA cores are better for Cycles. "x80" and "Ti" have also wider bus (384bits) and that is the reason why 780 is little bit faster than 970 (with 256bits) in rendering. But 780 have almost double power consumption. Good for 970 is also 4GB RAM.

In my opinion the best what you can do is buy one GTX 970 now and second one (or better) later. In Blender you can use multiple CUDA card and can be different.


Render preview vs Render issue with hair

Well it took me 6 minutes to figure out both issues, so maybe I should have put some thought into it before asking.

The eyelid mesh had a multires modifier on it because i duplicated it from the main mesh in edit mode and it took its modifiers. The preview was at 0 and the render view was at 1. The binding is related to the amount of vertices so it only works in the mode that it was bound, which was 0. So it showed nicely in render preview but not in render. The strange hair was from a different hair emitter that I forgot to delete and that was hidden in the viewport but not in the render.


UV mapping a straight image around a ring shaped flat mesh

Using face select, select all the faces of the circle then have one face the active face (selected last, it will be lighter orange).
Press U > Follow Active Quads, then hit OK.
That will give you a straight line of the  UV for the circular faces, which will deform your pattern around the edge perfectly.


how to disable auto smoothing by default in 2.74

You cannot (well, not from UI or other 'user-land' ways). Note however that 'autosmooth' here is a bit of a weak name, since it actually means you are using (custom) normals as defined by the .obj, instead of auto-computed ones by Blender…

Now, if you really want to disable that by default, you'll have to open addons/io_scene_obj/import.py in your Blender installation, search for me.use_auto_smooth = True (should be around line 657 currently), and replace it by me.use_auto_smooth = False (or just comment it by adding a # in front of that line).

But again, don’t think you want to do that, at least I do not see why you would…


How do you call `bpy.ops.clip.rebuild_proxy()` in the python api without getting a context is incorrect error

So it sounds like the problem is that the wrong part of the interface ('Area') is active at the moment you're calling ops.clip.rebuild_proxy() or sequencer.rebuild_proxy().

I'm working on an add-on that will allow me to add a movie strip, draw waveforms, and start a 50% proxy build all with a single action. I found that I had to iterate through the areas and override the context to rebuild proxy for a specific clip. Here's what worked for me:

ctx = bpy.context.copy()
for area in bpy.context.screen.areas:
    if area.type == 'CLIP_EDITOR':
        ctx['area'] = area
        bpy.ops.clip.rebuild_proxy()


Insert properties keyframe for multiple objects?

So the easy solution would be to write a script that creates keyframes for every selected object.

While the Rigid Body Tools will copy attributes from the active object to all selected, it doesn't copy keyframes. Copying keyframes could be something to add to the Rigid Body Tools. I would think that the animated checkbox is probably the only Rigid Body option that would normally be keyframed.

Within the 3DView, Insert Keyframes will keyframe the same properties for every selected object. Creating a keyingset with an interface property doesn't allow the property to be keyframed for all selected objects. Sounds like a deficiency in the create interface value keyframe operator.

EDIT: There are some options that can help under some circumstances -

CtrlL -> Animation data - can create keyframes for every object to match keyframes for the active object. This creates keyframes for the same properties in each object - it doesn't make the properties the same as the active object.

For rigid body options you can set and keyframe the active object, use rigid body tools to copy settings from active, re-do calculate mass, then CtrlL -> Animation data to create keyframes for each object.

This doesn't apply to non-rigid body values. The following script can easily be modified to set and keyframe a specific value on every selected object, adjusting to work on multiple values is also easy. I used rigid_body.kinematic as an example as I see this as the most likely value to be used in this scenario.

import bpy

set_kinematic = bpy.context.active_object.rigid_body.kinematic

for object in bpy.context.selected_objects:
    object.rigid_body.kinematic = set_kinematic
    object.keyframe_insert(data_path="rigid_body.kinematic")


You can control the colors a single material has, per face, in various procedural ways, or you can UV map your object, and its material can refer to a texture map, assigning colors in any way you like, across the surfaces of your object.

But here, you probably want to assign separate materials to each face.

Click the '+' sign next to the materials list currently showing 'Material', highlighted. This will create a new slot.
Press 'New' below the list, to create a new material, or select a material you have already created, from the dropdown accessible just to the left of that button.
If the material is 'New', give it the color/ other characteristics you want.
With the desired material active in the list, and the desired faces selected in Edit Mode, hit 'Assign'. The selected faces will acquire the selected material.


Need help modeling precise irregular torus

Bevel a curve.
Using method similar to Shrinking tube or bending a cone will make one quarter of torus using this technique and mirror to make rest.
Add two bezier circles,
Select one as The inner radius circle. In edit mode make the spline non cylic and remove and edit such that end up with a quarter circle.
Setting the radius of the each of the end points of this curve gives us the big an small torus radii.

The other will make up the rings of the torus.
In edit mode move the origin of circle from centre to "left side"
Select All
A and shift -1 in x direction
GX-1
This will ensure that when used as a bevel object for another curve (without offset) the origin point will always be on curve, thus ensuring our torus hole matches that of curve.

Now set this as the bevel object of inner circle

Add two Mirror modifiers one in X and one in Y to produce a standard torus
Set the bevel interpolation type to ease, now can adjust the radius of end points.

Note: without going into the maths of this, there will be a point where an ellipse cannot be maintained and will collapse into a cardiod or inflate to an oval.


A likely scenario would be if the normals were inverted. That happens for example if the geometry is inverted(scaled by negative values) at some point during modeling to mirror it. You should go to edit mode (tab), select everything (a) and recalculate normals before baking them. The hotkey is ctrl+n in 2.79 and shift+n in 2.80. You can access functions related to normals in the ctrl+f or Mesh > Faces and Mesh>Normals menus in 2.79, while in 2.80 there is a dedicated Normals menu alt+n.

However in this particual case the issue is the normal map made with overlaping UVs for symetrical geometry. If you have a look at a normal map of a symetrical object, the normals are not mirrored - they differ on each side so if you mirror them you get an incorrect result.


Snapping can be activated using the little magnet icon.  Next to this is a menu for setting the snap type.  What you can't see in the image is that after I activated the tool, I pressed g to move the object and then x to constrain the movement to the x-axis.

If you have the menu set to Increment as shown above, then you can also disable the magnet icon and hold down Ctrl to use the snapping feature.

Conversely, if you do still have the magnet icon activated, holding Ctrl will disable snapping so long as Ctrl is held.

Holding Shift will allow you to move the object in smaller increments.  This is true with or without snapping enabled.

I feel I should mention that snapping can also snap the vertices of one object to  another object by changing the menu selection to Face.  Even though it's unrelated to what you mention, I wanted to point out that the tool has more functionality than just for what you asked here since it's also very useful for re-topology, aligning model components to one another, etc...


You need to tell the shader what texture to put on the cube.  Add a Texture Coordinate node and an Image Texture node to your shader:


How can I make sharp geometric 3d models look more realistic?

For one, you can bevel your objects.

Forgetting to bevel or chamfer edges is one of the most common errors
committed by beginning 3D artists. There are almost no razor sharp
edges in nature, and even most man-made objects have a slight
roundness where two opposing surfaces meet. Beveling helps bring out
detail, and really sells the realism of your model by allowing edges
to properly catch highlights from your lighting solution.

In object mode you can bevel an object by using the Bevel modifier and in edit mode you can bevel edges and faces with Ctrl+B and vertices with Ctrl+Shift+B. The latter will allow you to interactively adjust the amount of segments with the mouse wheel.
Using the modifier.
Take a sharp object you just made, say a simple step. It's plain, simple and ugly when you look at it and would look out of place in almost any scene aiming for realism.

Once beveled, the edges are softened and it just looks more appealing as this is what we are used to in real life. This can be a very subtle effect or an exaggerated one as essentially it just helps to catch light and help show off the shape and detail of the object better.
(It can be a bit hard to see in the viewport at times with the default lights but makes all the difference when rendering with proper lamps)
Here is the bevel modifier with some optimal settings, increasing the value in the Segments slider will make the edge geometry start to approach what is more commonly called a Fillet, effectively rounding your edges. Do be warned however, as adding extra segments creates additional geometry.

Here is another look at how beveling effectively softens your edges.

Some advantages of beveling over other methods are:

It's cheaper than subsurface, meaning it renders faster and weighs down your scene less.
For hardsurface models, it softens or adds realism to your edges easily and effectively.
It's faster to do and gives you more control when compared to other methods such as using creases and or subsurf with edgeloops.

At the time of writing, this is now easier than ever. Cycles will have a Bevel Shader.
Example from Mike Pan on twitter.

Resource links

Example renders https://developer.blender.org/D2803#65805
Discussion thread https://blenderartists.org/forum/showthread.php?436279-V-ray-got-rounded-hard-edge-shader&p=3230688#post3230688
More discussion and examples http://polycount.com/discussion/comment/2570081/#Comment_2570081


How to get rid of the space between the edge of the camera render area and the actual viewport?

You have a View Lock on the camera to view enabled.

Hit the N key and look for the checkbox title Lock camera to view, it might be one of the others but I suspect this is the guilty setting.

This is a known issue for newcomers to blender, but it is actively being worked on, you can read more about improvements relating to these controls on ‘Lock Camera To View’… It was torture to find it!

The fact that you have this happening in all blend files suggest that at some point this had been enabled and has been saved into your startup.blend file, meaning that you need to save your startup file after you've fixed the issue ( but now you know how, so it won't be a problem right? ).


How to create faces connecting a curved area

You can connect the vertices manually.
This will also create proper topology, which is nice.

Select two vertices and go Vertex > New Face from vertices, F
Repeat, repeat repeat until it's filled
Done :).


How do I get Particle Boids to fight each other?

You need to define at least 2 particle systems with a relation enemy to each other, you can define attributes like strength (this will statistically decide who wins [particle disappears when defeated]).

You could add Follow Leader to the boids brain and animate the leader, this would make the particles follow the leader (creates nice formations). There're so many options you need to play around and develop an idea of how it should like.

In the physics settings make sure you checked Allow Flight or restrict them to land.

I stopped playing with this because I wasn't able to create explosions when a particle dies.

Example:


How can I make metal look decayed and rotted

Final:

Overview:

Basically you can use the same method as for creating any other rust material with one exception at the end - mix your rust material with Transparent shader trough "rust mask", created beforehand. This will create hard holes in your mesh. I've used Greater Than math node to harden texture.

  There is downside to this method. You can't add thickness to the mesh.
  If you add Solidify modifier, the edges will be empty. You can try to
  work around this with Volume texture but it could be an overkill.


Objects origin is not moving in edit mode

Pivot Point and Object Origin are different things.  The Object Origin isn't meant to move in edit mode.  The Pivot point depends on the Transform Pivot Point setting.  Take a look at the top bar in the 3D window:
The second drop down sets the pivot point:
You haven't screwed up any settings.  You just have the Pivot Point set to "median point". Because you have selected a cube, the median point happens to be the center of the cube.
If you want to pivot along the object origin, change the drop down to "Individual origins".
To move the origin, in object mode, Right Click and select "Set Origin" from the popup menu


Fire is bleeding/rendered in front of all objects in Eevee

This might be a little late but I figured it out. I had the same problem so after an hour of playing around with settings I figured out it's a setting under the volumetrics tab in the Scene options. Increase the start value until it doesn't go through your object.


Blender texture painting appearing on the backside

This happens if your normals are flipped so they are pointing inside the figure instead of outside.  Select your figure and switch to Edit Mode.  Select the whole mesh ("A"), and hit "Shift N" to recalculate normals (or select Mesh -> Normals -> Recalculate Outside from the menu).


Simply turn off proportional editing. It's not the armature that is controlling the mesh, but the fact that when you move an object with proportionale editing turned on, every other object nearby will be moved.


Binding the vertices of one object to the vertices of another object?

You could use an armature. A simple rig with two bones is all you need. The left bone will move the left side of the red object and the left outer object while the right bone does the opposite. You could either use weight painting or manually create the vertex groups in the centre object, with the side objects you can parent them to a bone instead of using an armature modifier.


Animation with no smoothing between keyframes

The default interpolation
 between keyframes is bézier, which will make smooth motions that start from 0, accelerate and decelerate before stopping or changing direction.

Interpolation can be changed in the curve editor (or the dopesheet editor) to be constant, meaning that there will be no in-between transformation between keyframes: Elements will remain unchanged until the next keyframe.

To change interpolation, select the keyframes, press the T key
and select constant.

To change interpolation permanently, open the system preferences (Ctrl+Alt+U), and in the editing section set the interpolation you want to use.


It's simple. Just use an Image Texture (your HDRI) for the object's material and connect it through an emission Shader so it emits light instead of being prone to shadows:

From inside the sphere, you can see the HDRI as you would as if it was connected through a World Shader:


Weight painting - Suddenly unable to remove paint

So I'd emptied my vertex groups after making a mess of painting and had Auto Normalize selected in Tool Options when I started over. This seems to have prevented me from removing paint. I'm guessing all groups have to contain some weight before Auto Normalize can be employed?


well, after seeing that both meshes are the same u should really only use the first one using an array modifier.

The array modifier also features a merge function
check the tickbox and the seam should disappear


Volumetric Lighting not showing very well

In order to have volumetrics work with a sun lamp you need to create a box around the scene and have it use volume scatter.

Volumetric lighting will not work with a sun lamp and volume scatter used in the world settings (read: Volume Scatter in World makes the sky turn black).

If you are using a window, then the default glass material will not allow for direct light to go thorough. You need to modify the glass material with a node setup like this:

(read: How can I make a more realistic glass shader? and How to illuminate the darkness inside glass objects in Cycles?)


Using PROPORTIONAL EDITING (with Linear Falloff type)
Add a plane , scale it along Z axis and divide it with many edge loops (Ctrl+R). Select the top edge and snap the cursor to it. Enable the proportional editing, set the falloff type to Linear. Now increase the influence circle with the Mouse Scroll and rotate (R) until you get the desired segments size.

Using SIMPLE DEFORM (BEND) and ARRAY modifiers
Add a plane and subdivide it as above. Go to Object Mode and add a Simple Deform Modifier. Increase the Deform Angle to 360 degrees. Then add an Array Modifier, increase the Count number and set the Z relative offset to 1.000. You may add another Array to duplicate the segments along the X axis.

Apply modifiers when done. Finally remove doubles.


While this isn't a direct solution to the issue of collison, something else that works is placing a slightly smaller collision box within my box above and setting the material to transparent. The dragon flies slightly go through that inner collision object but prevent anything from showing on the outside.


my mesh got spikes and idk how to fix it

I'm quite new to Blender as well, but my first thought is that you need to recalculate your faces. Have you tried that?


Blender fluid simulation "with drag" (simulating a pump)

Perhaps you could use a chain of control objects which follow a path in the center of the pipe. I have attached my blender file that generates this animation.

I have a pipe (which would be your pump) set to Obstacle under Fluids and it has Shell initialization.

I have a domain surrounding the simulation and some fluid at the bottom to be sucked up.

The most important thing is the short cylinder which is a Control fluid object. Play with "Attraction" and "Velocity" to get suction. It follows a path I made in the center of the pipe. Perhaps you could use an array of these controls to have a constant suction/drag on the water. Or you could cheat and have an "inflow" at the end of the out pipe and an "outflow" at the opening. Then if your pipe is not transparent, it will look like water is going in and coming out. I can make an example of this if you want.


Go to Edit - Preferences... Add-ons tab and search for LoopTools. Enable the add-on.
Select both objects and press CTRL  + J to join them.
hold ALT and click right to the right edge of the left plane. THen hold SHIFT + ALT and click left to the left edge of the right plane.
Right click and choose LoopTools -> Bridge

Press CTRL + R, hover over the bridge and use your mouse wheel to get  a uniform density of loops across whole mesh.


Compositing Workflow/How to compose a render after restarting Blender?

I think what you are missing is the FileOutput Node.

here is a basic Setup for your 3 Layer.
check the docs for renderlayer in Blender and you are good to go.

you can do a lot more then saving files with the compositing context, so have look and do some experimenting.


The easiest way would be to use Drivers.

Select your character, and, in the Properties panel, switch to the Particle System tab; At the top, there's a Hair Length field - press RMB (Right Click) and select Add Driver.

Now, switch to the Graph Editor (you could switch a Window to this, but it's easier, from the Default Screen Layout, to double press Ctrl + Left Arrow or to go to the Header and click besides "Default" and choose Animation), set type to Drivers, press N and select your driver from the left side. Select your objects name on the Obj field, then set the type to either X, Y or Z scale. set the Expression to be scale * var, where scale is the Hair Length and var is the variable you just setup.

Now, when you scale your object up, the hair will scale properly.


This is a post effect as it occurs inside the lens. I have used a mask to create the ring, then added some noise from a cloud texture, this is distorted radially to make streaks (that you could animate). Then this is coloured with a fringe using the Projector node.

Make a single mask with 2 circle shapes on their own layers:

Layer one use Add function

Layer two use a Merge Subtract function

Make sure both layers are active, tick the eye buttons

Use this mask shape with a noise texture that is distorted with a radial blend texture using a UV map node:

Here's the blend file I created for this effect:

UPDATE:
Here's the flare turned up to 11!
I duplicated the projector node for more color and added a ramp to the radial blend so that I could better control the stretch of the cloud texture.


For me the answer was to put the entire project into a folder with the proper structure and set this as the scripts path in preferences.

This is the folder structure I used, and I was able to run the example scripts from the book:


How to extrude a bone using Blender's Python API?

It turns out it is not hard to do this using Python. I did it using the following instead:

newBoneLocation = (1, 1.5, 1.2)

bpy.ops.armature.extrude_move(ARMATURE_OT_extrude={"forked":False},
TRANSFORM_OT_translate={"value":newBoneLocation,
"constraint_axis":(False, False, False),
"constraint_orientation":'GLOBAL',
"mirror":False,
"proportional":'DISABLED',
"proportional_edit_falloff":'SMOOTH',
"proportional_size":1,
"snap":False,
"snap_target":'CLOSEST',
"snap_point":(0, 0, 0),
"snap_align":False,
"snap_normal":(0, 0, 0),
"gpencil_strokes":False,
"texture_space":False,
"remove_on_cancel":False,
"release_confirm":False,
"use_accurate":False}`


I'm not sure I understand your question 100% correctly. So forgive me if I answer not what've asked.

Straight to "is there a way to duplicate the action...?"
⇧ ShiftR is your friend when you've just done something good to a face (edge, vert, multiple selection...) and would like to do the same to others. Just select the next part and hit the shortcut. Big time-saver indeed.

And as the topic suggests let me give you my advice on actual chocolate bar design (who can stand tempted with chocolate :-)).

As suggested by m.ardito you could go with arrays too.
But my favourite for this kind of models is cube-modelling + edge-loops + inset faces. Very quick, in fact.
Don't forget to choose Individual for Inset faces and play with Depth (hold Ctrl). Then adjust by scaling on separate axes with Individual origins as pivots.

With this I really wanted to demonstrate that you don't necessarily need to repeat some action if your model is by-nature very homogenous.


So the thing that is you should always use context that passed by the operator instead of bpy.context. Unless you want to override context with the one you need in rare case.

And Blender 2.80 does change the object.select to its private(?) value, one should consider use object.select_set(bool) and object.select_get() for select value manipulation.

So assume that your function got a context passed in:
ListObjects = [ o for o in context.scene.objects if o.select_get()]
will give you a more reliable context.


Running a script via module vs script mode in the BGE

Why does running a script via Module mode require importing bge?

Because the import statement is the proper way of writing Python code.

The auto-import within script mode is a dirty shortcut. It is still there for backward compatibility. But it is no good design.

Pro

You always need it to access the the BGE context anyway.
(In module mode you do not really need it as you can get access via function arguments.)
Bge is not a real Python module. It is a wrapper around the BGE native code.

Contra

It violates the Python convention to show where objects are coming from (defined by the code or imported from other modules)
It hides the fact that this module is imported at all. So a reader will never see an explicit assignment to bge.
The bge module should behave like regular Python modules, so it should be imported as any other Python module too.

I strongly suggest to add the import statement in script mode too and ignore the auto-import.

I hope it helps


How to scale/repeat texture on object? (blender internal)

In the properties panel, textures tab, go to the mapping section and modify the size of the texture.

For fast editing of the 3 values simultaneously, left click on the x fileld, drag to z field without releasing, then - still without releasing - drag left to decrease and right to increase the value.

A bigger value means smaller texture.


Superzoom effect in Video Sequence Editor

In the absence of answers after 18 hours and meagre 12 views, I’ll start building my own answer – block by block.

How to locate target spot on a strip at a very high zoom?
Reverse your workflow by centering the strip on target spot first, but begin at a manageable Scale. Then multiply Scale and Position (or Position shift value if initial Position wasn’t zero) by exactly the same factor. Fine-tune Position if you can. If you can’t, undo last multiplication and redo it using a smaller factor. Repeat until you reach the desired Scale.

a) How to disable cropping of the output to the Render Area in the preview window?
— (Impossible?)
b) How to pan a strip in the preview area?
(Impossible?) Impossible!

Why does exponential interpolation mode fail during superzoom?
Buggy Blender? Workaround: approximate desired interpolation curves manually using multiple linear interpolation segments.
How to align interpolation curves of different strips?
No relevant functionality in Blender. Workaround: approximate desired interpolation curves manually using multiple linear interpolation segments.

Edit: 8 November 2016

Leave it. I’ll sooner make it manually in C (programming language) than in Blender + StackExchange. Literally.

Interesting links

“Rescaling in the VSE yields low resloution, blurry images”
“How do I prevent VSE strips using Image Offset from being cropped before the transform effect can shrink them onto the screen?”
“VSE. I need to rotate image with arbitrary center pivot point that is not in the center of the image”
“§11. Blender Video Editing (Importing Images [Overlay/Resize/Rotate])” (YouTube)


Ohh, found out.
Under the "Duplication"->"Frame" option in my object settings, I had "End" set to 100. Size it up and more objects were created.

EDIT:
Apparently: If you set "End" to let's say 800, then 800 objects will be created no matter how many frames you've set up under "Path animation". So if under "Path animation"(in your curve settings) you've set "frames" to 600, Blender will still create 800 objects. The 200 extra objects will be put in the same place as the 600-th - in other words, at the last position.


Full examples at the bottom! (There's one for the "restarting" workaround and one for the "suspending" workaround)

Lets start with the second part:

'LEFTMOUSE' is correct, as that is your key. To check wether or not it is pressed, test for event.value.

if event.type == 'LEFTMOUSE':    # the KEY is left mouse
    if event.value == 'PRESS':   # the ACTION is pressed
        pass
    if event.value == 'RELEASE': # the ACTION is released
        bpy.context.object.data.ortho_scale = self.user_input

Now to the real meat: your first problem!

About the Problem:

This is a known bug. Sadly it's not dokumented.

The popup does a modal execution inside itself. The problem arises from the popup and the normal modal execution fighting for the modal execution (on the same running instance). After one of them finishes, it closes the operator on the other one. The second one therefore will take a nosedive.

This problem was pointed out by domlysz on blenderartists. They fixed it in 2016 (see task T48196) but it somehow reappeared later on.

Solution:

The correct solution would be calling window_manager.modal_handler_remove and temporarily remove the operator. OR to repatch blender. However modal_handler_remove doesn't exist, and patching ... someday.

So, lets get to the work-arounds: First consider if you need a set number of Interface-Popups or an undefined number of them. If e.g. you want one thing, have a popup, then do another thing and be done, you might want to use a bpy.types.Macro.
Macros are an undocumented feature of blender. They are basically operators, that allow you to chain other operators in a certain order of execution. If you do extrude-and-move and press escape, the (instantanious) extrusion is still there, just the movement was cancelled. You can read more at this question. Your workflow would be:

Create a (modal) startup operator
Create a popup operator
...
Create a operator for final stuff
Create a macro to run the operators above

A different workaround would be, to stop the modal operator and use a second operator for the popup: Finish the modal operator and start the popup-operator. The popups execute in turn restarts the modal operator.

Step-by-step:

Do some modal interaction.
Event "show some popup" happens:

Start popup, push props to popup and close modal.
Do some interface stuff, changing props.
Start modal, push props to modal, close popup.

Continue with your modal actions.

Notes:

While domlysz called the popup-operator inside the __del__ function, it seems to work fine from within modal. Just be sure to return {'FINISHED'} or {'CANCELLED'} straight after calling the popup.
If they exist, a modal operator will run __init__ before invoke and __del__ after finishing/cancelling.
Cancelling either the popup, or the modal operator will both stop your interaction.

Here's an enhanced example. The mixin simplifys transfering the properties (usefull for larger sets of properties). The double-asterisk unrolls a dict into variable assignements.:

import bpy

class ModalPopup_Props: # mixin to use in the modal and the popup
    myBool   = bpy.props.BoolProperty()
    myInt    = bpy.props.IntProperty()
    myString = bpy.props.StringProperty()
    __ModalPopupProps = ["myBool", "myInt", "myString"]
    def _props_as_dict(self):
        return {prop: getattr(self, prop) for prop in self.__ModalPopupProps}

class ModalPopup_Popup(bpy.types.Operator, ModalPopup_Props):
    """This will be callable from the search"""
    bl_idname = "test.popup"
    bl_label = "ModalPopup Popup"

    def invoke(self, context, event):
        return context.window_manager.invoke_props_dialog(self)

    def execute(self, context):
        bpy.ops.test.modal('INVOKE_DEFAULT', **self._props_as_dict())
        return {'FINISHED'}

class ModalPopup_Modal(bpy.types.Operator, ModalPopup_Props):
    bl_idname = "test.modal"
    bl_label = "ModalPopup Modal"
    bl_options = {'INTERNAL'} # Internal removes this from the searchbar

    def execute(self, context):
        context.window_manager.modal_handler_add(self)
        return {'RUNNING_MODAL'}

    def modal(self, context, event):
        # some dummy event. let's print the props.
        if event.type == 'LEFTMOUSE':
            if event.value == 'RELEASE':
                print(self._props_as_dict())

        # open the popup
        if event.type == 'SPACE':
            bpy.ops.test.popup('INVOKE_DEFAULT', **self._props_as_dict())
            return {'CANCELLED'} # or return {'FINISHED'}

        # cancel modal execution
        if event.type in {'ESC'}:
            return {'CANCELLED'}

        return {'PASS_THROUGH'} # (or use {'RUNNING_MODAL'} to block stuff)

def register():
    bpy.utils.register_class(ModalPopup_Popup)
    bpy.utils.register_class(ModalPopup_Modal)

def unregister():
    bpy.utils.unregister_class(ModalPopup_Modal)
    bpy.utils.unregister_class(ModalPopup_Popup)

if __name__ == "__main__":
    register()

Finally, one might think of suspending and updating the original modal operator.
Indeed this is possible using WinMan (the window-manager) as storage. However not by storing the operator in WinMan (blender would crash). Instead we use WinMan as a dead-drop for our passed values. The modal operator listens in, clears the dead-drop and resumes work. Note that if we fail to provide data, we'll be stuck in suspension, and depending on our type of suspension, blender will freeze. So in the popup we need cancel to provide an empty dict. The modal operator will update (nothing) from the empty dict, clear out the dead-drop and resume its work. Note that in this case, cancelling the popup will not cancel the modal operator (you might have the same buttons for it though, doing it in series). Try that by escaping the popup with rightklick vs escape.

Full example:

import bpy

class ModalPopup_Props: # mixin to use in the modal and the popup
    myBool   = bpy.props.BoolProperty()
    myInt    = bpy.props.IntProperty()
    myString = bpy.props.StringProperty()
    __ModalPopupProps = ["myBool", "myInt", "myString"]
    def _props_as_dict(self):
        return {prop: getattr(self, prop) for prop in self.__ModalPopupProps}

class ModalPopup_Popup(bpy.types.Operator, ModalPopup_Props):
    """This will be callable from the search"""
    bl_idname = "test.popup"
    bl_label = "ModalPopup Popup"

    def invoke(self, context, event):
        return context.window_manager.invoke_props_dialog(self)

    # this is run on cancellation.
    def cancel(self, context):
        if 'ModalPopup' in context.window_manager: # there's a running instance
            # we MUST(!!) provide data to the dead-drop or we'll be stuck forever
            #    so we just give it an empty dict. The modal operator resumes
            context.window_manager['ModalPopup'] = {}

    def execute(self, context): # start the modal op
        if 'ModalPopup' in context.window_manager: # lets see if there's a running instance
            # we cannot get the running instance directly, so we'll dead-drop the data
            context.window_manager['ModalPopup'] = self._props_as_dict()
        else: # no running instance? start one.
            bpy.ops.test.modal('INVOKE_DEFAULT', **self._props_as_dict())
        return {'FINISHED'}

class ModalPopup_Modal(bpy.types.Operator, ModalPopup_Props):
    bl_idname = "test.modal"
    bl_label = "ModalPopup Modal"
    bl_options = {'INTERNAL'} # Internal removes this from the searchbar

    def execute(self, context):
        print("Modal operator has been started")
        context.window_manager.modal_handler_add(self)
        return {'RUNNING_MODAL'}

    def modal(self, context, event):
        # Listening to the dead-drop. This MUST stay on top AND return
        # {'RUNNING_MODAL'} or {'PASS_THROUGH'} to "suspend" the operator.
        if 'ModalPopup' in context.window_manager:
            # get the dead-drop from our popup
            if context.window_manager['ModalPopup'] != "SUSPENDED":
                print("resuming Modal")
                for k,v in context.window_manager['ModalPopup'].items():
                    setattr(self, k, v) # read in our data
                del context.window_manager['ModalPopup'] # clear off the dead-drop
            else:
                print("Passing by, saying hi.")
            return {'RUNNING_MODAL'}

        # some dummy event. let's print the props.
        if event.type == 'LEFTMOUSE':
            if event.value == 'RELEASE':
                print(self._props_as_dict())

        # open the popup
        if event.type == 'SPACE':
            print("suspending Modal")
            context.window_manager['ModalPopup'] = "SUSPENDED" # setup deaddrop
            bpy.ops.test.popup('INVOKE_DEFAULT', **self._props_as_dict())
            return {'RUNNING_MODAL'}# otherwise space would call the searchmenue too.

        # cancel modal execution
        if event.type in {'ESC'}:
            return {'CANCELLED'}

        return {'PASS_THROUGH'} # (or use {'RUNNING_MODAL'} to block stuff)

def register():
    bpy.utils.register_class(ModalPopup_Popup)
    bpy.utils.register_class(ModalPopup_Modal)

def unregister():
    bpy.utils.unregister_class(ModalPopup_Modal)
    bpy.utils.unregister_class(ModalPopup_Popup)

if __name__ == "__main__":
    register()


I think rig effects to vertices try to add loopcuts bending areas and reupload to mixamo again probably it will work


Tp make the sharp edges disappear select your object and use smooth shading.

On top of that you can always add add a Subdivision Surface Modifier


Use texture + color ramp to set density vertex group for particle system

Vertex groups are one method of controlling where particles generate, but there are also particle textures.
Create a texture from your color ramp (one way is to connect the color ramp node direct to material output, then bake). This should be an image that is full black where you don't want particles and full white where you do.
Then in the Textures panel of your particle system menu, press the + to add a texture. In the settings for the texture, under the Influence tab, check the box for Density.


Can I adjust bones after skinning and weight painting?

You can edit the armature as much as you like as long as the bone names remain the same.

You see, weight data is stored in the object in the form of Vertex Groups. Vertex Groups are a multi-purpose way of defining weighted areas in mesh that's used for all kind of things, skin weighting being one. The armature modifier just takes the incoming bone names and matches them with the names of the Vertex Groups. It's super flexible.

It's possible to even delete the rigify generated rig, do the adjustments in the metarig and generate a new one, and the armature modifier is like nothing happened.

The trick is to add the armature modifier without adjusting the pre-existing weights. Through parenting, you just have to choose "Armature Deform"

Or by setting the armature object in the armature modifier manually.

Both will leave your skin weight data as it was. No need to redo.

If the bone names have changed, for whatever reason, you only need to rename the corresponding Vertex Group to match the new one.


Yes it is.
In every IK chain you can select a bone and set some constraints in the IK tab of the bone section of the properties panel. The XYZ constraints are referred to the bone axis, not to the global orientation.


How to Offset Geometry of a Text Converted to Mesh

If I understand correctly your question, first simplify your letters topology with X > Limited Dissolve.
For some letters a simple inset (i) will work (and then invert the selection with Ctrli and delete the outer edges):

For some other letters it won't work and you'll have to extrude them, Shrink/Fatten with AltS, and delete the extrusion:


Save objects in Object ID Properties (Blender 2.79)

import bpy
scene = bpy.context.scene

class MyPropertyGroup(bpy.types.PropertyGroup):
    obj_pointer = bpy.props.PointerProperty(name="Object", type=bpy.types.Object)
    custom_2 = bpy.props.IntProperty(name="My Int")

bpy.utils.register_class(MyPropertyGroup)

bpy.types.Scene.id_objects = bpy.props.PointerProperty(type=MyPropertyGroup)

scene.id_objects.obj_pointer = bpy.data.objects[0]
print(scene.id_objects.obj_pointer.name)


Look up Blender Texture Atlas.

also,
You can create a new image, in the image editor, large enough to hold the resolution you want.
Then, create a new texture layer, to use the new image, and bake the original textures to the new Texture. You will just have to move the UV maps around so they don't overlap during baking.

Info on that here and here.


Removing animation keyframes outside of a specified range

I got it working thanks to batFINGER's comment.
My final code looked like this:
import numpy as np
def action_slice(action, start_frame, end_frame, shift=True):
    copy = bpy.data.actions.new(action.name)
    copy.id_root = action.id_root

    for fcurve in action.fcurves:
        kfs = np.empty(len(fcurve.keyframe_points) << 1)
        fcurve.keyframe_points.foreach_get("co", kfs)
        kfs = kfs.reshape((-1, 2))
        _fc = copy.fcurves.new(
                fcurve.data_path,
                index = fcurve.array_index
                )
        _fc.keyframe_points.add(0)
        _kfs = kfs[
                np.logical_and(
                    kfs[:,0] >= start_frame,
                    kfs[:,0] <= end_frame
                    )
                ]
        if shift:
            _kfs[:,0] -= start_frame
        _fc.keyframe_points.add(_kfs.shape[0])
        _fc.keyframe_points.foreach_set("co", _kfs.ravel())
    return copy

def object_do_slice(string, endframe):
    ob = bpy.data.objects.get(string)#context.object
    ad = ob.animation_data
    action = ad.action if ad else None
    if action:
        ad.action = action_slice(action, 1, endframe, shift=True)

object_do_slice("Root",framelength+1)


Seems its not interested by anyone, but i'had solved the problem.

Here is the video https://youtu.be/S4yfnxffJmA

And here is preview

Actually i've compressed all the 3 channels to one (to 6x6x7 palette), but it was not looking good. Had to refactor many things so there are 4 + 4 channels, (2 for displacement + 2 are free for future use) & 4 for tint as standard RGBA.

Here is the final PS

float4 PixelShaderDisplacementFunction(VertexShaderOutput input) : COLOR0
{
    float4 color = tex2D(assembleSampler, input.UV.xy);
    float2 UV = input.Position1.xy + (color.xy * 2 - 1) / ZoomMultipliedBy64;
    float4 srcColor = tex2D(screenSampler, UV);
    return srcColor;
}

ZoomMultipliedBy64 = RenderMatrix.M44  * 64f, to neutralize effect of zooming


Why does it happen?

There is a very simple explanation to this: to increase performance of various things (including video playback), Blender has a fixed-size cache in your RAM. Using this Blender preloads frames into quicker memory for faster playback (this is what you see for the ten first seconds.). When the cache fills, Blender starts doing the following:

Read the frame from the hard drive
Decode the frame
Push it to the cache (overwriting whatever was in the way)
Read it from the cache and draw it on screen.

This is slower because:

You are limited by the speed of your hard drive.
Decoding the frame takes time
Pushing things to the cache is an extra overhead.
The processing time used up by the above is taken away from actually playing back the video.

This explains the overall sluggishness.

How does one solve it?

You can adjust the size of the cache: in User Preferences > System > Memory Cache Limit. I personally advise using as much as you can manage. It also reduces the amount of crashes due to memory leaks (this is especially true on Windows). A bigger cache means a faster Blender in general.

Also, you can make Blender prefetch frames in the Clip Editor and Sequencer. Do this by going to User Preferences > System > Sequencer / Clip Editor. I hope this helps.

Also have a look at:

How to make VSE render faster?
http://blenderartists.org/forum/showthread.php?349186-Does-Blender-has-a-cache-size-limit-(per-frame)

[Edit]

If the codec is slow to decode, having frames cached is even more important.


Select your domain object, go to the physics->Fluid tab, and change the speed value to something lower than 1, for example to 0.5 if you want the simulation to have half the normal speed.


If you print out the content of me in the console, you can see that it does not contain the cylinder's mesh data:

>>> me
{'FINISHED'}

The bpy.ops.mesh.primitive_cylinder_add operator, like most operators in Blender, returns its exit status (in our case {'FINISHED'} - signalling success) rather then the result of whatever it did.

If you want to access the vertices, you can do this through bpy.context.object.data.vertices, since after you add a cylinder primitive, it becomes the active object (context.object):

import bpy
from math import *

bpy.ops.mesh.primitive_cylinder_add(radius = 0.5, depth = 1)
me = bpy.context.object.data

for v in me.vertices:
    v.co[2] =v.co[2]+0.5

A few other things worth noting:

The vertex collection in the mesh object's data is called vertices (For instance: context.object.data.vertices) not verts. The bmesh module does call the vertex collection verts, which is probably why this confused you.
It's considered bad practice to import everything from a module, unless you're actually going to use everything you imported (from math import *). You should only import whatever function you intend to use. For instance:

from math import degrees, radians

Small tip regarding debugging in blender (and in general):
The error message you got gave you a nice lead for debugging. It says that whatever it is you're trying to use .verts with doesn't really have any attribute called 'verts'. The next logical thing is to check what the heck is inside the me variable by printing it, to see why it has no verts. This would have showed that me is indeed a set, not a mesh data object, which whould have indicated that the bpy.ops.mesh.primitive_cylinder_add operator returns an exit status, and not the cylinder's data.
[EDIT] And another late one. To get a shorter and more readable version of your scaling action, you can replace this:

v.co[2] =v.co[2]+0.5

With this:

v.co.z += 0.5


Is it possible to iterate through particles in python?

Yes it is to some extent.

ps = obj.particle_systems[particle_sys]
particles = ps.particles

# on large objects list comprehension seems to be slower than index
# and . dotted access is also a slowing factor
for i in range(len(particles)):
    # alive_state
    # angular_velocity
    # birth_time
    # die_time
    # hair_keys
    # is_exist
    # is_visible
    # lifetime
    pt = particles[i]
    if pt.is_exist and pt.alive_state == 'ALIVE':
        # do something... add_loc(pt.location[:])
        ...
    # prev_angular_velocity
    # prev_location
    # prev_rotation
    # prev_velocity
    # rotation
    # size
    # velocity

pt.location would give the coordinate. The Particles API seems to be slightly under-developed, but perhaps this info will help you.


Can I use BSDF for the emission pattern of a lamp or light source?

Spot into textured transparent shader will work. like this

Shader


I know it´s quite a while since this Thread was active, but I had the same problem and no of all the solutions (and I searched a lot of other threads..) solved my problem.
My Problem was.. the Render Settings!

Increase your "Light Path"-Settings, and it works.
I hope I could help somebody, too.


How to model a fluid like object without particle system or fluid simulation

You could try using a displacement modifier with a texture.

I tried using a clouds texture and a stucci texture, which came up with a decent result. Didn't look to much like the image, but if you have a better base mesh, and just keep messing around with adding more textures, and adjusting size and strength, you should be able to come up with a good answer.

p.s. you need to add another displacement modifier for each new texture you add.


Shapekeys aren't saving to the animation timeline?

You can add keyframes by:

Press RMB on Value box and select Insert Keyframe.
Hover on Value box and press I

When keyframes created, you can edit them in Dope sheet or Graph editor like usual keyframes.

Also you can create a driver for shape keys.


How do you try different random seeds for noise texture node?

This doesn't really change the seed, but you can get a different noise pattern by translating the whole texture by a significant amount.

The Suzanne on the left uses a noise texture with default settings and mapping coordinates.  The Suzanne on the right uses the same noise texture, but uses the below nodes to shift the texture coordinates to get a different noise pattern.

For the sake of space i am using my homemade translate node but you could just as well use a mapping node as well.


I'm having an issue merging after I joined the objects

I do not have the blend-file so i can only tell you what could be done based on the uploaded image.
A vertex was probably too close to the mirror-axis. Press Ctrl + Z until they are not merged anymore.

First you should disable the mesh view for the subdivision surface modifier (the last option on the right in the modifier's header bar) so you can see where the vertices actually are. You also might want to turn off clipping and merging from the mirror modifier before you join one object to another. This will keep Blemder from joining vertices.

Then you should select two adjacent vertices from the leg and two from the foot. Then you press "F" to fill them. You might will have to change the flow of the edges or add loop cuts if the loop of the foot does not have the same amount of vertices than the leg.

If both loops have the same amount of vertices you can simply select both loops and hit space and type in "bridge edge loops". This function does connect them automatically so you dont have to connect them by pressing "F" for each face that you want.


Can I copy UV map to many objects with the same and/or symmetrical topology?

I used the suggestion given by gandalf3 and made it all work for my case. Here is the procedure:

I have 14 shoes objects with identical broken UV, 7 of them are mirrored (using CtrlM mesh mirroring).
I fix UV on one of the shoes
I go to its mirrored version of the fixed shoe, flip normals and then use CtrlL -> Transfer UV layouts. (If I do not flip normals transfer does not work right and resulting texture is a mess).
I flip normals on the mirrored object again. At this point one size of the shoes has right texture with correct UV map for both mirrored and not mirrored mesh.
I use mirrored mesh to transfer to all 7 mirrored sizes  by selecting all mirrored objects and selecting last the mirrored object with corrected UV and using CtrlL -> Transfer UV layouts.
Repeat the same procedure for not mirrored 7 sizes.


Geometry of one object changes (doesn't update) when I render the image

Nevermind... I must have duplicated an object in a few hours ago and it was invisible in viewport, but visible in render. I deleted it and it's ok now.


Remove Target Object reference from constraint with python

Simply set the the target property to None to clear the target field.

So in your example it would be:

...constraints["MocapHook"].target = None


How can I delete keyframes and animation data for all selected objects?

One fell swoop approach.
copying the script from Delete animation of object
Uses Object.animation_data_clear() to remove all animation data from all selected objects.
import bpy

context = bpy.context
for ob in context.selected_objects:
    ob.animation_data_clear()

this will orphan any action not associated with other objects, and they will be dealt with on file save / reload.
Otherwise
orphans = [a for a in bpy.data.actions if not a.users]
while orphans:
    bpy.data.actions.remove(orphans.pop())


What does 'Autorun disabled' statement mean?

Blender comes bundled with python. Malicious scripts written in python could potentially damage your computer. As a security measure the automatic running of python scripts has been disabled since version 2.6.
What this most likely means is that there is a piece of python code that is controlling the driver.
You can allow blender to auto run scripts by changing your user preferences. To do this press Ctrl + Alt + U, then head over to File and enable Auto Run Python Scripts. Although it is unlikely that someone will distribute a malicious blend file you should still make sure where you download .blend file from

More information on Scripting & Security at the official documentation.


Cut a circular hole in a curved surface (using snap to face)

You want the "use_snap_project" feature:

If you turn that on, while snapping is enabled you'll get all selected components projecting onto other objects.


extrude region (vertex normals) direction problem

If  your Pivot is set to 'Individual Origins', you can indeed get AltE > 'Faces Along Normals' in 2.8, or AltE > 'Region Along Vertex Normals' in 2.79, to fail as shown.

With the Pivot set to any other value, it works as expected.

This does seem like, at least, inconsistent behavior.. I haven't looked to see whether it's already been mentioned to developers.


How to export fills on Freestyle SVG export?

The SVG exporter only supports exporting the freestyle lines at the moment.
If you want to have the fill in your SVG file as well, you can use the trace bitmap function in inkscape (or a similar action in other vector graphics programs) on your rendered image.

This is a little bit beyond strict blender topics, but I don't think there's a way to do this without external programs.

http://i.giphy.com/l41lKvw47mA396Ei4.gif


Blender import ply file but only show orange color

I think the orange color is showing because you selected that thing. so deselect everything(press A in 2.79 and alt+A in 2.80).


How to have a continuous ColorRamp in a broken spline (spline with removed segments)

The simplest solution is, don't delete spline segments.  If you want part of your spline to "not exist", then use its UV to make these parts hidden, or use a mesh object with a curve modifier to create your spline:

Once you delete spline segments, Blender no longer has an understanding that the newly separated splines have any particular relationship to each other, and cannot draw a colorramp along their length.


Bake AO map from multires in Blender.2.82

I'd suggest another approach.

In the Shader editor, using Cycles, add Emission shader, add Input -> Ambient Occlusion node and connect its AO output to Emission color input.
With viewport shading set to render tweak AO node's settings as you like.
In the Bake tab in Render Properties uncheck "Bake from Multires" checkbox and choose Emit as the Bake Type.

After that you can bake the result in a common way: create an image in Image Editor, choose it in Image texture in Shader editor, make sure the object is UV-unwrapped, active, and the Image Texture in the Shader editor is selected and press bake. As an emission shader is the only shader used, it bakes extremely fast.