is https://wiki.blender.org/uploads/1/14/Keyboardlayout_250.png no good printed in greyscale / low quality?

Alternatively tufts has a nicely compiled (but incomplete) list of shortcuts per area:   http://ocw.tufts.edu/data/71/1717950.pdf
The tufts shortcuts might be handier as it doesn't try to cram all info onto a few keys which change depending on mode anyway. Unfortunately it doesn't list some of the more useful key combos ( vertex-slide Shift + V)


How to re-map the shortcut to remove a node connection (cutting tool)?

That's a built-in key and has nothing to do with Node Wrangler.

Go to Keymap > Node Editor Global > Cut Links and change it to whatever you like:

To get a Houdini like key binding, set its 'map type' to 'keyboard' and its type to Y.


Animation: Having the camera view move as if someone is holding the camera and running

There are two methods you can use to achieve this effect, one of them will produce better results, but the other is easier to set up.

Match move, with actual footage:

Also know as Camera Tracking. This technique is a favorite of  Stu Maschwitz, ex-ILM employee and co-founder of the now closed VFX company, the Orphanage. This will produce the most realistic results, but will also be harder work to complete.

Steps:

Go outside, or into a large room.
Place allot of high contrast objects on the ground(a mix of foreground and background markers will yield more precision).
Take a video camera, and shoot video like you're the camera man in your virtual scene
Match move it
Position your camera in your hallway.

This approach will result in very realistic looking results, since it is "Camera Mocap". The down side is, it is a lot of work. As with most visual effects tasks, the more work you put into, the better your scene will look.

Add random noise to your camera's movement:

This is one of the easiest ways to simulate a shaky camera in Blender. It won't produce as realistic results as the above method, but takes way less work to set up.

Steps

Add an Empty.
Parent your Camera to it.
Set a Location and Rotation key frame on the empty.
Open the Graph Editor and hit N.
Add a Noise modifier to the rotation and location of the Camera.
Parent the empty to another empty.
Use the last empty to control the movement of the Camera.

This can work pretty well, with some tweaking. I would recommend first removing the noise effect from certain axis, if that failed.

  Should I use a path?

I wouldn't bother, just key frame it.


I Managed to accomplish this through trial and error. First going from the second bone (first child after Node) I added two Constraint's.

First add a "Damped track" and target the same armature as the bone, and target the next bone in the armature, Bone_2 targets Bone_3, 2->3, 3->4.

Second add a "Limit rotation" constraint keep everything default and Limit X, Y, and Z.

On the last, Tail Node add only 1 Constraint: A "Inverse Kinimatics" Target is Armature 2, Bone x.

After all this the first armature will fallow the second one, keeping its constraints.

EDIT: I made a small mistake the last Bone (Tail) constraint is not a Spline IK, but an Inverse Kinimatics constraint.


Unfortunately it's not possible to determine what's happening just from those screenshots, hence moonboots's comment requesting that you upload the broken file which demonstrates the strange behavior.
I've not seen a texture paint problem quite like this before. It may be caused by an unreported bug, perhaps due to some combination of your hardware and a new part of Blender's 2.80's viewport.

As it's unknown territory, the only advice available here will be either A) trying to diagnose what's really going on (i.e. asking many clarification questions); B) suggestions for working around it (eg as Craig D Jones suggests); or, C) if it's happening too consistently to ignore, you might consider submitting a bug report.

Before any of that: experimental builds of Blender are available to download, which are effectively daily updated '2.80+' with additional fixes and some newer features. You might want to try downloading the bleeding edge latest version, and see if the same problem still occurs in that.

Finally, if the problem is still happening, please consider using the Help > Report a Bug option. This option uploads operating system and graphics cards details which help pinpoint things with much less guesswork.
If you can find and describe the fewest steps to reproduce the error from a blank starting state, consistently (i.e. more than once) then that's invaluable for the devs to pinpoint it quickly if it is a new bug.
I know this doesn't help you immediately fix your problem today, but if this is something unreported, reporting it is the best way to get it resolved and then gone from the newest version.


A possible solution I found myself was to use the 'Spin" tool on the end where I wanted it to turn. Since it's not going to be seen close up, and for the asset I'm building this should suffice. Wish there was a better way to do this.


After scaling the object, determine the amount of scaling of the holes required to "undo" that scaling. For example, if the object was scaled down by a factor of 0.9, use 1 / 0.9 = 1.111 as the scale factor to adjust the holes by.

To quickly scale all of the holes switch to use the pivot center "Individual Origins" and it should scale each hole separately.

You can get the add-on presented in this answer to verify that the dimensions of the holes are indeed the same: https://blender.stackexchange.com/a/68678/28015.


Random computer luggishness using Blender

This may be a amazing solution but I would recommend uploading important files to google drive or something of that nature then resetting pc. I have had issues like this in the past with different programs and it can happen because of lots of extra stuff running that is extra stuff that you never use. I have had this happen before and resetting it, it was like insane. Hope this helped!!


How can I merge objects in Sverchok and Animation Nodes?

Yes it's possible. First we need to put all objects inside a collection.

Using Animation Nodes

In Animation nodes we can use collection info node to get all objects, then convert them into mesh list using Mesh Input node(Mesh Input node don't have vectorized input so we need loop). finally merge it using Join Mesh List node.

Using Sverchok

In sverchok we only need these 3 nodes, Our new connected object is Alpha.0000


Quixel exported textures not behaving like they should

Did you use Quixels material setup? They created a node group in which you only plug in your textures. Here's the link:
http://www.quixel.se/content/blender/QuixelShader.zip


You can edit multiple meshes in edit mode since Blender version 2.80 and the operation you are trying to perform is for a single mesh. Make sure it's a single mesh. Go into object mode and join the meshes if they are separate with Ctrl+J


Animation of Selected Object Not Show Showing in Editors

I don't see any problem with your file but I'm not playing it with the latest version.

For the moment the armature is playing the animation that you've pushed down into the NLA editor. To see or edit this action you can select the strip and press Tab, the strip will turn green and the keyframes will be displayed in the Dope Sheet.

If you want to load any other action, switch the Dope Sheet to its Action Editor mode and choose whatever action you want in the dropdown menu (now the Dope Sheet will play over the NLA, to come back to the NLA actions you'll need to close the actions you've opened in the Dope Sheet).

To switch directly from Dope Sheet to the Graph Editor you can press CtrlTab.

Also, the Only Include options may be useful sometimes to only see the keyframes of the selected bone(s) but don't forget to disable it if necessary:


Subsurf modifier creating mesh irregularities

first steps are always: Remove Doubles, Recalc Normals. Then look around the mesh in Object mode without modifiers on to see if you have any double edges (they will show up as wires even in Object mode).

But here another problem is you have a whopping non-planar Ngon, a polygon with more than 4 verts, for the side. The ngon isn't flat, if you look carefully it tapers away into the back-rest (visible on the bottom left view).

Ngons as best avoided with subsurf, and especially avoid using them on areas that are non-planar. Why avoid them? Because you have no control over the underlying triangles, the ngon has abstracted away the real geometry.

Under the hood the real geometry of that ngon might look something like  this, and that is a problem for subsurf.

If you don't quite know what "planar" is, then imagine a sheet of paper, placed on a table. it is perfectly flat. now if you make one fold in it, and try to press it back into place - you know the fold will stay visible for a very long time, maybe forever. The sheet of paper has a discontinuity, the corner of that fold no longer lies on the same plane as the other corners. There will always be a bend. In geometry imagine something similar is happening when you join an edgeloop which isn't planar.

You need to guide your geometry at the back and maybe make an extra edge-loop. Fill this gap a different way. But exactly how depends a lot on the final shape you want.

assert some control over the underlying geometry of that side, and remove doubles, and you'll get reasonable results. adjust to taste of course.


When you unwrap, you should be selecting only the edges that you want to be separate in the UV editor as seams (it looks like you selected a whole bunch of unrelated ones).

If I was unwrapping this saw blade, I would select all the perimeter edges around the sharp blade part of the saw on both the front and back and that's it.


In Blender's built in text editor is there a way to read a built in class or function's docstrings?

When inspecting a python object in the Python Console, press ⎈ CtrlSpace to Autocomplete.

If the completion is ambigous, the console will complete the command upto a certain point and offer you the options. If you end with a period, all properties are displayed.

⎈ CtrlSpace on a not completed function (where the closing bracket or more is missing) will print a docstring if available.


You access the UV coords by looping over face loops.

import bpy
import bmesh

#retrieve mesh in object mode
if bpy.context.active_object.mode!='OBJECT'
    bpy.ops.object.mode_set(mode='OBJECT')
mesh = bpy.context.object.data
bm = bmesh.new()
bm.from_mesh(mesh)
uv_layer = bm.loops.layers.uv.active

for face in bm.faces:
    for vert in face.loops:
        # here are the UV coords
        print(vert[uv_layer].uv)

#write the mesh back if you changed the uvs
bm.to_mesh(mesh)


How to create an operator that exports location over time

If modifiers are used...

If the plane is only transformed, ie the object is only translated rotated or scaled then the object world times vertex coord will give the global location of the vertex.

ob.matrix_world * v.co for v in ob.data.vertices

If however a modifier is used, then this is a different kettle of fish, as these modifications will not show from the base mesh vertex locations.

I propose using a method similar to https://blender.stackexchange.com/a/57038/15543  Parent an empty in global space to each vertex, loop thru frames and export the empty locations. Remove the empties to clean up.

Here is an example method, prints the vertex locations of context object mesh for each 0.1 seconds elapsed from from animation start frame to end frame.  (change the print to write to CSV file to suit. The print shows the time in seconds, frame (as a float), vertex index and coordinate)

Note the use of bpy.utils.time_from_frame and time_to_frame and scene.frame_set(f, subframe=f % 1) to set the frame to match time, using just the frame or the time (it worries about all the nuances of fps for us.

import bpy
from bpy.utils import time_to_frame, time_from_frame

def export_vert_locs(context):
    scene = context.scene
    obj = context.object
    me = obj.data
    empties = []
    # add empties to verts
    for v in me.vertices:
        empty = bpy.data.objects.new("Empty", None)
        empty.parent = obj
        empty.parent_type = 'VERTEX'
        empty.parent_vertices = [v.index] * 3
        scene.objects.link(empty)
        empty.matrix_parent_inverse.identity()
        empties.append((v.index, empty))

    t = time_from_frame(scene.frame_start).total_seconds()
    end = time_from_frame(scene.frame_end).total_seconds()
    while t < end:
        f = time_to_frame(t)
        scene.frame_set(int(f), subframe=f % 1)

        for index, empty in empties:
            print("frame %3.1f" % f, "%4.2f secs" % t,  "Vert %d location: " % index, empty.matrix_world.to_translation())
        t += 0.1
    # remove the empties
    for i, empty in empties:
        scene.objects.unlink(empty)
        bpy.data.objects.remove(empty)

# test call
export_vert_locs(bpy.context)

Sample output, frame rate 24 fps, start frame 1. every 0.1 seconds is 2.4 frames.

frame 1.0 0.04 secs Vert 0 location:  <Vector (-1.0000, -1.0000, 0.0000)>
frame 1.0 0.04 secs Vert 1 location:  <Vector (1.0000, -1.0000, 0.0000)>
frame 1.0 0.04 secs Vert 2 location:  <Vector (-1.0000, 1.0000, 0.0000)>
frame 1.0 0.04 secs Vert 3 location:  <Vector (1.0000, 1.0000, 0.0000)>
frame 3.4 0.14 secs Vert 0 location:  <Vector (-0.9997, -0.9998, 5.9995)>
frame 3.4 0.14 secs Vert 1 location:  <Vector (1.0003, -0.9998, 5.9995)>
frame 3.4 0.14 secs Vert 2 location:  <Vector (-0.9997, 1.0002, 5.9995)>
frame 3.4 0.14 secs Vert 3 location:  <Vector (1.0003, 1.0002, 5.9995)>
frame 5.8 0.24 secs Vert 0 location:  <Vector (-0.9868, -0.9893, 5.9774)>
frame 5.8 0.24 secs Vert 1 location:  <Vector (1.0132, -0.9893, 5.9774)>

Alternatives to getting modified vert locations would require using ob_to_mesh() each frame or bmesh.from_object(...) to get the deformed locations.


Set it to Object mode before you begin:

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

...
I tried running your code.  It doesn't do anything over here in any mode.

import bpy
def export(filepath):
  obj = bpy.context.object
  mesh = bpy.data.objects[obj.name]
  obj.data.calc_normals_split()

  with open(filepath, 'w') as f:
    for poly in obj.data.polygons:
      for loop_index in poly.loop_indices:
        loop = poly.loop_indices[loop_index]
        vert = mesh.data.vertices[loop]

        f.write("v %.4f %.4f %.4f\n" % vert.co[:])
        f.write("c %i " % (mesh.data.vertex_colors.active.data[loop_index].color[0] * 255))
        f.write("%i " % (mesh.data.vertex_colors.active.data[loop_index].color[1] * 255))
        f.write("%i\n" % (mesh.data.vertex_colors.active.data[loop_index].color[2] * 255))
        f.write("\n")

It throws: IndexError: range object index out of range
I don't think mesh.data.vertices is pointing to the right number though.


how do I import functions from a file in the same directory as the file that is the source of the current text buffer?

You can add the text file's folder to the system path, which will enable you to import from that path.

I'd also suggest to extract the folder path via os.path.dirname.

Short example to clarify:

import sys
from os.path import dirname
textFilePath = "/home/me/somewhere/textfiles/text1"
textFileFolder = dirname( textFilePath ) # = "/home/me/somewhere/textfiles"

sys.path.append(textFileFolder)

import someFileThatExistsInTextFolder


This is because the second bevel is trying to bevel edges which shouldn't be beveled, creating too much geometry, thus creating the artifacts.

You will see that if you set the limit method in the second bevel to "Angle" and then progressively increase the angle, at some point the artifacts will disappear.
Notice how the vertices count in the lower right corner drops while you increase the angle limit. Alternatively you can set the view to wireframe (SHIFT + Z) in order to see exactly which edges are beveled.

The angle refers to the angle between the two face connected by the edge, 180° being coplanar faces, 90° being faces at a right angle and 0° being faces that intersect each other (also coplanar).

No limit Vs Angle limit = 21° :


After you render out your image, press F3 in the UV image editor for the Save Image As function. You can also go to Image -> Save As Image.

I recommend checking out this answer by gandalf3 which provides more detail as well as solutions.


to make the plane invisible apart from reflection ,uncheck all the options in Ray Visibility except Glossy

this will make the object appear only as a reflection on objects with glossy shader

render :


You can add the missing hotkeys in the Preferences Panel.

Open Edit > Preferences, then click Keymap.
Click Add New.
Expand the panel and replace none with screen.frame_offset.
Set the Delta value (keyframes): 10 or -10
Click the default hotkey A and type your hotkey Up Arrow
Select the Modifier (Shift)

Save your preferences (if Auto Save Preferences is not selected)

Thanks to Zino.G, who answered this question on BlenderArtist:
https://blenderartists.org/t/frame-jumping-in-2-8/1156440


Simulate Individual Face Extrusion Via User Input In Python

The referenced question and answer(s) didn't actually apply because I didn't want or need bmesh and a massive script just to do this. I found a 1 liner that does exactly what I wanted.

bpy.ops.mesh.extrude_faces_move(
    MESH_OT_extrude_faces_indiv={"mirror":True},
    TRANSFORM_OT_shrink_fatten={"value":-0.9,
    "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),
    "release_confirm":False})

bpy.ops.mesh.extrude_faces_move(MESH_OT_extrude_faces_indiv={"mirror":True}, TRANSFORM_OT_shrink_fatten={"value":-0.9, "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), "release_confirm":False})

TRANSFORM_OT_shrink_fatten={"value":-0.9... is where you would set the value of the extrusion (-0.9 in this case).


How to randomize scale of a node in blender?

Here is a solution using simple vector distance node and a 1D noise texture node.
This can then be used to feed a Bump or Displacement node.

The key reason why this work is the use of 1D noise texture which uses the distance from the circle center as the coordinate input value (W). 1D means it works on a line (2D is on plane and 3D in space..). The same way coordinate in 3D is driven by X Y and Z, for the 1D noise texture, that 1D coordinate is simply named W on the 1D noise texture.


If i understood the question 1st think notice is that your in Blender Game

If you want to color

Go to the Material Tab -> click on Diffuse below

Change the color as per needed

If you want to apply textures

Click the texture tab -> click New

Select below Image / movie option and below that select open and access the image.


Cycles cannot directly render particles. You can select Object in the Render particle properties panel to render each particle as a duplicated object or you need to use a different method of generating geometry from the particles. One such solution to generate trails from particles is defined in How to add trailing light effect to finger tips?


Moving this IK bone just a little causes the leg to twist up

I don't know if it will solve all your problems but I guess you need to:

Deparent the second leg controller.
Move up a bit the central limbs so that it knows how to bend the legs.

Please tell me if it's enough to fix your problem.


How do I create this arch in the middle of a cube?

You should use the Array modifier with an Object Offset:

Create a 8 vertex circle.

Only keep 1/8, create an empty at the same point as its origin.

Give your circle an Array modifier, Count > 8, deactivate Relative Offset, activate Object Offset, choose the empty as object, rotate the empty 45° on the Z axis.

Model the object.

Extrude it down, flatten the bottom with SZ0.


"scale to bounds" missing in blender 2.9?

"Scale to bounds" is from the "3DPrint" addon. Activate it in the preferences.


That kind of topology can be made with Poke Faces which will reorient faces as needed and then Tris to Quads will convert triangles to quads oriented as in video.


Automated way to make "Select interior faces" ignore select faces that are visible to the camera?

Here's the solution I came up with:

Run Blender's built in "select interior face" algorithm
Note which faces are selected
Loop over every face, and cast a ray from the "camera" position to the face.
If the ray hits (the center of) the face, we know it's visible to the camera, so don't delete it.
If the ray doesn't hit the face (hits another face) it means it's probably interior.

This is a bit confusing, so I made two images to show more detail:

Commented code is below. Please note this is taken from a large file so I might have forgot to declare some variable references. Happy to clarify if anyone has questions in comments.

import bpy
import bmesh
from mathutils import Vector

cameraOrigin = Vector( ( 0, 0, 10 ) )

ops = bpy.ops
scene = bpy.context.scene
mesh = bpy.ops.mesh

current_mesh = scene.objects[ 0 ]
current_mesh_data = current_mesh.data
scene.objects.active = current_mesh

# Blender's "select interior faces" doesn't actually select interior faces, it
# selects faces that share edges with 2 or more other faces. In my case this
# erroneously selects some faces that are visible but connect to multiple other
# faces. The solution is to select interior faces, then ignore any faces that
# the camera (positioned at 0,0,10) can see, and delete the remaining ones
# See http//blender.stackexchange.com/questions/57540/automated-way-to-make-select-interior-faces-ignore-select-faces-that-are-visib
def removeInteriorFaces( mesh_data ):

    # First do the built in selection
    mesh.select_interior_faces()

    # And store all faces inside that selection
    indices = []
    bm = bmesh.from_edit_mesh( mesh_data )
    for index, face in enumerate( bm.faces ):
        if face.select:
            indices.append( ( index, face.calc_center_median_weighted() ) )

    # Deselect everything...
    mesh.select_all()

    # Switch to object mode to do scene raycasting (doesn't work in edit mode
    # I don't think, got error "has no mesh data to be used for ray casting"
    ops.object.mode_set( mode = 'OBJECT' )
    outside = []
    for index_data in indices:
        index = index_data[ 0 ]
        center = index_data[ 1 ]
        direction = center - cameraOrigin;
        direction.normalize()

        # Cast a ray from the "camera" position to the face we think is interior
        result, location, normal, faceIndex, object, matrix = scene.ray_cast( cameraOrigin, direction )

        # If the ray actually hit the face, as in the face index from the
        # selection matches the face index from the raycast, then this face
        # *is* visible to the camera, so don't remove it!
        if faceIndex == index:
            outside.append( faceIndex )

    # Build a list of the "true" interior face indices, which is the original
    # indices from Blender's built in "select interior faces", but without the
    # faces we know the camera can see
    invisible_interior_faces = [ data[ 0 ] for data in indices if data[ 0 ] not in outside ]

    print( 'Removing ',len( invisible_interior_faces ),'invisible faces' )

    # Select the faces (in object mode this is easy, strangely)...
    if len( invisible_interior_faces ) > 0:

        for index in invisible_interior_faces:
            mesh_data.polygons[ index ].select = True

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

    # Then delete them
    if len( invisible_interior_faces ) > 0:
        mesh.delete( type = 'FACE' )

ops.object.mode_set( mode = 'EDIT' )
removeInteriorFaces( current_mesh_data )


Mirrored object is misaligned when compared to its source object

Consider using a Mirror Object. This allows you to use another object as the reference for the mirror point and axes. This way, you don't have to mess around with the origin point.

An Empty Axis works well as a Mirror Object.


The skin modifier is incorrectly applied to the skeleton

Select vertex and check Radius in Properties side panel.
Your issue looks differently, probably two vertices (or split).


Create number grid of text objects in Animation Nodes

Well it seems that I've answered my own question.

My mistake was using a source text object for the instancer. Instead, I just disabled the "Copy from source" setting and then selected "Text" from the drop down list of available types to instance.

The next challenge will be getting the numbers to count up horizontally instead.

Update!

I vastly simplified the node network from my (deleted) post yesterday, and made it able to order the numbers in anyway you want, up down left right, down up right left, etc.

There's still just the issue of not having any access to the font object material at all.


Blender setup for orthographic image rendering

As you have many questions, here are many answers:

Position

In orthographic mode, it is not important, how far away the camera is from the object (but stay within the clipping bounds). The position parallel to the object should be set and tweaked as you wish.

Tilt

As you already calculated right, the tilt of the camera downwards is $\alpha \approx 41.4°$. Here's how to calculate it for the orthographical view:

$\cos\alpha = \frac{48\text{ pixels}}{64\text{ pixels}} = \frac{3}{4} \implies\alpha = \cos^{-1}(0.75)\approx 41.4096221°$

the other rotation axes should stay untouched (parallel to the grid)

Orthographical Size & Resolution

This depends on how many grid squares you want to have in view. So we define, you want to have $m$ squares vertically and $n$ horizontally in view of your render.

If $n\ge m$ set the orthographical size to $n$.

The Render dimensions resolution: X-value is $n\cdot64$ px; Y-Value is $m\cdot48$ px.

The whole algorithm also works for different values $p,q\in\mathbb{N}$ with $p\ge q$ instead of $p=64$ Pixels and $q=48$ Pixels

With the above explained setup I got this render:

EDIT:

Fire Lancer pointed out that he wants a tileable setup.
Here's the setup with the blend file:


How to bake in Cycles to an external file

I am using 2.77 and still don't see that option to bake to an external file,anyway i found this and it's probably what you want

bpy.context.scene.render.bake.filepath = "/tmp/baked.png"
bpy.context.scene.render.bake.save_mode = 'EXTERNAL'
bpy.context.scene.render.bake.use_split_materials = True # or False

or
bpy.ops.object.bake(filepath="/tmp/baked.png", save_mode='EXTERNAL', use_split_materials=True, ...)

source : blender repo


How to convert from Magicavoxel to Blender to Unity, without losing the texture/colors

If just import the OBJ file(exported from MagicaVoxel) into Blender, animated it and want to sent it to Unity with textures I think this will help you:

On Blender

Export the model as FBX

On Unity

Import the FBX
Import the voxel PNG(palete) file into Unity as a texture
Drag the FBX file to the Scene
Create a new Material
Associate the new material to the model on Scene
Drag the PNG(palete) image to the ALBEDO field of the material

Another solution would be this: If you export an OBJ from MagicaVoxel and want to send it to Unity with the textures/colors you have to send to Unity all the 3 files MagicaVoxel generates when you export an OBJ file (.obj, .png, .mtl)

On the file explorer you have to select all these 3 files and drag-and-drop them all at once into a unity folder inside the Asset folder (need to drag from file explorer and drop into Unity software interface). This way Unity will receive the 3D Object model, the texture and the info about how the texture will be used into the 3D model.

Well, about that and a lot more you will find on this MagicaVoxel/Blender/Unity course: Modelagem 3D com MagicaVoxel para criação de games em Unity


Create an edge parallel to the normal of a face from a given vertex

You could use the View orientation, and set an orthographic view to the face, side on, with ShiftNumpad 1 or ShiftNumpad 3.. but I still think the quickest way is with a Custom Orientation. You don't need to duplicate a face to create an orientation from it

Right-click on the '+' in the Orientation dropdown, and add it to your Quick Menu, and/or give it a keyboard shortcut. (It used to be CtrlAltSpacebar)
In the Adjust Last Operation panel, set the New Orientation op. to 'Use After Creation' and 'Overwrite Previous'
You would have to select a face in any case, to avoid ambiguity, so do that...
.. and use your shortcut, followed by vertex selection, and EZ

or

You could try using the Cursor.

In the Cursor tool, set its Orientation option to 'Geometry'
and check 'Surface Project'
Give yourself  reachable keyboard shortcuts for the Cursor tool, and the Tweak select tool
Using the shortcuts, and with the Transform Orientation set to 'Cursor', drag the cursor over the face of interest, and EZ the vertex.


How to rotate a set of control points while masking

Select "Median Point" as the pivot point for the mask.


MMD models imported into blender are missing all textures?

This is an issue unique to MMD models in Blender due to the way MikuMikuDance understands shading, textures, and all things of that sort.
When you open an MMD model in Blender, you might see something like this.

(All of the following images are taken using the Blender 2.8 version of MMD tools)
There are several things we can try to get our textures looking normal and not so pink.
1. Disable Sphere Textures in the MMD Display tab.
Open your Visibility Sidebar on the right (usually can be opened by pressing N ) and navigate to the tab titled Misc. Under the section MMD Display, uncheck the box next to Sphere Texture.

If this does not correct any or only a few of your textures, continue to the next step.
2. Disable Toon Textures in the MMD Display tab.
Directly to the left of the Sphere Texture option from the last step, there should be an option titled *Toon Texture. Uncheck the box next to this option.

If this does not correct any or only a few of your textures, continue to the next step.
3. Turn off Use Shared Toon Texture.
Selecting the mesh of your model, navigate to the Material Properties tab under the Properties panel. You should see a list of all the textures being used on your model.

Select a texture you see on the list that has the pink hue we're trying to get rid of. For example, these textures are supposed to be a pale yellow but they are appearing as a vibrant pink in my textures list.

Once you have selected the texture, scroll down in the settings underneath the texture list until you find a section titled MMD Texture. There should be an option titled Use Shared Toon Texture in this section. Uncheck this option and see if the texture has gone back to normal.

If there is a part of your model that is bright purple still, there may be an issue with the model or a missing texture.
After trying these steps, your model should be back to normal. Mine turned back to normal once I unchecked Toon Textures in Step 2.

Something Important To Know
Some models rely on things like Toon Texture and Sphere Texture if they have a special shader attached to them (to make them look more anime-like, or because of the material the textures on it are trying to emulate).  If you have a model that only has a few sections turning up pink try Step 3 first on those textures in order to have the model work correctly. However, this method can also be used if you don't want those shaders on your model!


How to remove white color even tho the image is already transparent

These are the basic settings to get the alpha work in Blender Internal: you must enanble transparency and set it to 0.0 in the material tab, and then let the image texture set it to matte only where colors are present. Also specular can be distracting.


The feature you're referring to hasn't made it into Blender 2.79b. If I recall correctly, it was finished after the release of 2.79b. If you still want to give it a shot, you can go to the Buildbot page at https://builder.blender.org/download/ and download the Official build from there.

Once you start that one up, the User Preferences will show you these checkboxes when you enable CUDA:

As you can see, my CPU is listed as Intel Xeon CPU E5-2640, and can be used in addition to the TitanX.

On the same computer, Blender 2.79b doesn't show the additional CPU option:


No animation in Curves on using Bake sound to fcurves

In the 3D window go to the menu Object - Animation - Bake action, so to bake the sound created animation into an editable curve.


How to fit "n" identical objects in a circle?

http://pasteall.org/blend/index.php?id=49632
HERE is solution with maybe many of circles


I have edited your script just a bit and now it seems to work fine. The main problem with your script was that you applied the rotation first, then checked for the cap and, if the rotation was too big, applied another rotation. I think that this led to the shaking.

The better aproach is to first calculate if the rotation would get too big when adding the offset, and if so just apply as much rotation as needed

import bge, math
from bge import render
from mathutils import Vector

def main():

cont = bge.logic.getCurrentController()
own = cont.owner

# Get the child object named "Camera"
camera = own.children['Camera']

# Props
cap = True
capLow = 20
capHigh = 120

# Get the sensor "Mouse"
mouse = cont.sensors ["Mouse"]

# sensib = Property on this object named "Sensibilite"
sensib = own['Sensibilite']

# Get the center of the screen
x = render.getWindowWidth()//2
y = render.getWindowHeight()//2

screen_mid = (x,y)

# center = Center of the screen
center = Vector(screen_mid)

# Get the position of the mouse
mouse_position = Vector(mouse.position)

# Define the rotation that should be made
offset = (mouse_position-center)*-sensib*0.0002

if mouse.positive: #This part has changed!
    # Get the rotation of the camera
    Camrot = camera.localOrientation.to_euler()
    Camrotx = math.degrees(Camrot[0])
    print(Camrotx)

    # Check if new rotation value would be too high
    if Camrotx + offset.y > capHigh and cap == True:
        # Choose offset.y so that: Camrotx + offset.y = capHigh
        offset.y = math.radians(capHigh - Camrotx)

    # Check if new rotation value would be too low
    elif Camrotx + offset.y < capLow and cap == True:
        offset.y = math.radians(capLow - Camrotx)

    # Apply the rotation the the camera
    camera.applyRotation(( offset.y, 0, 0), True)

# Apply the horizontal rotation to the player/parent object
own.applyRotation((0, 0, offset.x), True)

# Reset the mouse position
render.setMousePosition(x,y)

main()


Right-click on the node and select Toggle Hidden Node Sockets or press Ctrl H


Here is a try:

I've twisted a sphere, kept an edge loop only:

Then used a Screw modifier to make it rotate from 360° to 180°, then gave it Solidify, Bevel and Subdivision Surface modifier:


It's useful for more complex situations than this. Let's say you have an object with a subsurf modifier, and you pass a reference to that modifier to some function:

mod = bpy.context.object.modifiers['Subsurf']
somefunc(mod)

That function can now figure out the path of a property of the subdivision surface, like this:

def somefunc(mod):
    print(mod.path_from_id('name')) # this outputs 'modifiers["Subsurf"].name'

Here is another practical example I just encountered. I want to create a driver for a specific property on the active sequencer strip. The driver needs to be defined on the scene itself, and I need to get the path for the property to drive:

se = C.scene.sequence_editor
se.active_strip.transform.path_from_id('offset_x')

This outputs 'sequence_editor.sequences_all["2017-07-06T11-04-11+0200.webcam"].transform.offset_x', which is what is needed for the driver.


Found the solution. Had to select objects and in Edit mode > W > Clear all restrict render.


Why the dark objects won't be differenced from the base object?

In Edit Mode select all of your vertices and Recalculate the Normals. The option is in your Tool Tab in the Shading/UV's tab (Press the "T" key to toggle the Tool Tab on/off).


You can do a couple of things:

In edit mode, select the Ngon, and triangulate it. (CtrlT )
Or Poke the face to create a fan (AltP)
Select all the faces you would like to flatten, for an average, or the one you would like the others to match, and create a new Transform Orientation (CtrlAltSpace). Perhaps give it a name. Then, making sure you're in your new orientation,  with the faces you want to be planar selected, scale them to 0 along your newly created Z-axis (SZZ0)


Would it be possible to improve camera_fit_coords in my zoom method with a generator?

EDIT: found the true improvement thanks to @batFINGER

After using the tip from @batFINGER and some other minor modification (I was initially editing gen_co_list...), the method can become a still comprehensible one-liner:

 def zoom_to_g5(scene, camera, object):
    camera.location, foo = camera.camera_fit_coords(scene, [co for corner in object.bound_box for co in corner])

I wanted a faster method, so I'm using list comprehension instead of a generator. There shouldn't be a memory problem since there are only ever 8 corners in the bounding box.

The method is ~25% faster, clocking in at:

>>>print(min(timeit.Timer('cam.location=0.0,0.0,7.0; zoom_to_g5(scn, cam, obj)', setup=setup).repeat(7, 1000)))
0.007111115999578033

OLD

It seems it was a mistake in my comprehension of generators, and the code should have been:

def gen_co_list(object):
    for point_co in [point[:] for point in object.bound_box]:
        for co in point_co:
            yield co

def zoom_to_g(scene, camera, object):
    loc_new_for_cam, foo = camera.camera_fit_coords(scene, [co for co in gen_co_list(object)])
    camera.location = loc_new_for_cam

That said, trying to time the code yields different results than what I expected:

setup = """
import bpy
scn = bpy.context.scene
cam = bpy.data.objects['Camera']
obj = bpy.data.objects['Cube']
def zoom_to(scene, camera, object):
    co_list = []
    for point_co in [point[:] for point in object.bound_box]:
        for co in point_co:
            co_list.append(co)
    loc_new_for_cam, foo = camera.camera_fit_coords(scene, co_list)
    camera.location = loc_new_for_cam

def gen_co_list(object):
    for point_co in [point[:] for point in object.bound_box]:
        for co in point_co:
            yield co

def zoom_to_g(scene, camera, object):
    loc_new_for_cam, foo = camera.camera_fit_coords(scene, [co for co in gen_co_list(object)])
    camera.location = loc_new_for_cam
"""

>>>print(min(timeit.Timer('cam.location=0.0,0.0,7.0; zoom_to(scn, cam, obj)', setup=setup).repeat(7, 1000)))
0.009414574999937031
>>>print(min(timeit.Timer('cam.location=0.0,0.0,7.0; zoom_to_g(scn, cam, obj)', setup=setup).repeat(7, 1000)))
0.00963822900030209

run on blender's classic cube.

I will therefore stick with the first zoom_to version, even though I thought the contrary would happen.


I would recommend to cut holes in the walls using Archimesh and placing the glass frame inside the window frame. Reasoning behind it is that you might want to play with sliding windows etc. But at the end the goal of your project decides mostly what approach will work best.

You can use Archimesh for house/room modelling. But will only work if you started from scratch. In other cases you need to cut the holes your self by for example the knife tool or re-organizing your topology.

Using Archimesh

The Archimesh Add-on is a fine add-on what can make a room, place windows and doors in the location you like and hit a button called Auto-Holes that will cut the holes for you.

The Archimesh add-on is distributed with Blender by default, but it is disabled. You just need to enable it in the User preferences.


How to remove the upper and lower checked box out of the render window

The aspect ratio in Render>>Dimensions must be X: 1.000 and Y: 1.000

See the image below.

Good luck.


Sine Integral
The function, denoted $Si$, by definition is the antiderivative of $\frac{sin\ x}{x}$ from $0$ to the input point whose value is zero at $x = 0$. The sine integral definitions are
$$Si(x) = \int_0^x{\frac{sin\ t}{t}}\ dt$$
To put it simply, we want to compute integral with animation nodes as the $sin$ function is already available. One technique we can use is Numerical Integration, which is a technique for approximating a definite integral and also quite easy to implement inside animation nodes. There are various methods in numerical integration but for this example I will use two methods that won't use too much node.
Trapezoidal rule
The Trapezoidal rule works by approximating the region under graph of the given function as trapezium rather than rectangle.
Let $f(x)$ be continuous on $[a, b]$. We partition the interval $[a, b]$ into $N$ subintervals, each of width
$$\Delta x = \frac{b-a}{N}$$
The Trapezoidal rule for approximating $\int_a^b f(x)$ is given by
$$\int_a^b f(x)\ dx \approx \Delta x \Biggl(\sum_{j=1}^{N-1} f(x_j) + \frac{f(x_N) + f(x_0)}{2}\Biggr)$$
Where $x_j = a + j\Delta x$. Because $Si(0) = 0$, we can simplify the equation into the following
$$\frac{b}{N} \Biggl(\sum_{j=1}^{N-1} f(x_j) + \frac{f(x_N)}{2}\Biggr)$$
Notice that $\Delta x$ is also substituted by $\frac{b}{N}$ because $a$ is always zero in this case.
Implementation

The result for $Si(2\pi)$ with 2000 subintervals is $1.41804$. Let's compare with the result from WolframAlpha

To get more accurate approximation, try increase the subintervals.
Monte Carlo integration
Another technique for numerical integration is Monte Carlo integration. This technique is using random numbers instead of subintervals or midpoint. While Monte Carlo integration is usually used for higher-dimensional integrals (eg. in Machine Learning), we can also use it for one-dimensional integral. Beside that, we can implement this technique in animation nodes with just a few nodes.
$$\int_a^b f(x)\ dx \approx \frac{1}{N} \sum_{j=1}^N f(\bar x_j)$$
where $\bar x_j$ is $N$ uniform random numbers on $[a,b]$. Monte Carlo integration use uniform sampling and fortunately random number generator in animation nodes use uniform sampling. Maybe… Or is it?.
Implementation

Blend file for study and practice

Python
Scipy
Both techniques is not really accurate and a bit time consuming to make the node tree, another alternative is to use scipy. If your blender installation is using system-wide python and have scipy installed, you can use scipy.special.sici function or you can install scipy directly in blender.
from scipy.special import sici
# sici return two results, first is Si(x), second is Ci(x)
Result, _ = sici(Number) # Store in output variable

As you can see, using scipy is more accurate.

Using Hypergeometric Series
If you don't have or don't want to install scipy, this function will do without any external dependency and also quite accurate. Adapted from mpmath then simplified and this for epsilon value.
EPS = abs(7.0/3 - 4.0/3 - 1)  # 2.2204460492503131e-16 on 64bit CPU

def si_(z, *, maxterms: int = 6000):
    """Sine Integral"""
    oz = z
    z = -0.25*z*z
    s = t = 1.0
    k = 0
    while 1:
        t *= 0.5 + k  # coeffs[0] + k
        t /= 1.5 + k  # coeffs[1] + k
        t /= 1.5 + k  # coeffs[2] + k
        k += 1
        t /= k
        t *= z
        s += t
        if abs(t) < EPS:
            break
        if k > maxterms:
            raise Exception("Hypergeometric series converges too slowly. Try increasing maxterms.")
    return oz*s

Result = si_(Number)


How to assign same Data to multiple object copies

Blender makes this very easy.

Select all the objects you want to have the same data, then select the object which the data will be copied from, last so that is it the active object.

Press CtrlL and choose Object Data. Or from the 3D view header Object > Make Links > Object Data.

Doing that will give the same outcome as if you had used the linked duplicates (AltD) to start with.


Locking translation axis for multiple objects

Select all your objects, lock the channel, then right click on one of the lock icons and "copy to selected" to copy the locked status to the other objects.


The easy way, which requires a bit (just a bit) of manual work:

Install "Edit Tools 2" and "Loop Tools" addons. They're both
available in basic blender 2.79/2.79a, so just find them in addons
and enable
Select your edge, hit W > Edit Tools > Offset Edges (make sure you're in edge editing mode)

Offset twice, for both positive and negative direction

Select both of edges you've just created. Hit W > Loop Tools > Bridge


Importing animations for Rigify in Blender for use in Unity

In the unity asset store, there is a seller named Mixamo. They have an animation store that sells mecanim animations, like a run cycle for $10 each.

https://www.assetstore.unity3d.com/#/content/362

Here is a short demo of it:
http://www.youtube.com/watch?v=17V3_j1NZhM

As far as I know, you have to use mecanim (the new and improved animation system in unity).

With the Mixamo animation store you can download and preview the animations on any character. But the names on the bones have to be right. I'm not entirely sure if rigify does this right, should be a minor problem compared to making all those animations.

Edit:
Oups, according to this page:
http://meglassons.com/?page_id=1971
Rigify isn't compatible with mechanim. You have to rename the bones or create the rig yourself.


This is likely to be an issue due to clamping, which prevents the bevel from generating non-manifold (i.e. self-intersecting) geometry. Try turning this off in the modifier settings and you should see what's happening. It'll probably be due to some of the very short edges meaning the clamping causes the bevel width to be clamped very small (small enough to make the bevel virtually invisible).


In the Options dropdown of the sculpt mode, deactivate Fast Navigate.


I guess you need to select your icing, then go in the Properties panel > Particles > Render and  enable the Show Emitter option.


You can invoke copy and paste using the Spacebar menu (it shows CtrlV as shortcut for paste, but as you said that doesn't work). Simply press Space and search for copy and paste and use the appropriate entries from the list.

  As pointed out by GiantCowFilms, the copy / paste functions work at object level. So even if you use them in edit mode, the whole object gets duplicated and not your selection!

Because you can use ShiftD to duplicate, there seems to be no need for copy and paste.


When I edit a plane with an image texture it distorts oddly

There is a smiple fix: add a sub surf modifier and set it to simple. Be sure to increase to subdivisions.

The issue is that because a face is made of 2 triangles, the uvs are stretched across the triangles and not the mesh.


change cryptomatte setitings with python

View the UI source

In User Preferences > Interface > Display turn on developer extras. Sounds like you already have.  When the path in button hover is dodgy, if available click view source on a field of interest.

In this case it opens addons/cycles/ui.py in text editor at or around the CryptoMatte draw panel where this leaps out

cycles_view_layer = context.view_layer.cycles

Off to the python console:

>>> cycles_view_layer
bpy.data.scenes['Scene']...CyclesRenderLayerSettings

>>> cycles_view_layer.use_pass_crypto_
                                      asset
                                      material
                                      object
>>> cycles_view_layer.use_pass_crypto_object
True

>>> cycles_view_layer.pass_crypto_
                                  accurate
                                  depth
>>> cycles_view_layer.pass_crypto_depth
6

>>> cycles_view_layer.pass_crypto_depth = 10
>>>

can put in accurate mode with

cycles_view_layer.pass_crypto_accurate = True

Some more fiddling, the property is displayed as belonging to scene

>>> cycles_view_layer.id_data
bpy.data.scenes['Scene']

>>> C.scene.view_layers['RenderLayer'].cycles
bpy.data.scenes['Scene']...CyclesRenderLayerSettings

>>> cycles_view_layer
bpy.data.scenes['Scene']...CyclesRenderLayerSettings

>>> C.scene.view_layers['RenderLayer'].cycles is cycles_view_layer
False

>>> C.scene.view_layers['RenderLayer'].cycles == cycles_view_layer
True


One quick way is to use Offset Edge Slide tool. Select bottom face and run it (depending on the version) either with Ctrl+Shift+R or via viewport menus:

  Add two edge loops on either side of selected loops.

Offset Edge Slide

Since there aren't any faces on the other side of the selected face before using the command, no extraneous edges will be added and you don't need to dissolve any unnecessary geometry in this case.


Try scaling in the y axis how much you want, then scale the same in the x axis. (Example with things you type: S,Y 90, S,X 90)


Using knife project method to make a shape into the mesh

Try to start with more simplified geometry connected without n-gons.

Start with 10 sided Circle and continue extrude, scale, as needed)
Use Subdivision Surface modifier to round curved parts
and Edge Crease Shift+E 1 to keep corners sharp.

Similar to this.

Note: I probably used too low topology, when I would like to bevel edges now, I would have to add another loops (alternatively use bevelling on shader level).


How to make toothbrush Bristle animation

As suggested by mma78 in the comment try a Hair Particle System.

Brushing the default cube

Make an emitter plane:

Copy a few faces of the lower side of the toothbrush head where the brushes sit. In Edit mode, duplicate Shift+D, press Esc or RMB to leave it where it is, and separate selection with P)
In Object mode, rename the plane, and parent it to the toothbrush (Ctrl+P). Parent must be selected last = highlighted light orange.

Add a Hair Particle System to the bristle plane

150 particles
3, 5, or 8 segments (I used 8. Test it, less can make the bristle stiffer)

In Field Weights turn off gravity:

Gravity: 0.000  (we do not want to bend the bristles to the ground)

Adjust these values for render and the shape/appearance of the bristles:

Render:

[_] Show Emitter (disabled, we don't want to render it)
Path → Steps: 5

Viewport Display:

Strand Steps: 5

Children: Simple

Radius: 0.02m (adjust this to your toothbrush size! Value here is for the 2m default cube!)
Roundness: 1.000

Clumping:

[X] Use Clump Curve
(edit a curve. Make it round in the top right corner. This makes the bristles heads round)

Hair Shape:

Strand Shape: -0.850    (for rounded bristles)
Diamenter Root:  0.3m    (adjust this to your toothbrush size!)

enable [X] Hair Dynamics. Run/bake the simulation and play with the Hair Dynamics values:

Collision

Distance: 5cm (adjust this to your toothbrush size!)

Pin Goal Strength: 10
Structure:

Vertex Mass: 0.3 kg (default, higher values make the bristles inert)
Stiffness: 30 (higher values result in less bending)
Damping: 0.300 (default, increase if the bristles swing too much)

Happy teeth brushing!


How to populate a menu using "path_menu"?

Ok. Seems there's a pretty straight forward example in space_text.py

class TEXT_MT_templates_py(Menu):
    bl_label = "Python"

    def draw(self, context):
        self.path_menu(
            bpy.utils.script_paths("templates_py"),
            "text.open",
            props_default={"internal": True},
        )

path_menu can be used within the main draw function. Would be great if I could figure out how to make the contents of self.path_menu a sub menu item (rather then enumerating out directly into the menu).

EDIT: Just to be clear, I mean "would be great if I could" create a sub menu from the path_menu contents directly within the original menu itself (without having to create a whole separate, other class menu to call on).


Can one modify Fly mode in blender to be active on press/hold of a key?

Sadly, I don't know of any way to customize it the way you want.
But you can at least assign the command to your custom mouse button.

Press Ctrl + Alt + U to open the Blender User Preferences. Go to the Input rider. You can edit the hotkeys in this context. Expand the 3D View > 3D View (Global) area.

Locate the View Navigation entry and change its hotkey to your mouse button.

With the button you enter fly mode.

You exit and confirm with the left mouse button.

You exit and abort with right mouse button.

Lifting one button couldn't differentiate between those to actions.


Is there a way to rotate the origin without rotating the geometry?

First go into Edit Mode (Tab). Select the whole mesh (A) and copy it to the buffer (CtrlC).

Leave Edit Mode Tab and rotate (R) your object as you like. Then go back into Edit Mode, delete the whole mesh (X or DEL).

While still in Edit Mode, paste the mesh from the buffer (Space and type "Paste Selection from Buffer" then hit Enter).

Now leave Edit Mode and the mesh is back in place, but the object is rotated.

Not a direct button to do what you want, but this is pretty quick to do.


I would first create a map with all your holes shapes (the primitives may need more vertices than what I've done though), then weave the edges between their vertices, then extrude outwards, extrude inwards, extrude along its length, add edge loops to sharp. Then to deform the whole thing you could use a Lattice or a Mesh Deform modifier.


How to control the flow pattern of the noise texture node?

In this image you're using UV space and then scaling the X axis to 0, so that's why your noise texture is coming out like a wave texture.  I'll go through what my solution might look like.  This is UV space so you can either just go and use proportional editing to move the UVs of the faces, or we can do it with nodes.
Here's our sample scene, it's just a plane and I've put a wave texture on it.

We'll use your distance from the UV origin on one axis to move the UV space along the other axis.  We'll use a separate XYZ and a combine XYZ node.

And then you can insert any kind of math in there to control the rate at which you are shifting the UV space over, or create any manner of effect.


I'm not sure where your problem comes from but if you want to do that with the Array modifier, here is the way:

Create your card, at the centre of the scene to make it simpler.
In Edit mode shift the mesh from its origin (on the Y axis in my case).
Back in Object mode, create an empty at the same point as the card origin.
Give your card an Array modifier. Choose Object Offset with the empty as object. Choose the Count value you want.
Rotate the empty on the Z axis. In my case, as I've chosen a count of 36, I have to rotate 10° so that it make a complete circle.
As you don't want the cards to be on the same Z level, rise the empty a bit on the Z axis (use shift while you move to make it more precise).


White Block Artifacts in Eevee Beta Renders?

I've been experiencing this as well; when it happens to me, it's occurring in geometry where there's a degenerate or zero-area face (e.g. take a polygon and scale it to 0 in two dimensions, so it's just a couple of lines occupying the same space), and the material applied to it has a normal map. If Depth of Field is turned off, it shows up as pure white pixels occurring randomly along the line; with it on, they're either small white squares or small white circles. (And if Bloom is also turned on, it looks like J.J. Abrams came by and dropped a massive lens flare into my scene.)


How to correctly drive a normal node with lamp rotation?

This is a bit tricky, since the value range of the normal vector is (-1, 1). But you appears to control it by object rotation, which circle range is from 0° to 360°. It doesn't make any sense to add drivers between them.

You can use Mapping node to control the Normal vector output, driven by the object rotation (in degrees or radians). However, Blender internally uses Radians instead of Degrees, that's why you'll see the driver value shows in both radian and degree system.

So, you need to do some radian calculation for the driver expression. In this case, on the newly added Normal node (with the "control ball"  UNTOUCHED), you need to add/subtract a half circle for it, which equals pi.

Example file:


How do I hide this top panel and where did my menu bar go?

The trick in this scenario is you have to collapse all the lower panels so that you have 2 horizontal panels, then join them to one and then start out again to create the layout you want.


I suppose all the textures you're talking about are packed? What you could do is go in the File menu > External Data > Unpack All Into Files which will create a texture folder next to your file, replace all the high-quality images with low-quality, keeping the exact same name, then File menu > External Data > Pack All Into .blend.


Weight painting problem : when I move the head of my character,the cloak also move but it shouldn't

If you want to simulate the cloak with the cloth simulator, you'll have to remodel it. This cloak was made for a still model, it was not meant to be simulated. Two points to keep in mind :

A cloth to be simulated should have a non distorted starting shape, since the simulation will perform the distortions on it. If you leave the base mesh distorted, the surface will be completely uneven. It will look like some parts of the fabric are stretched.
a cloth simulation only works if the cloth is single-sided. Your cloak has 2 sides. If you perform a cloth simulation on it, the simulator will still consider every face a piece of fabric. So you're basically telling it this mesh is a double cloak (except both sides are joined at their boundaries). To give thickness to a single-sided simulated cloth you have to use a solidify modifier after the cloth modifier.

As for attaching parts to your character, you have to combine pinning and hooking :

In pose mode, select the bone you want your pinned cloth to follow
Shift select your cloth
Tab to enter edit mode
select the vertices of your cloth you want to attach
create a new vertex group and assign the selected vertices
In the vertex operators (Ctrl+V), go in Hooks > "Hook to selected object bone"
Move the hook modifier on top of the cloth modifier
In the cloth properties, enable Pinning and select the vertex group you just created.

Here's a simple example of the result :

And here's the file used for this gif :


How to get better anti-aliasing in blender internal?

I think anti-aliasing doesn't have anything to do with this.

I can't see very well, but I think the problem with "rough" reflection in the first image is due to a low amount of reflection raytracing samples. Try increasing the sample amount in the material's "Reflections" tab.

Cycles and Blender Internal rendering engines are defining materials differently, you can't quite switch from one to another every moment and expect to see similar visual results. Setting up object materials for Cycles is a completely different process. When you set up your materials for Blender internal rendered and then switched to Cycles, Blender actually tries to create similar materials, but it's a very basic approximation, this is where there's no reflection on the floor. Also setting up lighting for Cycles is different.

The basic difference is that Blender Internal is a scanline rendering engine, while Cycles is a raytracer. The latter provides much more realism at the cost of much higher computational cost. Blender internal is however very useful for non-realistic renders where advanced light simulation is not needed and we can work with the different tools for "faking" these effects.

For instance: Cycles will calculate how light propagates and reflects from surfaces and what image it will produce when reaching the scene's camera. All the bells and whistles are a part of the simulation of how light behaves in the 3D scene. Blender Internal however uses different tricks to fake these effects like shadow maps, raytraced reflections, bumpmapping, volumetric shadows... in Blender Internal it's all kind of "fake" and approximate and it doesn't look that real when compared to Cycles, which actually is simulating how photons bounce around. The downside of Cycles is the amount of noise you get from fast renders - it's a bit like getting too little exposure time for taking a picture in a dark environment - it's gonna be noisy. The same is with cycles. The more samples you give it to calculate, the less noise you're gonna have (but it can be very time-consuming).


In 2.79, you would have had to switch the view to Textured mode to see the image on the plane in the viewport. The equivalent in 2.8 would be to switch to LookDev.

The option is there, now, to see a reference image in Solid or Wireframe mode as well, by creating an Image Empty object, which is altogether more flexible.

You can create it manually, with ShiftA > Empty > Image, and adjusting the settings in its Data tab, or simply by dragging an image from your filesystem into a 3D View.


How to create UV and texture for egg shaped model

Try to reproject your texture upon a catmull-clark subdivided version of the mesh with the subdivide UVs option disabled.

This way you should be able to have more faces (and so a higher projecting accuracy), while maintaining the same UV islands.

Before:

After:

In my testfile this process was able to mitigate the effect of the distortion.

Once reprojected the texture, you can obiuvsly delete the modifier and keep your vertex count untouched.


How to create a floor full of serpentines - streamers?

As suggested the Cloth simulator is one way to go. In the example below the mesh is split with the V key along the vertical edges, but remains one object onto which the simulator acts. Important here is the weight painting that creates the group - ALT drag the brush for a smooth gradient. The weights are pinned in the Cloth settings.

The effect is visible once a force of some kind is added - each has somewhat different effect and can also be animated. Here I just used Harmonic as it works fine in a static position. ALTA to play animation.

At any point in the animation you can freeze the mesh by applying the Cloth. Below I have added a second cloth modifier onto the mesh created from the first cloth modifier and dropped it onto a plane with collision enabled. Again here you can choose a point in the animation and then apply it to work on it further as a mesh.


Explanation first:

PNGs can't handle pixels that are emissive and transparent at the same time because PNG does not support associated alpha transparency.

You are on the right track using EXR, what you need to understand is that EXRs are exported as linear information (meaning no "gamma curves" are applied to make them display nicely on a monitor). The images on EXR format are not constricted by the limits of Display Referred, with none of the color transforms set by the color management. (visit this link for a deeper explanation). Think of EXR images as exact copies of the render layer with all of the brightness and color, which might exceed the limits of what the monitor can display.

An attempt to answer:

EXR have to undergo some color transform before they can be displayed nicely on the screen. If you import them onto other software (like photoshop) they need to be interpreted as linear before they can be displayed,and probably scaled so that they fit within the values used by the display device. If you do the compositing in blender, the EXRs should have no problem. Please add information on how you are viewing them and what you want to do with the image.


It seems you're using Grab. With Grab (g) you're simply moving the edge, which is made out of vertices that it shares with the adjacent edges, hence they are also manipulated.
Try using Extrude (e) instead. This will create a new edge (a set of two vertices) in the exact same location that you can manipulate independent of the adjacent geometry.
If you then set the Transformation orientation to 'Local' , you can move it along the axis in the same direction as the original roof:


In this case beveling vertex won't really help as it will create Ngon with too many sides:

While it's possible to fix that Ngon to desired face later it can be cumbersome as original vertices position won't be the case any more.
Instead you can try Rip tool to detach some faces, fill new one and split it. Then dissolve unnecessary geometry. Note though that both procedures - beveling and merging vs ripping and dissolving - take nearly the same amount of effort.

Select vertex where edges are connecting (by the way too many edges are joining at one point there). Then press V to execute Rip tool. Your mouse cursor will affect which part is being ripped, in the case below mouse cursor was to the left top so to rip left faces.

Fill a new face there and split it at the vertices in the middle with Connect Vertex Path tool (J); select vertices first and then execute the tool. It will split the face into 2 triangles.

Then merge unncessary vertex and dissolve edges which are no longer needed.

The result isn't clean, it's more of a middle position between further retopology.


Is there a way to output gif animation from blender?

No, there isn't a way to export (or import) gif directly.
GIF is not a supported format in blender.
You would need to export your images or animation in a different format, and then convert it to GIF using an external application.
For a list of the supported formats read this.
To record a screen capture using external software refer to this post in Meta:
What is the process for creating gifs for questions and answers?


How do I fix mirror errors for Mirror Shape Key, without splitting and mirroring?

This error occurs when the mirrored mesh is not perfectly mirrored on the opposite side. The solution is to make a perfect mirror of both sides. But the mesh needs to have to be almost exactly the same on both sides also it must have even amounts of mesh on the mirrored side.

In edit mode select the half the vertex that needs to be mirrored.

Make sure the symmetry is on for the side you want to mirror.

Press G then Enter


Link the text content of two text objects

this a script that uses the scene update handler to synchronize two text object content :

select the two text objects only
copy and paste the script and click run
once you edit one of the text objects the other one will get updated accordingly

import bpy

obj1 = bpy.context.selected_objects[0].name
obj2 = bpy.context.selected_objects[1].name

def link_text_objects(scene):
    obj = bpy.context.active_object
    if obj.type == 'FONT':
        if obj.name == obj1 :
            scene.objects[obj2].data.body = obj.data.body

        else :
            scene.objects[obj1].data.body = obj.data.body

bpy.app.handlers.scene_update_pre.append(link_text_objects)


How to change file output node's file subpath value in python

I found a solution here and it works
scene = bpy.context.scene
for node in scene.node_tree.nodes:
    if node.type == 'OUTPUT_FILE':
        node.file_slots[0].path = ''


How to save an .exr file with 32 bit with python

You can change the color depth like this:

image_settings = bpy.context.scene.render.image_settings
image_settings.file_format = "OPEN_EXR"
image_setting.color_depth = '32'

Note that '32' is a string and not an integer/float.
Then save the image like this:

img = bpy.data.images['myImage'] # your image here
img.save_render("C:\\Users\\daddy\\me\\Documents\\myImage.exr") # save to desination


Maintain equal rotation on multiple objects

Yes, it's possible.  You need to rig it twice, once in each direction.

No bone here is parented, but I've raised each bone in the Z axis to indicate a hierarchy of "copy rotation" constraints.  There are five bones.  First we travel through the gears one way, copying rotation along the way.  Then we travel back along the gears in the opposite direction, again, copying rotation along the way.  (The middle bone doesn't need to be duplicated.)  The gears themselves are parented only to the final bones.  The first three bones here should be understood as the control bones; the last two bones should be hidden.

Imagine rotating the second bone, indicating the middle wheel.  Nothing is directly parented to this, so there is no immediate effect from this.  The first bone is unaffected, but the third bone rotates properly via its constraint, rotating the right gear.

This rotation is then propagated to the fourth bone, which is what is responsible for actually rotating the middle gear, and then to the fifth bone, which rotates the left gear, even though there was no transformation given to the first bone.


You can do this with newest Blender versions (as I remember from 2.78 and up).

First of all you'll need to turn on Experimental features (1) and select under Material tab Displacement as True (2). You can use Both but mixing Displacement with Bump gives weird results. Next step is to add Subdivision Surface modifier with Adaptive checked.

You can check whole tutorial about it here: Introduction to Microdisplacements


I think this sort of thing is much easier to work in the flat, keeping the vertex count low, and working under a Subdivision modifier

So, I've made a nice pot, and a lid. But the lid doesn't have an inside, and needs to fit a recess in the pot.

In Edit Mode CtrlD steal (duplicate) a profile loop, lying in the XZ plane, from the original pot, and P split it off into a new object.
Do the same with the lid.
Join the new profiles CtrlJ into a new object.
Assign a Screw and Subdivision modifier to the new combined profile, to make it back into a pot-with-a-lid.
You can now edit the profiles in place -  if you don't show the modifiers in Edit Mode, you can flip back and forth Tab to Object mode to see how your work is going.

The picture shows the original profile in the vicinity of the rim, and 2 steps in the edit - using E extrusion on vertices to draw out new edges. Still in Edit, to make the inner dome,I created a new Circle mesh (unfilled) to add to the profile, moved and scaled it into the right place, deleted most of it, and O (Connected) proportionally edited it to keep it smooth inside. (Always keeping everything flat in XZ)

You have the choice of if or when to apply the modifiers, add bevels, whatever you like.

In short, this recommendation is: edit the profile, not the pot.


Cinema4d R19's new viewport and Blender's EEVEE

R19 only have preview rendering mode (or advanced OpenGL). Where Eevee is a game engine view (close to UE4) Afaik, C4D have no plans on making an actual game engine view. But I could be wrong of course.


You have to select proportional editing first(at the bottom the 3d view), then hit g to grab.


Is there any software that I can do real time motion capture in Blender with?

There are trials you can play with here https://ni-mate.com/ and here http://ipisoft.com/. Extra functionality, you might have to pay for...


M = Mask Painting
K = Snake Hook Brush
Shift+C = Crease Brush
C = Clay Brush
Shift+T = Flatten/Contrast Brush
L = Layer Brush
G = Grab Brush
I = Inflate/Deflate Brush
P = Pinch/Magnify Brush
S = Smooth Brush

1 = Blob Brush
2 = Clay Brush
3 = Clay Strips Brush
4 = Crease Brush
5 = Fill/Deepen
6 = Flatten/Contrast Brush
7 = Grab Brush
8 = Inflate/Deflate
9 = Layer Brush
0 = Mask

Shift+1 = Nudge Brush
Shift+2 = Pinch/Magnify Brush
Shift+3 = Rotate
Shift+4 = Scrape/Peaks
Shift+5 = SculptDraw
Shift+6 = Smooth
Shift+7 = Snake Hook
Shift+8 = Thumb

Graphic below, slightly outdated. Twist was renamed Rotate and Shift+Number hotkeys re-assigned.

Current as of Blender 2.79a


Why are part of my model differently colored?

easy, recalculate the normals of the oddly colored area of the model. the normals look like they have been reversed.


This does not answer your question directly, but consider this as an alternatively way to implement a more realistic atmosphere effect. (With Blender Render)

Basically, you want to use the volume material type on a sphere, this gives you much more control over the density of the atmosphere, and you can tweak the density and colour without fussing around with blurring or nodes.

The following screenshot has all the settings you need to generate the atmosphere.

Blend File


what have I done wrong with this piece of code?

logic = ? (not defined) -> I assume you mean module bge.logic (from import bge)

  Module to access logic functions

getCurrentScene()

  Gets the current Scene.

  Return type:  bge.types.KX_Scene

A KX_Scene has no items (BGE properties)

KX_GameObjects and it's sub classes have items (properties). You can access them via GUI and via Python:

myObject[myPropertyName]

  Now I want it to be working with more objects so I thought: Let's make the name "Player" not be the name of an object but refer to every object that uses the property "Player"

When you want to process multiple objects the same way, you need to provide these objects and process each of them separate.

As your request involves two different operations I suggest to split them:

import bge
from mathutils import Vector

PROPERTY_GRAVITY = "gravity"
'Objects with that property are effected by this planet'

GRAVITY = 9.8

def applyPlanetaryForce():
    controller = bge.logic.getCurrentController()
    planet = controller.owner

    for object in findObjectsByProperty(PROPERTY_GRAVITY):
        vectorToPlanet = Vector(object.getVectTo(planet)[1])
        vectorToPlanet.length = GRAVITY
        object.applyForce(vectorToPlanet)

def findObjectsByProperty(property):
   return [object for object in bge.logic.getCurrentScene().objects
                  if property in object]

and

import bge

PROPERTY_PLAYER = "player"
'Objects with that property are aligned to this planet'

def alignToPlanet():
    controller = bge.logic.getCurrentController()
    planet = controller.owner

    for player in findObjectsByProperty(PROPERTY_PLAYER)
        vectorToPlanet = planet.getVectTo(player)[1]
        player.alignAxisToVect(vectorToPlanet, 2, 1)

def findObjectsByProperty(property):
   return [object for object in bge.logic.getCurrentScene().objects
                  if property in object]

Yes, you can place both functions into the same module. They both belong to planet behavior.

I strongly suggest not to mix these operations. It is better to keep them separate. You need one controller more, but your code does not grow into a giant mix of different requirements.

I hope it helps


How can I connect two seams on a mesh? They come apart while posing but not while modeling

Idle Chit-chat

Ok, I switched to answer to give a more detailed, well, answer! It appears that your mesh is not actually one piece, despite appearances.

Problem

I am not familiar with the self-intersect tool you described (or Ctrl + F if those are one and the same), but the spheres are separate. I proved this by selecting a single verticy of one of the spheres and keying L. If the mesh were a whole, like rigging requires, everything would select. Everything, obviously, did not.

Solution

Luckily, there is a simple solution! Select the entire mesh with A, key W, and select Remove Doubles:

This will join all the seemingly joined edge loops. Now you can continue on and rig!


Current behavior
Just now you have one operation:

apply an impulse (a force with the duration of one frame)

As you apply this impulse at subsequent frames again and again you get a constant force.
Be aware the value you describe as "speed" is no speed at all. It is the z-component of the force/impulse.
Request
You want changeable z-component of the force. This means you need new operations that change this strength.
Solutions
Additional forces
As you can add forces, you can simply add another force when shift is pressed.
if up:
    obj.applyForce((0, 0, zStrength), True)
    if shift:
        obj.applyForce((0, 0, additonalShiftZStrength), True)

Replace force
You calculate a different force to be applied:
if up and not shift:
    obj.applyForce((0, 0, zStrength), True)
if up and shift:
    obj.applyForce((0, 0, shiftZStrength), True)

Toggle

With this code I have to hold shift to change speed. But I want to change the speed at one click so that it will keep using the new speed when I press my uparrowkey.

In this case I suggest a different design at the higher abstraction level.
Lets see:

you want to use up to move forward
you want to use shift to switch to turbo strength
you want to use shift to switch to normal strength

State machine
I suggest to use states:

normal
turbo

Hint: Think about what a key press really means -> what is the purpose of the key press. The design will be determined by the purpose rather than the key. Therefore I will not talk about up and shift anymore but "move" and "toggle turbo". The easiest way to think about that is: how would you explain to a player what the keyboard key is used for.
You transit between the states this way:

when in normal state and "toggle turbo" is requested -> transit to turbo

when in turbo state and "toggle turbo" is requested -> transit to normal

This is our high-level behavior. You can switch state by requesting "toggle turbo" (pressing shift once).
Now the low-level behavior. With the two states we have two different low level behaviors:

when in normal state:
**when requesting to "move" -> move with normal strength

when in turbo state:
**when requesting to "move" -> move with turbo strength

The details are quite similar. The difference is the strength.
There are several options to implement a state machine. They mostly differ where to hold the state.
Build In states
Transitions:

And then add Actions:

Please note the [Level] switch is enabled. This ensures the sensor triggers the controller on state change and therefore activates the actuator without the need to release and press the button again.

The actuators are labeled: "normal move" and "turbo move"
Property
You store the mode in a property as you have just two of them you can use a boolean property.

To toggle the value you can use property actuators:

Then perform the according operations dependent on input and property value:

Dynamic strength
This more flexible than a state machine as you are not limited to a low number of states. But this solution is not that flexible in terms of difference between normal and turbo mode. The differences you can have is the force you apply.
The idea is that you use the current strength as "state".

When you request "toggle state" and the current strength is high -> reduce the strength.
When you request "toggle state" and the current strength is low -> raise the strength.

These are still two operations:

toggle strength -> which needs Python due to it's dynamic nature

move -> which can be Logic bricks or Python

Both operations rely close together do to the shared strength.
The implementations differ in the way where you store the strength.
Motion actuator as storage
You can benefit from the fact that the motion actuator can store parameters. You simply re-configure the actuator when toggling turbo.
toggle_strength.py
import bge

controller = bge.logic.getCurrentController()

STRENGTH_NORMAL = 1
STRENGTH_TURBO = 10

if controller.sensors[0].positive:
    motionActuator = controller.actuators["move"]
    force = motionActuator.force
    strength = force[2]

    newStrength = STRENGTH_TURBO if strength < STRENGTH_TURBO else STRENGTH_NORMAL
    force[2] = newStrength
    motionActuator.force = force

Property as storage
A pure python solution requires you to store the current strength somewhere else. A good place would be the object itself -> means a property.
toggle_strength.py
import bge

controller = bge.logic.getCurrentController()

INTERNAL_PROPERTY_STRENGTH = "internal.strength"

STRENGTH_NORMAL = 1
STRENGTH_TURBO = 10

if controller.sensors[0].positive:
    owner = controller.owner
    strength = owner.get(INTERNAL_PROPERTY_STRENGTH, STRENGTH_NORMAL)

    newStrength = STRENGTH_TURBO if strength < STRENGTH_TURBO else STRENGTH_NORMAL
    owner[INTERNAL_PROPERTY_STRENGTH] = newStrength

move.py
import bge

controller = bge.logic.getCurrentController()

INTERNAL_PROPERTY_STRENGTH = "internal.strength"

STRENGTH_NORMAL = -1

if controller.sensors[0].positive:
    owner = controller.owner
    strength = owner.get(INTERNAL_PROPERTY_STRENGTH, STRENGTH_NORMAL)
    force = [0.0, 0.0, strength]

    owner.applyForce(force, True)

The "move" sensor requires [True Level Triggering] enables otherwise there will be just a single impulse rather than a constant force when the key is pressed.

Hint
Better avoid "main()". It serves no purpose other than to make your code hard to read.
If you really want to place your code into a function choose a descriptive name that tells what the function is supposed to do.
When this is the only function in your script the script name should already provide this information. This should not prevent you to provide more details with the function name.
The name "main" is a reserved word in other programming languages for complete different purpose. It can easily create confusion when used here.
Btw. in your sample code above it cause errors.


You can use vertex hooks, example: draw a line mesh (2 vertices).

Then in edit mode, select one vertex, press CTRL+H and select "hook to new object". Here an example for a cube mesh, easier to visualize: it works anyway.

A new "empty" will be created where the vertex is, and the vertex is "hooked" to it (meanwhile a "hook" modifier has been created, for your line mesh, with proper relations to empty object).

Do the same with the other vertex. Now you have the line mesh and two empties. Wherever you move the empties, their respective hooked vertex will follow.

You can also hook to existing objects (empties or others) or bones, choosing other options after CTRL+H. You may need to select them first.

In this case you'll probably have to move the control points to the respective empties origin while in edit mode to set their position:


Object renders black with UV mapped image?

I've had this problem in the past when using glossy, glass or transparent materials with an alpha.

Here is the correct setup for alpha textures with a glossy (same process for glass and transparent).

You can remove the transparent node if you don't need it.

The Curve node is there in case the black or the white are a little bit grey in the alpha.

NB there is an invert node for when I use inverted alphas. Not useful here.


What does this icon mean ? and How can I erase it at once?

Let's go one by one:

The 'icon' you're reffering to is a so called empty.
The ones in your file contain no geometry and are generally useless.
You can delete or hide them.

1) How to delete all these empty objects.
Press 'B' on your keyboard for box select. And then right click -> delete.

Be careful not to delete real geometry when cleaning up your file.

2) You can get rid of those black lines here:
Overlays->Relationship Lines and Overlays->Extras


How to get the worldspace location of a rendered pixel from Python

Blender's Python API currently doesn't expose access to the pixel value of render passes.

(You can access image pixels but renders's are a more complex structure).

However since you mention you need to store the values in a file, just save the OpenEXR file, this will store the values in a file.


How to render an Equirectangular Panoramic image with Eevee

There is this VRRenderer script by EternalTrail that works okay for rendering a stationary camera. However it does not animate and the camera cannot be parented to another empty or object. (Correction - it can render an animated camera or imported camera, please read the update below)
Here's a video explaining how it works.
https://www.youtube.com/watch?v=ND8T5_VCcN0
I have tried installing it as a addon as described in the video but it didn't work for me, what worked is opening the python script directly in the scripting tab in Blender and then running the script. Following that you should be able to see the eeVR tab on the side of the viewport. You have to save the blend file for it to run and also it writes the renders in PNG and into the same folder of the of the blend file. Seams will appear if you turn on AO and bloom in Eevee. Turning on overscan will apparently fix the problem but I have yet to try it.
Guess I'll have to wait for the Blender developers to come out with a dedicated Panoramic renderer for EEVEE. Cycles is good but the render times just take way too long when time is limited.
Update after some experiments.
I have trying to use an imported alembic cache export from Maya and although I can see the camera animated, the VRrender script does not want to render from the camera. As explained earlier, this is a limitation in the script. I tried deleting all the cameras and used a single camera and the script automatically renders to that camera. I tried manually keyframe animating it and the renders correspond to the keyframed animation. Eventually I figured out from other forum posts that I can just duplicate the alembic exported camera, delete its alembic constraint, then apply a transform constraint to follow the alembic constraint camera. Following that I select the duplicated camera, then go to Object => Animation => Bake Action to bake the keyframes into every frame. In the Bake Action options, I turned on only Visual Keying and Clear Parents. My Camera animation had over 2700 frames so it took a while for the keys to be baked. This is the workaround I'll use until the official Panoramic EeVee render is available.


Constrain position of group of wiggling objects within another

Here i created points inside a torus using particle system and animated it using wiggle vector node. Using bvh trees we can find the points which are inside torus, the points outside is replaced with nearest surface point on the torus.
You can work more on nearest surface point to get more smooth animation.


Regarding the file attached try adding camera object to the scene, for some reason Freestyle lines render only if it's present.

It's probably a limitation however you won't be able to output an image without a camera regardless unless taking a screenshot of the preview render (although in Cycles Freestyle lines will be rendered only in the final aka F12 render so screenshot won't work as well).


This solution doesn't give you a perfect angle based control but it is sort of a better version of the pointiness value map.

You will have to download a daily 2.79 build from https://builder.blender.org/download/ to get access to the bevel node.

The viewer node is just an emission shader to view the value map.

You can tweak this map even further with a colorramp node of course.


Is it possible to display volume of a mesh object?

You can use the Print3D add-on for that. Activate it in user prefs (Ctrl-Alt-U) and it will appear in the Tool Shelf of the 3D View. Top line buttons let you calculate volume and total area.


I can't select "Armature" when adding a Track To constraint

You've clicked on the Object Constraints tab, where you could give a constraint to the whole armature, it's not what you want, what you want is the Bone Constraints. To have access to this tab you need to switch to Pose mode, select your bone, click on the right tab.


You can use modifiers for it in the graph editor tab.
https://docs.blender.org/manual/en/latest/editors/graph_editor/fcurves/modifiers.html


How do I make these facial tattoos without messing up the topology using nodes in cycles?

If you want to do this with Blender texture painting, use the stencil brush mode:

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

Stencil will allow you to "spray through" a 2D image to project it's patterns onto the mesh.

To back up to a more general sense, the way I'd approach this is to build the tattoos marks on a 2D sheet using your drawing/image editing tool of choice (Illustrator, GIMP, Photoshop, whatever). Then you can either use a projection tool (like Blender's stencil paint or the projection brush in Substance Painter) to spray the appropriate symbols into place. Symmetry can help you keep them even on each side. Alternately, you can lay the symbols into place in a 2D editor, but this requires a UV sheet free of distortion and with seams out of the way (such as the back of the head).

Doing this via a texture will also allow you to use a lower resolution face mesh, as you might find the one in your file tricky to weight paint and set up shape keys for.


How to set custom vertex normals for certain vertices using python?

Example of assigning custom normals based on vertex selection. It's just a slight modification of the code given in this answer and assigns a custom vector to vertices in selection.

Run the script in Object Mode and enable show_split_normal property in Edit Mode:

import bpy

context = bpy.context
ob = context.object
me = ob.data

me.use_auto_smooth = True

# Normal custom verts on each axis
me.normals_split_custom_set([(0, 0, 0) for l in me.loops])

# Set normal for selected vertices
normals = []
for v in me.vertices:
    if v.select:
    # if v.index in (0, 1, 4): # Alternatively you can ask for certain indices
        normals.append((0, 0, -0.5))
    else:
        normals.append(v.normal)

# make csn's all face up.
me.normals_split_custom_set_from_vertices(normals)

#me.free_normals_split()

Note: As of 2.8x show_split_normal property is part of the Overlays menu:


How to Tell if Object is No Longer in Camera View (bpy)

Yes there's an easy way, go to the BGE Documentation to look for more information. Since you dont specified if you are using bpy or bge i go for bge.

from bge import logic
cont = logic.getCurrentController()
cam = cont.owner

# Test point [0.0, 0.0, 0.0]
if (cam.pointInsideFrustum([0.0, 0.0, 0.0])):
  # Point is inside frustum !
  # Do something useful !
else:
  # Box is outside the frustum !


How can I enable in 2.8 an overlay of an object's local coordinate system?

How about adding an Empty that shows the arrows that you want, set its parent to the object, and then disable selectability (in the Outliner)?


Animation Nodes - How to make a series of waves

We start by creating a grid that is high resolution along the y axis and offset its vertices by some amount equal to a multiple of the sine of a multiple of the vertices' y locations. Since this is a grid, a float range should represent the y location of the vertices and thus we have:

Notice that the mesh morph into a rectangle when the multiple (offset amplitude) approaches zero. So, we are going to create a number of waves that moves and morph into rectangles in a delayed fashion. To do so, we use a loop that takes factors as iterator, this factor ranges between zero and one, where it is zero at the start of its animation and one at its end. We are going to modulate the amplitude of the offset based on the factors as follows:

Then, we are going to offset each wave by a certain amount. This amount depend on the factor as well as the index of the wave. The factor is used as a factor in mixing between zero (no offset) and some end value (max offset), the max offset is determined by a multiple of the inverse of the normalized index. The normalized index is computed by dividing the index by the number of iterations, the inverse is computed by computing one minus the normalized index, the multiple is computed by multiplying the number of iterations (waves) by their width to make them stack tightly.

Finally, the factors are generate by evaluating a delay falloff:

The speed and iterpolation can be adjusted from within the falloff node.


How to import bpy module in PyCharm IDE?

I don't have PyCharm on this machine, but have used it with Blender on my dev machine. So I can't detail the setup now - but for starters, see this dev doc regarding debugging Blender with Eclipse: https://wiki.blender.org/index.php/Dev:Doc/Tools/Debugging/Python_Eclipse

should be close enough for you to use with PyCharm (which is a custom eclipse). I presume you're okay with local (single machine) debugging - that's what I have setup in Eclipse/PyDev, tho in other Python work, I came across a browser-based setup that I adapted to PyDev - so now I debug Blender in the Browser - with the api docs in the 'tab next door' - very convenient.

if you're interested in remote debugging instead, see this recent dev blog entry: http://code.blender.org/2015/10/debugging-python-code-with-pycharm/

m23d


Parent with automatic weights problem in Blender

I found the solution! I had already parentet the mesh to the armature erlier. Later I flipped the names from L to R. Then I parentet it again, and it had still saved some of the old vertex groups. I deleted all the vertex groups, and now it works:)


Right sequences of the faces when constructing object with python

With trial and error I found that two faces with common edges should have these edges running in the opposite direction. So the faces should be

bm.faces.new((vlbu, vrbu, vrbd, vlbd))    #back
bm.faces.new((vrbu, vlbu, vlfu, vrfu))    #top
bm.faces.new((vrfu, vlfu, vlfd, vrfd))    #front
bm.faces.new((vlfd, vlbd, vrbd, vrfd))    #down
bm.faces.new((vlfu, vlbu, vlbd, vlfd))    #left
bm.faces.new((vrfu, vrfd, vrbd, vrbu))    #right

This gives the right normals.


Blender supports some physics simulation for rigid bodies, soft bodies, cloth and fluids. However these are not aimed at CAD applications, there are no tools to measure things like rotation speed and torque, and there is no guarantee that the simulation results will match the real world to some precision.

I think you need to use specialised CAD/CAM software for this.


Apply transformations does not work in automated process

Make sure that you actually need to apply transformations. If you are writing an exporter, multiplying the object.matrix_world by the vertex position gives you the transformed value without altering the original mesh.

In case you still need to do it, do what batFINGER suggested.


Why is my script to add large batches of objects so slow? v2.90

This is due to the material.
As all your objects share the same data, adding the material will add many material slots to the same data. This is visible in the material property of the object: give it a try with n = few objects.
You'll see, for each of them (as same data) n material slots added:

So, remove the line:
object.data.materials.append(mat)

If you want this mat, add it previously to the ico mesh data or add it once after the loop:
mesh.materials.append(mat)

30k objects should be around 1mn (depending on your configuration).


From the wikipedia wavefront obj page -

  The OBJ file format is a simple data-format that represents 3D geometry alone — namely, the position of each vertex, the UV position of each texture coordinate vertex, vertex normals, and the faces that make each polygon defined as a list of vertices, and texture vertices

If you look in the unreal docs under Managing content they only mention fbx as a format for importing static or skeletal meshes. Blender includes an fbx import/export addon, if you don't see the fbx export option then you will need to enable the addon.

There is also an addon available that eases the blender -> UE process, available on github.


How to quickly separate and/or delete extra faces created by extruding?

By now you are working with "edge" selection mode (2nd button on the header).

Just switch to "faces" mode (the third), select the face you want to delete, press X and choose the preferred option.

Try also the first button (vertex mode).

The fourth on the right lets you also select  vertex, edges or faces hidden by some other geometry.

Another useful function is select some faces, hit P> Selection, then exit edit mode (↹ Tab). The selected faces will be no longer be a part of your original object: they are a brand new object.

Additionally if you hit Y instead of P the selection will be separated from the original mesh while remaining part of the same object.


How to render from VSE, and not 3D scene?

Make sure, under your Render Properties in the Post Processing panel you have Sequencer checked.


Yes. What you can do is use the Search engine tool in the Outliner. Since various aspects of each object's Object Data (including materials) are listed in the Outliner, the Search engine tool will turn them up as results. Note that you may have to  MW scroll to bring the search bar into view.


While Shady Puck's answer covers making a true shadow-only render, here is my approach to creating this type of render using the Cycles Toon shader in combination with a shadow pass and some manual contrast adjustment.

My final result:

Thanks to MrChimp2313 for the awesome CC-0 house model!

First just give everything a white Toon shader material, this will help with that contrasty, cartoony look.  The Toon shader also has two other properties (besides color), you should set the Size to something fairly high (close to 1.0) and leave the Smooth at 0.0.

Light the scene with a single sun lamp, with a fairly small shadow size.  Tweak the direction and strength to suit your tastes for your scene.

Set the environment color to Black, this way the shadows and highlights will all come from the sun lamp.

Make sure to turn on the Shadow render pass and render your image.  Keep in mind that for this effect to work you need to eliminate as much noise as possible, so use a lot of samples.

In the compositor, run the shadow pass image itself through a Color Ramp node.  You can tweak the swatches' positions to get the effect you are looking for, but the basic idea is to have them fairly close together to get that super high-contrast shadowy look.  I also found it looks a little more pleasing if you adjust the minimum color to be not pure black.


Where is the smooth / flat shading property of an object?

The smooth/flat shading option is only applied per face and not per object. So there isn't a way of viewing the shading status of an object.

When you click 'Smooth' or 'Flat' shading while in object mode you are simply telling blender to smooth each individual face. You could go into edit mode and set smooth or flat shading on a selection of faces instead of the whole object, meaning: the object would have both smooth and flat shading.

You could create a python script which loops through the faces of an object and sees whether the majority are smooth or flat shaded by accessing the use_smooth property of a polygon (face) and seeing whether it is True or False.

You can access the use_smooth property via Mesh.polygons on a given object:

# test the first polygon of a certain mesh
>>> bpy.data.objects['ObjectName'].data.polygons[0].use_smooth
>>> True

# set the shading of all polygons to flat
for poly in bpy.context.object.data.polygons:
    poly.use_smooth = False


You can set a transparent material to the domain object (or whatever blocks the light!)