How to use a pivot point to mirror mesh with script

After reading gandalf3 comment all works!

import bpy

def areas_tuple():
    res = {}
    count = 0
    for area in bpy.context.screen.areas:
        res[area.type] = count
        count += 1
    return res

def get_region(area):
    res = None
    for region in area.regions:
        if region.type == 'VIEW_3D':
            res = region
            break
    return region

areas = areas_tuple()
view3d = bpy.context.screen.areas[areas['VIEW_3D']].spaces[0]
view3d.pivot_point='CURSOR'
view3d.cursor_location = (0.0, 0.0, 0.0)

bpy.ops.object.mode_set(mode = 'EDIT')
bpy.ops.mesh.select_all(action='SELECT')
override = {
    'window': bpy.context.window,
    'screen': bpy.context.screen,
    'area': area,
    'region': get_region(area)
    }

bpy.ops.transform.mirror(
    override,
    constraint_axis=(True, False, False),
    constraint_orientation='GLOBAL',
    proportional='DISABLED')
bpy.ops.mesh.flip_normals()


What was the first printed documentation for Blender?

I believe this one is way older and Ton signed it.


How to write controller to activate Blender Game Engine actuator?

Also you can controller.activate(actuator) like this:

logic.getCurrentController().activate(actuators['Steering'])


Particles dispersion from one object to another

You can add a curve guide to specify the path the particles will follow between the two objects.

Then for something fancy you can you can give the guide a braid kink to have it swirl around the curve on the way.


The setting controls how much energy the surface removes from a collision. The parameter can vary between 0.0 and 1.0 (you shouldn't set it outside that range) and a setting of 0.0 indicates no bounciness (all energy is removed). Increasing it up to 1.0 allows energy to remain after the collision.
Note that the collision energy is affected by both objects taking part in the collision so if either of the objects is set to 0.0 then no energy remains and there will be no 'bounce'. The Bounciness from both objects can be multiplied together to give a value of bounciness resulting in those objects colliding.
For example, for two objects each with a bounciness of 1.0, the result of a collision will have 1.0 x 1.0 = 1.0 (ie, all) of the energy before the collision. If either is zero then the result will be zero energy of their initial motion after the collision. For in-between values, the same holds - eg, if both have Bounciness of 0.8 then 0.8 x 0.8 = 0.64 of the energy will remain after the collision - ie, a ball would bounce 64% of the way back up from its starting height if it fell onto the surface.
In your case you likely have the other surface set to its default value of 0.0, resulting in no bounce (since anything multiplied by 0.0 is 0.0).


I'd like to have portions of a texture not glossy

Cycles
You can use a mix node with a black and white texture as the Factor:

Result:

Blender Internal:
This can be done in blender internal by adjusting the influence map texture in Properties > Textures > Influence:

Note that you must have Mirror enabled in the material for the map texture to influence reflections.
Result:

Creating a mask:
So for a building texture you could make a mask texture for all the windows in an external image editor, or you could try making the image with blender:

Add your texture as a background image:

Add a plane and edit it to match the windows:

Add two Array modifiers to the plane (one for each axis):

Position the camera so it points straight at the window array (see this post), and set the camera to Orthographic in Object data > Lens:

Set the output resolution to the same as the texture and adjust the Orthographic scale of the camera in Object data > Lens until the array object and the texture line up:

Give the object a pure black material and set the world color to pure white.

Render. (If you are using cycles, you may want to set the number of samples to 1, this will give a mask with only black and white.):

Save the image to a file (F3) You now have a mask image file you can use as an Image texture in a material.

Example material: (click for full size)

Notes:

You may want a little bit of diffuse reflection on the windows, so I added a Brightness Contrast node to make the black on the windows a dark gray, which will result in a mix of the glossy and diffuse shaders. You can think of this as each pixel in image containing a value between 0 (black) and 1 (white), which will set the Mix factor for that specific pixel.

You may also want some subtle displacement, as windows are rarely perfectly flat. I added a noise texture and multiplied it with the inverted map, so the noise texture is only on the windows. (the rest is white). This is then plugged into the Displacement socket.

Result:

Also see this tutorial on BlenderGuru.


Settings to improve animation render speed

You can consider using the Eevee render engine, which is much faster than Cycles.
It is less photo-realistic, but it seems to me that photo-realism is likely not a requirement for your logo.
To switch renderers, go to the Render Properties tab, and select "Eevee" in the Render Engine dropdown.


How can I keep blender from freezing whenever I try to render or bake a somewhat heavy scene in my no good very bad computer?

The most likely reason for such a crash is running out of memory - and for what you describe as a simple scene you should not be running out of memory.

In order to reduce the memory requirement for your scene you could try reducing the size of your textures, simplify your mesh, reduce the level of subdivision surface modifiers (there are separate settings for Preview and Render - check both) and check for other modifiers that generate geometry (for example, a Remesh modifier can easily become a problem if set too high).

Simplify the scene and objects until you get a working render and then start adding complexity again until you find the cause.


Yes, it's the single-faced walls. You have some places where there are 3 planes sharing one edge. The loop tool can't create a loop past these places.  You need to model those walls - the ones where you just have a single plane - like you've modelled most of them, as a U shape.


A way to export bezier curve with "bevel" (generated mesh) to a fbx mesh?

Make sure to enable "Other" in the export properties.


In the compositor you have plugged the 'Alpha' channel into the 'Image' output and the 'Z' channel into the 'Alpha' output. The image doesn't yet have an alpha channel (you just need to enable 'Transparent' under the 'Film' section of the 'Render' tab) and so the final image appears blank.

It looks like you may have just accidentally connected the alpha channel to the output, rather than wanting it, to output a normal image the connections should be:


Log Window

Example using an UIList based on the answer of Create an interface which is similar to the material list box as suggested in the comments. Removed all superfluous operators to get a kind of log window.

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

bl_info = {
    "name": "log-uilist-dev",
    "description": "",
    "author": "p2or, brockmann",
    "version": (0, 1),
    "blender": (2, 80, 0),
    "location": "Text Editor",
    "warning": "", # used for warning icon and text in addons panel
    "wiki_url": "",
    "tracker_url": "",
    "category": "Development"
}

import bpy

from bpy.props import (IntProperty,
                       BoolProperty,
                       StringProperty,
                       EnumProperty,
                       CollectionProperty)

from bpy.types import (Operator,
                       Panel,
                       PropertyGroup,
                       UIList)

# -------------------------------------------------------------------
#   Operators
# -------------------------------------------------------------------

class CUSTOM_OT_actions(Operator):
    """Move items up and down, add and remove"""
    bl_idname = "custom.list_action"
    bl_label = "List Actions"
    bl_description = "Move items up and down, add and remove"
    bl_options = {'REGISTER'}

    action: EnumProperty(
        items=(
            ('UP', "Up", ""),
            ('DOWN', "Down", ""),
            ('REMOVE', "Remove", ""),
            ('ADD', "Add", "")))

    list_item: StringProperty()

    def invoke(self, context, event):
        scn = context.scene
        idx = scn.custom_index

        try:
            item = scn.custom[idx]
        except IndexError:
            pass
        else:
            if self.action == 'DOWN' and idx < len(scn.custom) - 1:
                item_next = scn.custom[idx+1].name
                scn.custom.move(idx, idx+1)
                scn.custom_index += 1
                info = 'Item "%s" moved to position %d' % (item.name, scn.custom_index + 1)
                self.report({'INFO'}, info)

            elif self.action == 'UP' and idx >= 1:
                item_prev = scn.custom[idx-1].name
                scn.custom.move(idx, idx-1)
                scn.custom_index -= 1
                info = 'Item "%s" moved to position %d' % (item.name, scn.custom_index + 1)
                self.report({'INFO'}, info)

            elif self.action == 'REMOVE':
                info = 'Item "%s" removed from list' % (scn.custom[idx].name)
                scn.custom_index -= 1
                scn.custom.remove(idx)
                self.report({'INFO'}, info)

        if self.action == 'ADD':
            if self.list_item:
                item = scn.custom.add()
                item.name = self.list_item
                item.coll_id = len(scn.custom)
                scn.custom_index = len(scn.custom)-1
                info = '"%s" added to list' % (item.name)
                self.report({'INFO'}, info)

        return {"FINISHED"}

class CUSTOM_OT_clearList(Operator):
    """Clear all items of the list"""
    bl_idname = "custom.clear_list"
    bl_label = "Clear List"
    bl_description = "Clear all items of the list"
    bl_options = {'INTERNAL'}

    @classmethod
    def poll(cls, context):
        return bool(context.scene.custom)

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

    def execute(self, context):
        if bool(context.scene.custom):
            context.scene.custom.clear()
            self.report({'INFO'}, "All items removed")
        else:
            self.report({'INFO'}, "Nothing to remove")
        return{'FINISHED'}

# -------------------------------------------------------------------
#   Drawing
# -------------------------------------------------------------------

class CUSTOM_UL_items(UIList):
    def draw_item(self, context, layout, data, item, icon, active_data, active_propname, index):
        split = layout.split(factor=0.2)
        split.label(text="%d" % (index))
        #split.prop(item, "name", text="", emboss=False, translate=False, icon=custom_icon)
        split.label(text=item.name) # avoids renaming the item by accident

    def invoke(self, context, event):
        pass

class CUSTOM_PT_objectList(Panel):
    """Adds a custom panel to the TEXT_EDITOR"""
    bl_idname = 'TEXT_PT_my_panel'
    bl_space_type = "TEXT_EDITOR"
    bl_region_type = "UI"
    bl_label = "Log UIlist"

    def draw(self, context):
        layout = self.layout
        scn = bpy.context.scene

        rows = 7
        row = layout.row()
        row.template_list("CUSTOM_UL_items", "", scn, "custom", scn, "custom_index", rows=rows)

        row = layout.row()
        add = row.operator(CUSTOM_OT_actions.bl_idname, icon="ADD", text="Add Log Line")
        add.list_item = "Error %d" % (len(scn.custom))
        add.action = 'ADD'

        row = layout.row().operator("custom.clear_list", icon="X")

# -------------------------------------------------------------------
#   Collection
# -------------------------------------------------------------------

class CUSTOM_objectCollection(PropertyGroup):
    #name: StringProperty() -> Instantiated by default
    coll_type: StringProperty()
    coll_id: IntProperty()

# -------------------------------------------------------------------
#   Register & Unregister
# -------------------------------------------------------------------

classes = (
    CUSTOM_OT_actions,
    CUSTOM_OT_clearList,
    CUSTOM_UL_items,
    CUSTOM_objectCollection,
    CUSTOM_PT_objectList
)

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

    # Custom scene properties
    bpy.types.Scene.custom = CollectionProperty(type=CUSTOM_objectCollection)
    bpy.types.Scene.custom_index = IntProperty()

def unregister():
    from bpy.utils import unregister_class
    for cls in reversed(classes):
        unregister_class(cls)

    del bpy.types.Scene.custom
    del bpy.types.Scene.custom_index

if __name__ == "__main__":
    register()

Note: the naming of the classes and variables might be off a little.


Only one child light source for parent objects created multiple times

This solution, is called a FX lamp lending library.

Add a bunch of FX lamps like lamp1, lamp2, lamp3 etc,

Parent them to a object, name it LampFX, set each lamp energy to zero

Add a property in each lamp "Lamp"

Have the LampFX object run this (one time)

#build lamp list
import bge
cont = bge.logic.getCurrentController()
own = cont.owner

if "LampList" not in own:
    Lamps =[ ]
    index=0
    for child in own.children:
        if "Lamp" in child:
            Lamps.append([child, False])
            child['index'] =index
            index+=1

    own["LampList"] =Lamps

When a projectile is added to scene, use

added = own.scene.addObject("projectile", own, 0)
for Lamp in own.scene.objects["LampFX"]["LampList"]:
     if Lamp[1]==False:

         Lamp[0].worldPosition = added.worldPosition
         Lamp[0].setParent(added,0,1)
         Lamp[1] = True
         Lamp[0].energy = 1.0
         break

Now the lamp is "checked out"

Now, before the projectile is deleted, a script needs to put it back and check it back in, so another projectile can chexk it out again.

for child in projectile.children:
    if "Lamp" in child:
        own.scene.objects["LampFX"]["LampList"][child[index]][1] = False
        child.removeParent()
        child.energy =0.0

own.endObject()


How do I host my Blender-Made game so others can play online?

Creation and Build

Blender is a "creation tool". You can create Blender games (and the assets) as application with it.

Blender supports you in a way that it builds the application and data files that form your game. It is not designed to act as application server outside of the development pipeline (running the game embedded inside Blender, or starting it from within Blender).

Running

The user runs the game on his own starting the game as standalone application.

The usual way is to start the blenderplayer and feed it with a blend file which contains the game's data.

blenderplayer.exe myFancyGame.blend

For your service Blender can bundle the blenderplayer with such a blend file forming a application file (still needs the libraries).

myFancyGame.exe

Be aware: in this case all content of the application file (what is inside the blend file) has to be published under GPL as the blenderplayer is GPL (see Blender licence).

Publishing

Typically you somehow provide the user a way to get all the necessary files (blenderplayer/game file/blend file/linked assets). This can be a download/CD/stick or whatever. This is outside of Blender. There are other applications that help you on distribution (e.g. creating an installation file, hosting a download page, offering update service)

Distribution

If you want to create a multi-instance multiplayer game you need to split the game into different parts anyway. Each user gets a client that runs on the user's environment. These clients can connect to each other (peer-to-peer).

You can run one or more servers that help to connect (lobby) and synchronize (game server) the different game instances (client-server).

Each part (server, client) needs to be published separately as they are installed at separate environments.

When you want to run the central servers I suggest to look for some third-party-services to help you on that. Blender can provide the application, but not the application server - not even a website. That is outside of the scope of Blender and outside of the scope of this answer.

Remark: this is an architecture decision. You create the client with Blender (or other tools) you can create the server with Blender (or other tools) as long as they can communicate with each other.

Running embedded

This is a followup from the comments.

You can run your game embedded inside Blender. This is typically part of the development process.

The average user does not want to start Blender, load a blend file and run the game from there, specially as it is possible to break something while having the blend file open.

Nevertheless it is possible to run your game embedded. You might even support the user with auto start script (starting the game when opening Blender).

This means Blender is part of your game (you need to deliver Blender and the game assets).

The advantage would be that the Blender API (bpy) is available. Be aware this still does manipulate Blender data rather than data of a running BGE game.

You could use this option to run your server. This way the end-user does not see Blender just the individual client. The clients can be the usual BGE applications.


Okay, I can't post any images right now.  However, it's pretty basic what I did, so let me explain real quick.  I actually got the general idea from a great YouTube tutorial author that I watch, Sardi Pax.

I have a scene with a plane for the ground.  I put a hair particle system all across the plane.  I then went to another layer and created five ICOSphere "rocks" and applied a Noise and the Voronoi textures used for displacement mappings(set the material's settings section tab displacement flag to true after enabling "Experimental").  Then I tweaked these displacements to make the rocks look different.  I also applied a simple deform modifier with an empty to each rock to get unique shapes for them.  Then I Object grouped(CTRL+G) the rocks on that separate layer together.  Then I went back to my original layer with the plane and then used the rocks group as the hair particle system's display property.  I also created vertex groups on my plane(randomly selected).  Then I applied the rocks(with pick random from group selection in the particle's properties, so it would pick random rocks for me from the rock object group) to the plane's vertex groups that I created.  And since I put the rocks at 0 on the Z-axis on the other layer the rocks look buried in the plane's "dirt", pretty neat.   This gave me a decent spread across the plane of random rocks that didn't appear to be too repetitious.  I hope this makes sense, I'll try to post images later.


Find angles between list of sorted vertices using vertex.co.angle()

Vert co as a vector is from origin point.

Diagram where the red ico is the origin of a mesh and the other icos are the vertices.
Question code is calculating the angle designated as alpha above between the vectors defined by the  two vertex coordinates.
It appears you are after (beta) the angle between the vector made from two verts
vec = verts[i].co - verts[i - 1].co

and the x axis Vector((1, 0, 0)).angle(vec) or if the points do not all lie on same XZ plane, the projection of vec onto the XY plane containing point    verts[i - 1].co.
Example from python console, consider vec = Vector((1, 1, 1))  ie this is the result when subtracting i-1th vert from ith. Meaning if you travel (1, 1, 1) from vert[i-1] you will be at the location of vert[i]
>>> vec = Vector((1, 1, 1))
>>> x_axis = Vector((1, 0, 0))

Angle between 3d vectors
>>> degrees(x_axis.angle(vec))
54.735612876297274

To project as 2d vectors onto Y=constant plane, can get the signed angle between the 2d vectors ignoring y.
>>> degrees(x_axis.xz.angle_signed(vec.xz))
-45.00000125223908


You can use the ColorRamp to visually modify the attenuation across space.

What the setup does is "normalize" the ray length to make the max length you want to control equal to 1.

In the following image, the plane is exactly 5x5, so the falloff should be 2.5 units in order for the light to go off exactly before it reaches the edge.

Reasoning

The ColorRamp factor input takes values between 0 and 1 while the ray length is in absolute blender units (length). So in order to use the ColorRamp we need to bring down the maximum ray length we want to control to correspond to 1. So, let's say we want to shine light up to 10 meters (or units), we'd need to divide Ray Length by 10, so that the end of the ColorRamp corresponds to 10 meters from the light source.

The ColorRamp then assigns a color to each ray depending on their length. This result (which is a color - different for each ray) is plugged into the Emission color node so that we can pass color information in addition to strength.

We still need to make the light falloff constant so that the default attenuation does not interfere (multiply) with the our gradient. So we plug in the Constant output of a Light Falloff node into the Emission Strength input.

In the final setup, we control the distance by modifying the division value (2.500 in the screenshot above) and the strength by tweaking the Strength input (100.000) of the Light Falloff node.

Credits:

Using the additional info from cegaton's answer and Booth's edited question, I have edited this answer to be correct and complete. If the reader wants to see how we got here, visit the history


Accidentally deleted nodes in compositing tab. Can't recover it?

Do not worry, this looks easy to fix, even if this diagnosis is wrong.
The image looks like render passes that were previously enabled have been turned off, and thus aren't showing up in the render layer node. Check this manual page for information on render passes. https://docs.blender.org/manual/en/dev/render/layers/passes.html


How do I have an exception to a material override?

You can use the Pass Index to indicate to the material how to treat specific objects in your scene.
For those objects you want highlighting, set the Pass Index to a specific value (in this case, '1') :

In your material, use the Object Info node to get the Object Index and compare it to determine how to shade your object (in this case I've used the result of the compare to choose between colours in a MixRGB node) :

This produces the following result (with the cube set to index '1' and everything else left at index '0') :

To change the highlighted object, simply update the Pass Index to disable the previously highlighted one and enable the new one.


Extrude edges (or a curve) using an offset/inset to create a mitred patch of faces?

Start with your shape:

Select all the edges and extrude along the Z axis:

Select all the faces, right click and choose "Extrude Faces Along Normals". You can drag the mouse or enter a numerical value - if you want it inwards, use a negative value (ex: -0.5).

After extruding along normals, make sure to check "offset even" in the operator panel.

Next, select the whole mesh and flatten it by scaling to 0 on the Z axis (S + Z + 0).
This will leave some duplicate vertices (as the top and bottom faces are now "flattened" on top of each other). Select the whole mesh, and pick Mesh > Clean Up > Merge By Distance to clean it up.

Now you have your shape:


Use an object change to trigger Python script

A quick and dirty solution would be to use a scene_update_post handler.

Event handler access in Blender.

import bpy
def my_handler(scene):
    cursorLoc = bpy.context.scene.cursor_location
    # do something
    print(cursorLoc)

bpy.app.handlers.scene_update_post.append(my_handler)

Run the script once, then your function will be called as soon as the scene updates.

This is highly inefficient and will affect the performance depending on the design of the script. It provides an easy solution though and Blender was always fast enough for me to not notice a difference.


Painting in 3D window shows up on the other side of my model from where I paint

It's a Normals issue, in 2.8, in Edit mode, select all and shiftN to recalculate the normals


How to unlink a material only from a linked object?

If it's a mesh object, it might be that your material is linked to the mesh (the data), not the object. Try this structure: Two different objects, both of which use the same mesh. The materials are linked to the objects instead of the mesh. Then you have an object identical in shape, but different in color.

You can set the type of link to the right of the material name.


Shadow ray is the last segment on the light path traveling through the scene (from camera to light source). It is just a technical term, only a label. In nutshell it marks anything that goes to light.

When the light path begins, it starts as a camera ray, when its reflected it becomes reflection ray, when it goes through glass it becomes transmission ray and from the last point to lamp it is shadow ray. These are the base 4 types of rays in cycles (they divide more into diffuse, glossy etc. also).

With Light Path node and Shadow rays, you can for example color shadows to some tint of your liking. Here the object will be transparent and blue for the shadow part of path but opaque and green for the rest of it:

Note: In 2.75 rendering colored shadows from transparent objects is buggy - when adding Transparent BSDF in rendered viewport the shadow won't be colored - you need to restart the render-viewport (on CPU and GPU).


How to copy animation keyframes from one skeleton to an identical?

You need to create at least one keyframe to be able to paste, so copy the pose you want on the character on the right, select all the bones of the character on the left, create one pose, then paste. Or you could also select the same action, duplicate it and delete all the keyframes you don't want.


Downloaded Model Is Purple - Image Texturing

As Jachym Michal already mentioned, the Blender-friendly textures are in HS015.fbm.zip. Just extract them into a folder. In Blender, use the menu entry File → External Data → Find Missing Files to get the correct path.
After this, you need to fix the transparency, and the Roughness and Specular values. They are a bit messed up.

Yes, the model comes with Shapekeys :-)
Transparency
The materials in the FBX file use the base (diffuse) color for the Alpha slot. That's wrong. The images have an Alpha mask. So just remove the wrong Image Texture node and plug in the Alpha output from the Image Texture into the Alpha slot of the Principled BSDF node.
In the Material Properties > Settings set Blend Mode to Alpha Hashed.
You need to do this for the cloth, the body, the eyes, the hair, the eyelashes, the tear line, the eye's fake AO (CC_Base_EyeOcclusion). Each eye has its own material slot.
Roughness and Specular
for most materials you can go with the default Specular value of 0.5 and adjust the Roughness value

use a low Roughness value 0.1 and default Specular value 0.5 for the eyes and tear line to give them a reflection
a little more Roughness 0.3 to 0.4 for teeth and the wet tongue for reflection
increase the Specular value for the hair a little (0.15) so there is some sheen in the light
for the skin, you can use the "MetallicAlpha" and "SpecMask" from the Textures.zip file and control with them the Roughness value. This way the nose holes are not shiny but black. Note: Use the Alpha output from the "MetallicAlpha" images. A Specular value of 0.3-0.4 is fine.

Subsurface Scattering
use a little for the skin to make it look more realistic and more "skinny". For testing, I use the "SSS" mask from Textures.zip. But I think you can use a plain color in Eevee. The body below the neck uses a plain SSS color, the arms are unchanged and have no SSS and no roughness (see the first image).


How do I place the "follow active quads" results against the UV Grid?

You need to reset the UV coordinates, before using Follow active quads.
I don't know why :).

Select the faces (Ctrl+L to select the whole island)
Go UV > Reset to clear the UV coordinates
Unwrap through UV > Follow Active quads.


How do I fade in/out an object in Blender 2.8 Eevee?

Of course it is. The only "catch" is to change Blend Mode under Material > Settings tab to Alpha Blend and turn off Show Backface.

Then regularly you can animate Factor between your shader and Transparent shader (full white colour).


Extrude individual doesn't work for edges?

Like David suggested, use E to Extrude and switch to Scaling by hitting S:

(Extrusion started from the inner, unselected edge ring)

Or are you after unconnected edge rings?

They were created by using ShiftD to Duplicate.


Not sure if feasible for your project, but you could parent all your objects in the scene to an empty and move the empty instead of the camera.
Also, turn on motion blur in your render settings and turn it off for the individual objects that you don't want blurred. (In the Object Properties Panel)


Weight paint and mesh are mirrored, weight paint color seems right, but vertices are left behind

Ok, looks like it was because I had wrong weight painting in the pelvis bone. Not sure how it ended up painting the right arm, but now it's fixed.


Why does textures work with the default cube, but not with any new cube I add?

Okay, here's how we unwrap a cube so that we don't get any whonky image output when we view the image mapped onto it.

Option A

Go into edit mode, select the entire mesh, and then hit U > Cube projection. This is what to do if you want the same texture on every face, which is what I assume you are going for. However! if this is not wht you are going for, there is always ...

Option B

So who here has seen a baseball? Raises hand "me!..Me!"
You know how those two white panels are stitched together interlockish-ly? how if you were to cut the red seams they'd Pop out and you could lay them flat? That is what we do when we unwrap things, but we still need seams.

If your cube were made out of paper, and you folded it to get it into a cube shape, what did the paper look like before it was folded?

Like this maybe?

Well, what you need to do, is select all the edges that need to be seams and Ctrl +  E > Mark Seam. this will make them BRIGHT RED!!!!
It also means that those edges are now like the seams on a baseball, and all you have to do is U > Unwrap.


ImportError when loading Open3D module into Blender python console

After several attempts, I found a solution. In order to fix the ImportError, install Open3D v0.4.0.0:

pip3 install open3d-python==0.4.0.0

Note that the package name has changed: use open3d-python instead of open3d. Probably, the latest versions of Open3D have some bugs (see also this Open3D issue).


The denoiser is a wonderful part of the cycles render process. It runs after the tile has rendered, but during the render process. It takes information about the scene and calculations cycles makes to turn a noisy image into a remarkably smooth render.
Because it is part of the render process it works better then any filter you could throw on the image after the fact.

This image was render at 10 samples, with the denoiser on at default settings. Notice even the shadows are smooth.

Now here is the exact same render, but without the denoiser. (click for full size to see the difference)

The denoiser is at the bottom of the render layers tab in the properties window. Simply check the checkbox and open up the Denoising section.

Now given that you are not using Progressive Refine, and have blender 2.79 or higher then you are all set.

The three main settings are Radius, Strength, and Feature Strength.

Radius is how far the denoiser looks around each pixel.
Strength think of this as the strength of the over all denoising filter. Lower numbers are sharp (noisy) image, a value of one is full denoising (can kill small details).
Feature Strength controls the strength of a pre-filter, before the denoiser works its magic. Here again low values equal more detail, and a value of one is full strength.

The manual page for the denoiser. The release notes from 2.79.

Note that Denoising will use a lot more resources from your computer and might even yield out of memory errors. Denoising needs the information of all of the adjacent rendered tiles to work, meaning that for every tile being rendered blender will keep in RAM the information of all the surrounding tiles and will only release that ram once a tile has been denoised.


￼Shamelessly modified from:
Automatically change the properties of multiple materials
import bpy
for mat in bpy.data.materials:
    if not mat.use_nodes:
        mat.metallic = 1
        continue
    for n in mat.node_tree.nodes:
        if n.type == 'BSDF_PRINCIPLED':
            n.inputs["Metallic"].default_value = 1


The way i was dealing with input was not correct i needed to use the more advanced invoke and modal options to get the desired results.
https://docs.blender.org/api/2.90/bpy.types.Operator.html?highlight=operator#module-bpy.types.Operator
Here is the updated code:
import bpy

class PS_Remesh(bpy.types.Operator):
    bl_idname = "ps.remesh"
    bl_label = "Remesh"

    def execute(self, context):
        if context.active_object is None:
            print("Active object == none: Cancel")
            return {'CANCELLED'}
        else:
            bpy.ops.object.voxel_remesh()
            return {'FINISHED'}

class PS_MaskBrush(bpy.types.Operator):
    bl_idname = "ps.mask_brush" #use this as the pie.operator("ps.remesh") to use in pie menu
    bl_label = "Mask Brush"

    def execute(self, context):
        if context.active_object is None:
            print("Active object == none: Cancel")
            return {'CANCELLED'}
        elif context.mode == 'SCULPT':
            print("In sculpt mode sculpt mode select mask brush")
            bpy.ops.wm.tool_set_by_id(name="builtin_brush.Mask",space_type="VIEW_3D")
            return {'FINISHED'}
        elif context.mode != 'SCULPT':
            print("Not in sculpt mode sculpt mode activate")
            bpy.ops.object.mode_set(mode='SCULPT')
            bpy.ops.wm.tool_set_by_id(name="builtin_brush.Mask", space_type="VIEW_3D")
            return {'FINISHED'}

class VIEW3D_MT_pie_sculpt(bpy.types.Menu):
    # label is displayed at the center of the pie menu.
    bl_label = "Pie Sculpt"

    def draw(self, context):
        pie = self.layout.menu_pie()
        pie.operator("ps.remesh", text = "Remesh", icon="BLENDER")
        pie.operator("ps.mask_brush", text="Mask Brush", icon="BLENDER")

def register():
    bpy.utils.register_class(PS_Remesh)
    bpy.utils.register_class(PS_MaskBrush)
    bpy.utils.register_class(VIEW3D_MT_pie_sculpt)

def unregister():
    bpy.utils.unregister_class(PS_Remesh)
    bpy.utils.unregister_class(PS_MaskBrush)
    bpy.utils.unregister_class(VIEW3D_MT_pie_sculpt)

if __name__ == "__main__":
    register()

    bpy.ops.wm.call_menu_pie(name="VIEW3D_MT_pie_sculpt")


Try checking the start and end frames of the particles, and the frame you are rendering.

Also check the Object Particle Size

Also check the particles render option to see if Emiter is set to Render


Why won't any faces show up in the UV Image Editor?

You have 'UV Local View' turned on in the image editor. Go to the image editor and then View> UV Local View to turn it off:

I'm don't fully understand this feature but it seems to be mostly used for Blender Internal and not Cycles. There is a small discussion about it here:

https://developer.blender.org/T43042


If you want to stay with only one object:

Use bevel tool and extrusion

In Edit mode, after selecting all the edge where your tiny gap will apear, press Ctrl+B you will separate your edge in two edges, you can set the distance between them by moving your mouse or after that using the Amout value in the Bevel menu on the Left of the 3D view.

After that simply extrude the newly created face with E inside your mesh.

If you want to separate your mesh to work withtwo objects :

Separate

Select all the upper part of the phone and press P and select 'Selection'. You will need to do some scale modification to your object.


This is not exactly how to do it, but you can try to reduce alpha transparency of your glass object and adjust your Alpha Threshold value on View Layer settings. Just after that you can use cryptomatte object to pick the light.


Probably your camera clipping region is too narrow?

Try adjusting it from the Camera Properties > Lens menu

(You can check if the limits are big enough to encompass your scene by enabling Viewport display > Limits: see below)

P.S. I don't know what scene you have in mind, but from your screenshot it looks like your backdrop is veery big. Scaling everything down with respect to the world origin could be an option and wouldn't require changing the clipping distance.


Does parenting object A to object B mean A is the parent or is it the other way around?

When parenting an object. The object most recently selected will become the parent. And the other objects will be childs. For example, if you selected object "B" first, and then object "A" last, object "A" would be the parent, and object "B" would be the child.


Why is my object lying on the surface when I export file as OBJ?

On the left side of the exporter window, there is an option for it.


How can I make a custom IK arm rig on an already made Auto Rig Pro rig

I guess you already found your answer but maybe other peoples will need this too.
Here is one way to do :
Once you have your rig, go into pose mode and select the rectangle part of the hand.
Then on the panel on the upper right of the screen go to "tool"

Under Rig Main Properties you have "IK-FK Switch". 1 = FK ; 0 = IK
So if you want IK, switch it to O. I hope this will help.


How are the creases/folds in this mesh for a sofa achieved?

If you would like to achieve this effect with SCULPTING in Blender, a method that would definitely assist you is going to Sculpting >> Tools >> Crease  or using Blender's new Cloth Brushes.
Doing this without sculpting is also probably achievable, you will have to manually tweak the mesh to either pull or push vertices/faces to match the reference.
You also have the option to apply a normal map that has creases but personally I would find that a bit more tidious to do in Blender and would probably still require you to sculpt and bake the map yourself.


modifier subdivision surface not working

Uncheck "simplify" in the render settings:


Chroma key and a few images for background

You can use Maths nodes to set up logic that allows you to select an image based on an input and this can be used instead of the image sequence or video. For example, consider the following nodes :

The images are set in each of the Image nodes highlighted. To corresponding Greater Than nodes should each have incremental values and these will control the Mix such that subsequent images are selected as the input Value is increased. ie, Value less than or equal to 1 selects the first image, less than or equal to 2 selects the second image, 3 the third image, etc. Continue the chain for as many images as you require.

All that is now required is to keyframe the input Value so that it selects the relevant image for the frame in your animation.


I understand your problem.

When you load your script as an addon, it reads the scripts when loading blender. Thus the scripts register the the bpy.context.active_object = the active object when the addon is loader. Thus it does not point to the actual bpy.context.active_object when you run the operator.

For instance your makeLink(var1, var2, var3, var4): reference the link object which is the link of the node_three of the material of the active object when the addons was enable. Which may be not the one you want to modify. I hope your understand your mistake.

To solve your problem, you need to modify every function you made to be context sensitive. For instance, your main function should take as argument the context variable of the operator. (BTW the main class should'nt be a class but a functon, i.e. def main(...) instead of class main() ).

Then in the main function you should now declare the the mat_name, the node_tree, the links,... (everything that you declare at the beginning of your script)

def main(context):
    mat_name = context.active_object.active_material.name
    mat = (bpy.data.materials.get(mat_name) or bpy.data.materials.new(mat_name))
    mat.use_nodes = True

    nt = mat.node_tree
    nodes = nt.nodes
    links = nt.links

    while (nodes): nodes.remove(nodes[0])

    createNodes(nodes)
    ...

But then you also need to modify every function you have since the need to point to the correct variable. For instance the make link should be:

def makeLink(links, var1, var2, var3, var4):
    """
    Creates a link between a Material Node's output,
    and another Material Node's input.
    args follow the order: Output Node Name, Socket Name, Input Node Name, Socket Name
    """

    links.new(var1.inputs[var2], var3.outputs[var4])

def createNodes(nodes):
    link = nodes.link;
    output = nodes.new("ShaderNodeOutputMaterial")
    principled = nodes.new ("ShaderNodeBsdfPrincipled")
    mapping = nodes.new("ShaderNodeMapping")
    texCoord = nodes.new("ShaderNodeTexCoord")
    colorMap = nodes.new("ShaderNodeTexImage")
    normalMap = nodes.new("ShaderNodeTexImage")
    roughMap = nodes.new("ShaderNodeTexImage")#.color_space = 'NONE'

    mainTexCoord = [ node for node in mat.node_tree.nodes if node.bl_idname=="ShaderNodeTexCoord"]
    # python list comprehension filters the list of nodes down to the ones that match the right bl_idname
    texCoordinateNode = mainTexCoord[0]

    #Image Texture Node Image
    colorMap.image = bpy.data.images.load(image_path)
    normalMap.image = bpy.data.images.load(image_path2)
    roughMap.image = bpy.data.images.load(image_path2)

    makeLink(output, 'Surface', principled, 'BSDF')
    makeLink(mapping, 'Vector', texCoordinateNode, 'UV')

    makeLink(principled, 'Base Color', colorMap, 'Color')
    makeLink(colorMap, 'Vector', mapping, 'Vector')

    makeLink(principled, 'Normal', normalMap, 'Color')
    makeLink(normalMap, 'Vector', mapping, 'Vector')

    makeLink(principled, "Metallic", roughMap, 'Color')
    makeLink(roughMap, 'Vector', mapping, 'Vector')

Then the operator should be like this:

class QuickLayout(bpy.types.Operator):
    """Tooltip"""
    bl_idname = "myops.quick_layout"
    bl_label = "Quick PBR Layout"
    def execute(self, context):
        main(context)
        self.report({'INFO'}, "Layout Complete!")
        return {'FINISHED'}

I hope you understood where the problem was.

Cheers


I have checked out the video, and I recommend moving one of the cubes a tiny bit so that faces are not directly overlapping. That has caused this kind of thing before.


Cycles: Generate 3d coordinates before modifier stack is resolved

It can be done!

Approaching it on a Surface

Before we try to do this with a 3-dimensional texture, let's attempt it in 2-dimensions. This is actually fairly straightforward. We can create a proxy mesh by duplicating our object (Shift + D), removing the modifiers from our duplicated object, then setting the Texture Mesh setting for our original object to the mesh of the second object:

Result:

Hey, that works perfectly! Unfortunately, it doesn't work for 3D textures. When we attempt this with a volumetric texture it does absolutely nothing.

Approaching it in a Volume

The best way to do this in a volume (believe me, I've tested others) is to create a proxy mesh, then take the coordinates from the proxy mesh.

What should our proxy mesh look like?

Unfortunately, Blender does not provide an easy way to transfer volumetric data on and off of meshes. Our saving grace is the Point Density node in Cycles. The Point Density node will create a volumetric texture based off of the vertices of any mesh, and interpolate between them. It follows, then, that our coordinate proxy mesh should be a 3D grid of points.

Creating the proxy mesh

We'll start by adding a plane, then in Edit Mode, moving and scaling it so it has the same size and location of the bottom of the cylinder's bounding box (in the image, I enabled the bounding box display):

Next, we need to have more points in our coordinate grid. Use the Loop Cut tool (Ctrl + R) to add lots of loop cuts in both directions, trying to make the faces roughly square (I did $63$ and $15$, to get a $64\times16$ grid:

Next, in Object Mode add an Array modifier. Use Constant Offset in the $Z$ direction to create a "stack" of planes (I used an offset of $0.125$). Add enough planes to fill the bounding box of the cylinder:

Apply the Array modifier and add a Curve modifier. Set up the Curve modifier the same way that it is set up on the cylinder. Check to make sure everything deforms properly (proxy mesh set to Wireframe display):

Now the hard part:

Creating a coordinate system

The Point Density node can only take color from Vertex Colors, Weights, and Normals. By far the most customizable of these options is Vertex Colors. We need to find a way to put Texture Coordinates into Vertex Colors.

Let's use Animation Nodes! After downloading and installing the add-on, go into the Node Editor and add a new NodeTree.

Before we start adding nodes, we need to figure out how to emulate Generated texture coordinates. According to the Blender Manual:

  Generated
  Automatically-generated texture coordinates from the vertex positions of the mesh without deformation, keeping them sticking to the surface under animation. Range from 0.0 to 1. 0 over the bounding box of the undeformed mesh.

This means we need to normalize the vectors representing the positions of our vertices and put them in the positive-positive-positive octant. Here is the formula we will use:

$$\mathbf p'=\frac{\mathbf p - \mathbf c}{\mathbf d} + \mathbf{0.5}$$

where $\mathbf p$ is a point in 3D space, $\mathbf c$ is the center of the bounding box, and $\mathbf d$ is the vector of the longest diagonal of the bounding box (i.e. the dimensions).

Let's get our inputs first. Add the following nodes (press Shift + A to bring up the list of nodes or Ctrl + A to search):

The object in the Object Input node is our coordinate proxy object. The text in the Object Attribute node is dimensions. Note that "Use Modifiers" is unchecked. This ensures that the coordinates we get don't include the Curve modifier. Next, we'll use Vector Math nodes to implement the above formula:

The Convert node will be added automatically. We have one more issue with the texture coordinates: texture coordinates are encoded in a linear color space, while Vertex Colors are encoded in sRGB. From the linked Wikipedia page, we get the formula for encoding colors in sRGB:

  $$C_\text{srgb}=\begin{cases}
12.92C_\text{linear}, & C_\text{linear} \leq 0.0031308\\
1.055C_\text{linear}^{1/2.4}-0.055, & C_\text{linear} > 0.0031308
\end{cases}$$

To utilize this, create a loop subprogram by adding a Loop Input node. Create this loop:

The numbers are truncated in the screenshot. Here they are, row by row:

0.003131
12.92
0.416667  1.055  0.055

Now, add 3 Invoke Subprogram nodes with Separate and Combine Vector nodes to encode the $R$, $G$, and $B$ channels.

Now, we need to get our vectors into a Vertex Color. @Omar Ahmed has already made fabulous explanation of how to do this. You can find his answer here. I will copy the relevant parts below, but I recommend reading his answer for a detailed (and illustrated!) explanation of how Vertex Colors work in Blender.

First, create this loop:

Then, create this script (make sure to name things properly):

Here is the script:

#Create a vertex color map named "Normals" if it is not already created.
if "Coords" in Object.data.vertex_colors:
    map = Object.data.vertex_colors["Coords"]
else:
    map = Object.data.vertex_colors.new("Coords")

#Loop over Colors and assign them to the vertex color map.
for i, color in enumerate(Colors):
    map.data[i].color = color

Finally, link up the last nodes (for an explanation of how they work, see the answer linked above). Here's the final tree:

Getting the coordinate system into Cycles

We will be using the Point Density node as I mentioned above. On the Cylinder object, create a new material. Add a Point Density node. Set it to Object Vertices, with the Coordinate Proxy as the object and the Color Source as Vertex Color. Choose the Coords Vertex Color. Next, disable visibility for the proxy object, and link the Color output of the Point Density node to an Emission node plugged into the Volume socket of the material output (in the picture I'm using the Node Wrangler add-on to get an Emission node):

Activate Rendered View in the viewport (Shift + Z). Position the 3D View so that you are looking at one of the "caps" of the cylinder. Adjust the Radius parameter of the Point Density node to be just big enough that there are no "gaps" ($0.1$ worked for me):

Now we have our coordinates! Use the Color output just like you would normal texture coordinates, and volumetric texture-ize away!

Just remember that anything you do to animate the cylinder also needs to be done to the proxy.

(Requires Animation Nodes)


first download this addon https://github.com/Radivarig/UvSquares to install it open blender and go to file, preferences, addons, install from file and seek and select the zip file that you downloaded and then click open-accept and then check the the lithe box that will appear when it loads and then save user preferences, then see how to use it with this pictures... and dont forget to scale it to fit it well in the whole uv map area.


Fluid mesh isn't showing in Mantaflow simulation

Figured out that I had set my domain to display as bounds in its object properties. Duh


why grid lines + scale doesn't update, when controlled via python console?

Difference between a class and an instance.

bpy.types.SpaceView3D is a class, it has a grid_lines property. The blender UI has a window, made up of screens, made up of areas, within each area an active space (what you see in that area). The active space in a view 3d area is an instance of the bpy.types.SpaceView3D class.

Running this code in the text editor will change all 3d view spaces grid lines to 10 and scale to 2

import bpy

for screen in bpy.data.screens:
    for area in screen.areas:
        if area.type == 'VIEW_3D':
            area.spaces.active.grid_lines = 10
            area.spaces.active.grid_scale = 2

in the python console the active space is not a 3d view area, rather a python console.  Similar to above but in console

>>> type(C.space_data)
<class 'bpy.types.SpaceConsole'>

>>> for i, a in enumerate(C.screen.areas):
...     i, a.type
...
(0, 'INFO')
(1, 'PROPERTIES')
(2, 'CONSOLE')
(3, 'VIEW_3D')
(4, 'TEXT_EDITOR')

>>> space3d = C.screen.areas[3].spaces.active
>>> type(space3d)
<class 'bpy.types.SpaceView3D'>

>>> space3d.grid_lines = 10

If the code is invoked, via a button or menu (for example),  in the context of the 3d view, then the 3D VIEW space would also be context.space_data


I'm running Luxrender 1.6 fine on both my Linux machine and the Windows one with LuxCore API. However, it can be tricky to set it up correctly. I can imagine two scenarios where the LuxCore API won't show up:

You have installed Luxrender correctly, but forgot to update the LuxBlend plugin. Remember that the Luxrender installer does not do this automatically for you. The Luxrender version and LuxBlend plugin really need to be of the same installer, they break compatibility very quickly.
You are trying to use the Luxrender OpenCL installer, but your system doesn't support it (that was the issue on my linux machine)

If it is 1., then you can open up Blender, go to User Preferences -> Addons, find the LuxRender plugin, and remove it completely from your system. Then, Save your User Prefs, quit Blender and restart. This ensures that when you install the new version, the Python cache will for sure be regenerated. Now install the Plugin, you can find it in the Programs folder where you installed Luxrender to. So again, User Preferences, Addons, 'Install from File', and point to your folder/Luxrender/LuxBlend.zip. It should look like this on Windows:

You should now see the addon and be able to activate it. Set the Path to your Luxrender installation correctly, Save User settings, and restart. Note from the screenshot the plugin version:

With the newest plugins, they also added a 'Update LuxBlend' button. At the moment I recommend using it, because then the 'Opactiy' option for area lights will show up, but that's a topic you can find on the LuxRender forum.

In case of 2.: Uninstall Luxrender, Download the non-open-cl package, and try that.


ALT select edges in Edge Mode, and X - dissolve.

Update: In response to your Sub-div issue. Instead of just removing geometry, you might look at how you are modeling. In the example below I have made the windows edge loops. The one on the left is all quads, and the one on the right has one N-gon in the window - if you don't mind N-gons. The advantage of this geometry can be noted on the sides [top & bottom] where less faces are needed.


Why will Blender render the transparent area with shadow catcher on?

As far as I know Cycles still does not have adaptive sampling, so this is how it is for now. I believe this feature is always 'coming to Blender any time now' for a few years now. You can use border rendering to only render part of the frame.


First some information: (skip if tl;dr)
For matrices in general the inverse should actually be what you are looking for, since the inverse of a matrix exactly undoes the transformation of the matrix. And (at least in 3D) for orthonormal matrices (1) like the rotation matrix the inverse is equal to the transposed matrix. Since transposing a matrix is much faster than inverting it, I would use the transposed matrix in this case.

However matrix_world is the so-called World-Matrix, which does not only contain the object's rotation but also its translation and scale. Furthermore it is a matrix that works in 4D homogenuous coordinates, which are often used in computer graphics because they allow you to perform translations and perspective transformations with matrices. You can usualy not work with this matrix directly.

(1) matrices whose column vectors are normalized and orthogonal to each other

The solution:
You were on the right track with decompose. However decompose gives you the rotation as a Quaternion, not as a rotation matrix. But you can invert quaternions as well and use them for your calculation.
If you really need a matrix you can convert the quaternion to a matrix by calling mathutils.Quaternion.to_matrix(). This will give you a 3D matrix which you can invert or transpose to get what you want.

And this is how you can get all that stuff:

o = bpy.context.scene.objects['Cube']  # use your object name here
# calculate the translation, rotation and scale
t, r, s = o.matrix_world.decompose()
# calculate the inverse quaternion
r_inv = r.inverted()
# calculate the rotation matrix from the quaternion
r_mat = r.to_matrix()
# calculate the inverse rotation matrix
r_mat_inv = r_mat.inverted()
# calculate the transposed rotation matrix which is the same as the inverted
r_mat_transposed = t_mat.transposed()

Now take what you need ;)


How to quickly assign an individual material to color thousands of cubes at the same time with python API in Blender 2.8?

One mesh, object linked materials.

You are trying to make same linked mesh have different materials on a different object. Using object linked materials can use only the one mesh, and N x N materials and objects.

import bpy
context = bpy.context
scene = context.scene
count = 32

bpy.ops.mesh.primitive_cube_add(location=(0, 0, 0))
ob = context.object
dx, dy = ob.dimensions.xy
bpy.ops.object.material_slot_add()
ob.material_slots[0].link = 'OBJECT'

mat = bpy.data.materials.new("Mat")
ob.material_slots[0].material = mat
for i in range(1, count * count):
    o = ob.copy()
    o.material_slots[0].material = mat.copy()
    # set some mat props
    o.location = (dx * (i % count), dy * (i // count), 0)
    scene.collection.objects.link(o)

One material could be used here instead by mapping texture coordinates via the object.

Method 2: 1 material, N x N objects and meshes.

Grid, UVMap image texture, edge split, solidify, separate by loose parts

Using the same methods as outlined to you here https://blender.stackexchange.com/a/131765/15543

Material is an image texture mapped to the UV. This way we only have one material. The UV can be mapped to 1 pixel squares.

Result of script. Image is 128x128, grid was split 32 x 32

So each block has a top with 4x4 pixels.

import bpy
context = bpy.context

bpy.ops.mesh.primitive_grid_add(
        size=10,
        x_subdivisions=33,
        y_subdivisions=33,
        calc_uvs=True)

ob = context.object
me = ob.data
me.materials.append(bpy.data.materials["Material"])
sfy = ob.modifiers.new(name="Solidify", type='SOLIDIFY')
sfy.thickness = 1 / 3
bpy.ops.object.mode_set(mode='EDIT')
bpy.ops.mesh.edge_split()
bpy.ops.mesh.separate(type='LOOSE')
bpy.ops.object.mode_set()

bpy.ops.object.origin_set(type='ORIGIN_GEOMETRY')

Creating 128 x 128 objects and as many materials too is going to be slooooooooooooooooow.

Can be optimized for speed somewhat. Not sure it's worth it for zero feedback.

Method 3: 1 object, 1 mesh, N x N materials.

Single cube, applied array modifiers, materials assigned to each part

Similarly to this answer https://blender.stackexchange.com/a/61254/15543 can create an array mesh very quickly.

After the array modifiers are applied the faces are still ordered such that each 6 belongs to a cube.  A new material is added for each and assigned.  The row and column of the parts can be obtained using integer div and modulus and hence can be mapped to pixel colour.

For example sake I've only made a 32 x 32 array. Note the offset is at 1.5, change to 1.0 to have touching cubes.

To make each a single object, separate by loose parts as above. This is the rate-determining-step.  As one mesh, individual parts can be animated via hooks, armature, shapekeys.

import bpy
from bpy import context
# add a cube
bpy.ops.mesh.primitive_cube_add()
ob = context.active_object
me = ob.data
# add two array modifiers
count = 32
arrays = {"x": (1.5, 0, 0),
          "y": (0, 1.5, 0)}

for axis, displace in arrays.items():
    mod = ob.modifiers.new(axis, 'ARRAY')
    mod.count = count
    mod.relative_offset_displace = displace
    bpy.ops.object.modifier_apply(modifier=mod.name)

def chunks(l, n):
    for i in range(0, len(l), n):
        yield l[i:i+n]

material_index = 0
for cube in chunks(me.polygons, 6):
    mat = bpy.data.materials.new("Mat%d" % material_index)

    mat.diffuse_color[0] = material_index / 100
    me.materials.append(mat)
    for f in cube:

        f.material_index = material_index
    material_index += 1

Alternatively could use a UV map here also, for 1 object, 1 mesh (with NxN parts) and 1 material.


(Beginner) Inset weight "extruding" faces individually

I'm not entirely sure I understand.  First, I don't see any completed inset faces, only the state after extrusion (first that appears to be individual faces, the second that appears to be regions.)  Second, I'm not familiar with your use of the term "weight"; I'm used to it being used to talk about the extent to which a vertex belongs to a particular vertex group.

Note that it would be easy to get the first picture on accident if you have any doubled geometry, possibly by canceled extrusions.  First w->remove doubles.  Also note that extruding one checkered ring, and then extruding the second checkered ring, will get you the first picture, but extruding both together will get you the second.

Now, here's a default (region) extrusion similar to yours:

If I follow that up with inset faces, I'll get:

Now, maybe what you're talking about is using an inset follow by a scale; this is basically the same thing as an extrusion anyways.  Here's what happens if I inset with everything selected:

I can then move those faces any which way I'd like.  However, if I try to do this in two passes, or if I enable "individual" on the operator panel, I get

You'll notice that if I now try to move those faces, I'll end up with separate faces, as in your first pic.


When modeling, is there a way to have light shine from behind viewport camera?

You can put the scene lights on a separate layer, turn them of during viewport editing, and then parent a new lamp to the back of the camera. You can turn off the restrict rendering setting for the test lamp in the outliner.

This works in Blender Internal, but not in Cycles. You could test texture placment in BI, and then render from Cycles. It's possible to create shaders that work cross-engine, you just have to add the specific outputs. The BSDF nodes wouldn't work in BI, but the textures would.


Can I use the VSE to append multiple strips?

Sure! My result from just the VSE is the following. Note that you could use the same method for movie strips.

The first thing that you will have to do is adjust the dimensions to make sure there is no distortion in the Properties panel > Render tab > Dimensions dropdown > Resolution: settings.

With two 1080p images, one might use these Dimensions:

In the VSE, you can add two image strips on top of each other and then add an Effect Strip > Transform to each by selecting one, keying Shift + A > Effect Strip > Transform and repeating for the other one. Make sure that whichever Transform strip is on top has Alpha Over set in the VSE Properties Panel > Edit Strip dropdown > Blend: selection. This is what my strips look like in the VSE:

Whichever image you want to show on top should use these Transform strip > VSE Properties panel > Effect Strip dropdown settings:

Whichever image you want to show on bottom should use these Transform strip > VSE Properties panel > Effect Strip dropdown settings:

Here is a .blend for reference:


Selecting multiple edge loops in Blender 2.8

If selecting isn't working with alt-LMB, it's probably because you're using 3 button mouse emulation, in which case the old way of double clicking will work.

I'm still searching how to do edge rings though.


Control a cylinder mesh with multiple curves?

You could use the Spline IK constraint: Create your bezier curves, create one unique armature with bones that follow all around the curves (snap each bone head to each curve vertex), give the constraint to the last bone of the chain (choose Chain Length > number of bones, here, 4), parent the cylinder to the armature. At the end hook each curve vertex to an empty (or, even better, to the bones of a second armature, it would allow to easily come back to a rest pose).


How to get more points on a mesh (edit mode)?

In the comments I made, I probably misinterpreted the question. I never actually considered that you may be trying to use CtrlR on just the rim of the circle, and I thought you were trying to get more points on the surface of a filled circle.

The easiest way the get more vertices on the rim of a circle, is specifying the number of vertices when you add it. This is done in the Toolshelf right after adding the circle. If you do not see the toolshelf, make it visible by pressing T.

To add more vertices to an already created circle (or any object), you can subdivide it. In Edit mode there's a Subdivide button in the Toolshelf.

You may want to increase the Smoothness parameter. It's set to 0.000 by default, and this will make straight cuts. Setting it to 1.000 will make smoother cuts.


How to create a 3D object from a specific equation

The problem that prevents your equation from working with the Add Mesh: Extra Objects > Math Function > Z Math , is that you're using a sqrt function which is undefined for negative values.

When the math function operator tries to evaluate different values for X and Y, it raises an exception the first time that evaluation fails due to an attempt to sqrt a negative value.

Another option is to write a script of your own to generate the mesh only where the equation provides valid results. I wrote a quick script to do that below. It's incomplete as it only calculates vertices coordinates (result in the image above), and does not generate edges and faces, but it's a start:

import bpy, bmesh
import numpy     as np
from   math      import sqrt
from   itertools import product

# Define X and Y values lower bound, upper bound and number of points
lb, ub, n = ( -30, 30, 1000 )

# Calculate all the possible X-Y combinations and convert to a numpy array
xy = np.array( list( product( np.linspace( lb, ub, n ), np.linspace( lb, ub, n ) ) ) )

# Split X and Y to different arrays and initialize Z array
xs = xy[:,0]
ys = xy[:,1]
zs = []

# Iterate over every x and y value, and try to calculate the z.
# Append result if successful, and nan if not
for x, y in zip( xs, ys ):
    try:
        zs.append(
            (
                sqrt(
                    -16 * abs(x) + 40 * sqrt( abs(x) ) * y - 16 * pow( x, 2 ) - 25 * pow( y, 2 ) + 16
                ) + 15 * x
            ) / 15
        )
    except:
        zs.append( np.nan )

# Drop nan values from all axes
mask = np.logical_not(np.isnan(zs))
xs = xs[ mask ]
ys = ys[ mask ]
zs = np.array( zs )[ mask ]

# Generate mesh
bm = bmesh.new()

# Add vertices
for x, y, z in zip( xs, ys, zs ):
    bm.verts.new( (x,y,z) )

m = bpy.data.meshes.new( "equation" )

bm.to_mesh( m )

o = bpy.data.objects.new( "equation", m )
bpy.context.scene.objects.link( o )

This script uses external, non built-in libraries (namely numpy). You can achieve the same result without numpy, but it makes some of the calculations quicker and easier.


How to use Subsurface Scattering in Principled BSDF

Subsurface slider

Use it to scale Scattering depth down to realistic values
When set to 0, scattering is disabled

Values of around 0.01 are normal, since you're usually scaling from meters to milimeters.

Subsurface Color

Primary color. Visible on opaque parts and in shadows.
Generally, use the same image/color you used for Base color to avoid color mixing

Subsurface Radius aka Scatter Color

Secondary color. Visible on edges and translucent parts (like ears).
Connect an RGB node or a texture. This is a good place for a subdermal map.
The RGB values here represent how deep light penetrates in meters (!).

Correct radius is important to get right. Scale it down using the Subsurface slider.

Example of SSS setup
Stanford Dragon, 15 centimeters
Marble values set from reference chart below
Subsurface slider set to 0.01, to match SSS depth of marble (~8.5 milimeters)

Recommended values chart

Drag the chart into Blender and use color picker to easily select the colors
For SSS to work correctly, your model needs to be in real world scale.

Source chart from Pixar. Original paper here.

Sources

Link -
Henrik Wann Jensen, Stephen R. Marschner, Marc Levoy and Pat Hanrahan: "A Practical Model for Subsurface Light Transport". SIGGRAPH'2001.
An Introduction To Real-Time Subsurface Scattering, Stanford Dragon - Stanford University Computer Graphics Laboratory, Subsurface - Arnold Renderer, Subsurface - Substance Painter, Subsurface - Renderman


You can get camera space coordinates from the Input > Texture Coordinates node using the Camera or Window socket, depending on what you are looking for.

The same node provides local position for vertex using the Object socket, you can convert to world coordinates using a Vector Transform node.

Using the Vector Math node you can do the required matrix calculations.

If I interpreted your code right you should need something along the lines of the node tree below.


Blender console formatted printing: Is there a maximum length?

In python the string formatting operation ('%') accepts a single argument and in your first (working) example that's exactly what you've got as it's a single element with 3 components. in your other (not working) examples you're trying to pass multiple values to '%', each containing 3 values. Your solution is to simply combine them into a single tuple by appending them with the '+' operator :

for f in bpy.data.meshes['Cube'].polygons:
    for v in f.vertices:
        print("%f %f %f %f %f %f\n" % (bpy.data.meshes['Cube'].vertices[v].co[:] + f.normal[:]))
    print("\n")


The clip distance on your camera is set to a very small range.

Enable display limits so that you can visualize the clipping range.

Then increase the range so that the camera can see your objects


Align image corners to video corners in Blender VSE

I don't think there is currently a way.

It is an easy task for an addon, so I made one. You can get a copy of it from here, just save the link to disk, then in blenders preferences under addon click Install From File and select the script you just saved. Once enabled you will find a panel in the sequencer properties N with alignment options.

Currently it will align the selected strips to the top, left, bottom or right of the frame. I was just thinking that I could add align to active strip as well as centre, so it may also have those options by the time you see this.


How to adjust image color space, drawn with builtin shader

With

shader_code = gpu.shader.code_from_builtin("2D_IMAGE")
print(shader_code["vertex_shader"])
print(shader_code["fragment_shader"])

One can get code for builtin shader and modify it.
Here is mine, just 2 lines changed version:

vertex_shader = '''

    uniform mat4 ModelViewProjectionMatrix;

    in vec2 texCoord;
    in vec2 pos;
    out vec2 texCoord_interp;

    void main()
    {
      gl_Position = ModelViewProjectionMatrix * vec4(pos.xy, 0.0f, 1.0f);
      gl_Position.z = 1.0;
      texCoord_interp = texCoord;
    }

'''
fragment_shader = '''
    in vec2 texCoord_interp;
    out vec4 fragColor;

    uniform float gamma;

    uniform sampler2D image;

    void main()
    {
      fragColor = pow(texture(image, texCoord_interp), vec4(gamma));
    }

'''

shader = gpu.types.GPUShader(vertex_shader, fragment_shader)
shader.uniform_float("gamma", .454)


Need help animating a collection instance with parented empty

You're messing up with the parentage. Actually object B and C are parented to object A. But object C is an instance of object B, so C is twice subject to the influence of A.
So you need to either deparent B, make it invisible and only use C objects, or don't use C and duplicate B.


Add 3D content to an image using blender

If you were using a video, you could use blender camera tracking, and add objects to the scene that way. Then, you could select the exact frame in the video that you wanted to add the objects to. For example, if you had a video of the soccer game, then you could use that.

Here is an tutorial on blender camera tracking:
https://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=3&cad=rja&uact=8&ved=0CDIQtwIwAg&url=http%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DCVPcT0dJmoY&ei=J4IoVOy7CIi9ggTB7YDwCA&usg=AFQjCNF6HngfToZ3LNcfFsj9NnkfFfc6hg&sig2=JLK58U_NvMz6XS_KS3IzCA


How can I evenly but randomly distrybute particles in a mesh?

The problem is due to the uneven geometry interfering with the distribution of the particles. Add a Remesh modifier just before the Particle System in the modifier stack and, as well as enabling the Even Distribution (as mentioned by @LukeD), ensure to enable Use Modifier Stack. This should result in an even distribution of particles throughout the volume.

Without Remesh :

With Remesh :


Superellipse bevel with unevenly distributed edges?

[I'm the bevel developer] There is not such a way right now. As I discussed on your devtalk.blender.org thread, I had assumed artists would want evenly spaced chords, and went to quite a bit of trouble to achieve that.


How to add a border to a single videoclip

Blender can do all of those things but it takes a little bit of extra effort to set up. There is no "outline" tool, so you make it with a mask.

Create a mask in the UV/Image editor (render a frame from the video as a guide f-12), make sure that it is 'reversed' by clicking the Invert Mask button in the mask properties panel

Shift - A Add a "Color" effect strip above the video you want to highlight and apply a strip modifier in it's Strip Properties panel N key. Set the color strip's "Blend" type to Alpha Over or Over Drop.

To move them around the screen, (1) select both strips and combine them as a Metastrip ctrl-G. (2) Select the metastrip and add a Transform effect strip Shift-A. Select this new effect strip and change its "Blend" type to Alpha over or Over Drop the image or video (3) placed at the bottom of your stack. Use the properties panel to move and keyframe any animation.


How to save the default mode of a custom workspace?

Either from the 3D View Sidebar > Tools tab or from the Properties Window > Active Tool tab there is a workspace panel.

The dropdown menu allows you to define a default workspace mode. After that save the startup file from the File > Defaults > Save Startup File menu entry so it is available next time you start a new session.


To fix the file location issue I did: Outliner > change the "display mode" to "Data API" instead of "View Layer or "Scene" > scroll down to Movie Clips and in there I found the file paths from Movie Clip and Movie Clip.001 and just copy/pasted Ctrl+C / Ctrl+V the correct file path.
Still not sure how to fix the deleted solve data/track data.
Best I can tell is shift-clicking the X for the Movie Clip data block (deleting the false user) and then saving the blend file permanently deletes the solve/track data and the clip must be re-tracked and re-solved.  "Ten four rubber ducky. Over and out."


Why does Blender output noise even when rendering only flat colors?

As in comments, go to Output Properties tab, Post Processing section, decrease Dither to 0.0:

Searching for dither on SE should yield multiple questions where dithering was the solution (instead of the problem). The problem dithering solves is banding. In short, there's only 255 steps from #000000 black to #FF0000 red, so a horizontal gradient with more than 256 pixel width will assign some colors to multiple columns, making those steps possibly perceivable as the bands.
Ideally*, dithering would be implemented as a 16 bit value scaled down to 8 bits by rounding down or up, depending on the pixel's position. This way an integer red component like in your color #FF0000 (255 red) wouldn't be affected by dithering.
However, this is not how Blender does it, it doesn't round up or down, it just adds noise and then rounds:
source/blender/imbuf/intern/divers.c
MINLINE void ushort_to_byte_dither_v4(
    uchar b[4], const unsigned short us[4], DitherContext *di, float s, float t)
{
#define USHORTTOFLOAT(val) ((float)val / 65535.0f)
  float dither_value = dither_random_value(s, t) * 0.0033f * di->dither;

  b[0] = ftochar(dither_value + USHORTTOFLOAT(us[0]));
  b[1] = ftochar(dither_value + USHORTTOFLOAT(us[1]));
  b[2] = ftochar(dither_value + USHORTTOFLOAT(us[2]));
  b[3] = unit_ushort_to_uchar(us[3]);

#undef USHORTTOFLOAT
}

di->dither is the setting in the interface. It's multiplied by 0.0033 (1/303.(03)) and then by the result of a function dither_random_value(s, t). s and t are x and y coordinates. The result of the function is in range [0..1) - it's implemented slightly differently throughout the code, but always based on "A faster triangle noise"
So it will add noise to every color, even if that color perfectly fits the target color space without rounding.
Custom dithering
First setup the color management as in the question:

Now make a plane with a gradient that has two "flat" areas on either side:

The color ramp is set to two colors: #FF0000 (255 red) and #F50000 (245 red). Keep in mind you can't just input #F50000 as hex, because Blender will assume it's sRGB and convert it to linear space that it uses. So what you have to do is to divide 245/255 in a calculator and copy-paste the result to the red value of the color.
Now the compositor:

I'm only dealing with red here, so that the node setup is as simple as possible. The noise texture I used is Blender Original Distorted Noise with size:0.0 and brightness:1.5:

I didn't calculate those settings in some clever way, I just tinkered with them until the preview of "Less Than" node was giving me a result with almost completely white one side of a band and almost completely black other side (and smooth transition between them):

So if we blacked every 2nd shade of red, it would look like this:

Comparison
Standard dither 1.0, compositing turned off

Half dither 0.5, compositing still off

Zero dither (compositing still off)

Custom dither (dither setting 0.00 but compositing enabled)

The top red bar of each pair is the original output for testing with a color-picker. The other bars have increased contrast in Photoshop by setting the midtone level to 0.03 in RGB Histogram. The idea behind 0.5 dithering is that 0.5*0.0033 < 1/255/2 (0.00165 < 0.00196) so I thought maybe a value will never be increased by half of the step to the next 8bit value, but I must be missing something, as there's still some noise.
--
*- according to my tiny brain, but I might be missing something; for example, the reasoning of Blender developers could be that you should avoid getting pure black and pure white colors, as those are problems with overexposure or details completely lost in darkness (low/high end clipping). Once you avoid that, the likelihood for any color to be an integer in the chosen color space (that is, before being cast to a lower precision in that format) is very small, and it also doesn't make much sense to treat  a set of arbitrary colors differently than the rest. In the case of NPR, you can just disable dithering, export to a format with 16 bits per channel and do some custom dithering if needed.


Blender 2.8 VSE scene strip preview does not show image (as plane) from 3D viewport

You should open Properties panel (press N), select scene strip, then find in Properties panel Scene Preview/render tab. You can set here Render or LookDev to view the textures

Note, Sequencer must be in Preview or Sequenser/Preview mode


How to recalculate transform and rotation from origin?

Click Shift+Ctrl+Alt+C, then click Origin to Geometry


It's just a matter of finding some good contrasty and varying detail to put in the roughness map and hitting the right range of values. Assuming you're using a PBR shader, that is. If you have Substance Designer it has some nice noise patterns for this sort of thing. Otherwise (or even with SD!) photographs of dirty concrete usually work wonders. You can find these on any stock texture site, or try shooting your own if you find yourself at some place like an abandoned military site. (I have a bunch of personal ones I shot at Fort Stevens)

Often I find it easiest to create this kind of effect by starting with a constant value roughness around where I want for the surface, then blending in some noise or concrete photos using a blend mode like overlay. (overlay does a mix of brightening or darkening within a 0-1 range, so it's well suited to this sort of thing)

Start with the mix factor of 0 (just the constant roughness) and increase the mix factor until you start getting a nice breakup in the specular highlights. The example image there just uses a single instance of Cycles' noise node, which doesn't make the most detailed of varying textures. You'll often want to combine several procedural textures, or use photos of stuff like dirty concrete, or use an external tool with more complicated procedurals such as Substance. Sometimes using a ramp or levels can help you control the values in the texture so you don't get crazy ranges.

This is actually a fairly important thing to get the hang of in realistic texturing, as most smooth surfaces will get this sort of look on them once they've been exposed to the elements or fingerprints for awhile.


Where did texture paint in UV editor go?

In 2.80 the Image editor is now separated from the UV editor. So you need to switch to that.

edited to add:

Create a new image to paint on then select the brush icon and start drawing.....

In the Image Editor, Image menu choose the New option to create an image layer to draw on.


Importing image with original asspect ratio without cropping

You have found right option, the only thing left is to animate it.

With your credits imported, find the best Offset options (both X and Y) to make them begin the credits being in the bottom and end - in the top of frame, and animate your found values:

So, in the 1st frame this value is -1850 for me, and in the last - around 230.

The result will be scrolling your text:

text from here

The much more in-depth solution is provided in this solution


Trying to set a Keyframe in the Curve Data tab using Python

While likely not optimized the following appears to work both in blender 2.79b official and the 2.80 beta build I have at the moment and may assist in how to handle adding the key frames and manipulating them afterwards.

import bpy

obj = bpy.context.active_object  # Your pre-existing selected curve

def add_keyframes(obj):
    if obj.data.bevel_object:  # verify bevel object already selected
        obj.data.keyframe_insert(
                "bevel_factor_start",
                index=-1,
#                frame=1,  # defaults to current frame
#                group=""
                )
        obj.data.keyframe_insert(
                "bevel_factor_end",
                index=-1,
#                frame=1,  # defaults to current frame
#                group=""
                )

add_keyframes(obj)

def mod_fcurve(obj, path):
    for fc in obj.data.animation_data.action.fcurves:
        if fc.data_path == path:
            my_fc = fc
    for pt in my_fc.keyframe_points:
        pt.co.x += 1  # increase x 'frame number' of points
        pt.co.y += 0.1  # increase y 'value' of all pts in curve

mod_fcurve(obj, "bevel_factor_start")


The maximum fps that can be played back will depend on your computer and the complexity of the scene in blender.

The syncronze playback option tells blender to play every frame or drop frames to keep playback in sync with time. You set the fps at the 100 you want in the final output video, then if the scene can be played at 100 fps it will be, otherwise frames will be dropped so that playback will be in sync timewise.

The interface preferences can be set to display the fps that are being played, when frames are being dropped the fps will be drawn in red.


Is blender good for real physics simulations?

All physics simulations are approximations :-)
It just depends on how accurate you need it to be. As for your example, a box sliding on a slope is in reality quite complex. You do not only have imperfect, uneven surfaces, but they will also deform under load, maybe even be wet in places, they will possibly abrade and so on.
Depending on the level of accuracy you need, you can either use the fast but somewhat inaccurate blender physics, some third-party multibody simulation tool, or even a full FEM-analysis.
In any way, there are possibilities to use blender for visualization of the results afterwards.
Maybe just describe a little more in detail, what physical effects you want to show and then someone can point you in the right direction!


Problem when reverse copying keyframe for walk cycle

Alignement is set by "Roll" property. You can access it in Edit Mode on your armature, on property panel N, for each bone.

You can also change roll on multiple bones, using Ctrl + N

In order to use correctly Mirror copying, if your Left bone has a X° roll, your right bone must have a -X° roll.


How to add a watermark in simple blend4web turntable scene exported as .html by using either Blender or directly coding in .html?

There is a special feature in B4W called Viewport Alignment. Using this feature, the object can be aligned to the active camera, so that the object will remain in the same place of the screen regardless of the position and rotation of the camera. This is especially useful for creating UI elements and watermarks.
Taken from the B4W manual.


Select the faces you want to merge, press Del or X and click limited dissolve.


What are these triangles along the model edges?

These are precision artifacts from clipping distance issues caused by the distance between the clipping planes being too great:

I reduced the far plane to 1m.


How can I get a volume to expand uniformily in all directions, like a nova?

The smoke by default rises upwards from the emitter. To disable this, you need to set the Density and Temp. Diff. both to 0. Also disable the influence of gravity by setting Gravity under Smoke Field Weights to 0.

Here, I've also set Dissolve to 10 frames, to make the smoke disappear. I'm using a Force type force field, with Power set to 2*. This makes the effect falloff physically correct, by making the force proportional to inverse square of the distance from the source.

And this is the result I got.

As you can see, it doesn't spread exactly equally in all directions. However, the force, and most importantly the Vorticity of the smoke domain, are quite strong. The smoke will be calmer if you reduce the vorticity, and spread more slowly if you reduce the strength of the force.

*Have a look at the Blender Manual for an explanation of the Power and other settings.


What kind of units does the Cycles emission strength use?

The unit is Irradiance - radiant flux emitted by a surface per unit area (watt per square meter).

This is a radiometric "corresponding" unit to Illuminance (also known as Lux), which is a photometric unit measured in lumen per square meter.

Radiometric units are based on physical power, that means all wavelengths are weighted equally, while photometric units take into account the sensitivity of human eye to different wavelengths. The weighting is determined by the luminosity function (which was measured for human eye and is an agreed-upon standard).

Converting Irradiance and Illuminance:

There is a different conversion factor for every wavelength, so the spectral composition of light must be known to make the conversion.

At the most sensitive wavelength to the human eye the conversion factor is

1.0 W/m2 = 683.002 lumen/m2  # at wavelength = 555nm (green)

That means the irradiance (power) to make 1 lumen is at it's minimum at this wavelength (just 1.464 mW/m2).

Luminous efficiency is then the ratio between the actual number of lumens per watt and the theoretical maximum.

Incandescent light bulb has a luminous efficiency of 2% which is very poor. It's because lot of it's irradiance is only heat which is not visible. The luminosity function is zero for wavelengths outside the visible spectrum.


Weird because I've seamed the other teeth, unwraped with the first unwrap option (Unwrap), and it worked perfectly, so you must do something wrong somewhere, what option are you choosing?


(Video Included) Addon Wont Activate after Installation

You have put your operational code in as part of the Class SimpleOperator.

This means that when the register creates the Class your code is run, which is the wrong time and has no context.

Take the bpy.ops.transform.translate code and move it out of the Class definition and move it into the main function e.g.

def main(context):
    for ob in context.scene.objects:
        print(ob)
    bpy.ops.transform.translate(value=(0, 2.20362, 0), orient_type='GLOBAL', orient_matrix=((1, 0, 0), (0, 1, 0), (0, 0, 1)), orient_matrix_type='GLOBAL', constraint_axis=(False, True, False), mirror=True, proportional='DISABLED', proportional_edit_falloff='SMOOTH', proportional_size=1, release_confirm=True)

Now when you run the test call

bpy.ops.object.simple_operator()

It will print out all the Object names and then try and Translate the currently selected Object


When I switch from single to image sequence of an openEXR image sequence in the Compositor Panel, the backdrop disappears

SOLVED: My OpenEXR multilayer has 10001,10002,10003... as suffix numbers. This means that the "offset" ot the Image Node must be set as 1000, to reach the frame 1,2,3 etc... Only importing the OpenEXR from the node folder, selecting all the images and clicking import, has forced Blender to automatically set the offset at 1000, resolving this issue. Of course this could be done manually.


Render background and freestyle in different image layers

As far as my understanding goes, Blender isn't capable of creating multilayered TIFFs.
However, you could use other software to acchieve that.
 1. Change the file format for the output
In Output Properties you would specify the file format "TIFF".
Any file format that supports transparency (and can be converted by ImageMagick) should be fine.

 2. Assign Freestyle its own render pass
Since Blender 2.83 there is an option to set Freestyle as a render pass in View Layer Properties.

In the compositor, Freestyle can then be processed separately.

In case you have multiple layers that you like to export in a single run, you could use File Output Nodes.
For the default cube, the rendered image would look something like this.

 3. Use other software to create a layered TIFF
Any software that is capable of creating multilayered TIFFs will work.
For ImageMagick this command should work. (As ImageMagick doesn't have a graphical user interface, this is executed from the command line.)
convert canvas:white -resize 1920x1080! blender_render.tif -compose over multilayered_result.tif

The resolution should match the resolution of your render.
Without the trailing exclamation mark, the background would keep its ratio (a square).


Speedup Cycles for material-only renders

To speed up Cycles, you are going to have to sacrifice realism.

If that is okay for your projects, you might try adjusting the filter glossy field, disabling Shadows, Caustics, and Bounce light, , like so:

Set the fields labeled, "Max" and "Min" to adjust the overall amount of Bounce Lighting, but note that this will also disable the "reflectiveness" of an object; If you don't want that, then adjust the fields bellow, with out changing the "Glossy" one.


2.8 - has the "slow parent" feature been removed?

Looking at https://developer.blender.org/T55026, it does appear that Slow Parent is no longer available and is unlikely to be reinstated.

As an alternative, you could use a Driver to average between the 'desired' location of an object and its 'previous' location. I've done similar in the past before I knew of the existence of the Slow Parent or where I just wanted more control. As an example, see this answer to Moving objects create wind


How to control object's path follow speed based on its position

One way to do it is to use a discretized implementation instead of a parameterized one. We store the parameter (location along spline) of the object in a custom property. At each execution, we increment that parameter by the velocity that we can compute from the relation you provided above.

The divide node is a unit conversion which you can replace with whatever you need. Note that Uniform has to be used when sampling the location for obvious reasons.

A useful addition is to add a condition where the parameter is set back to zero whenever the frame is equal to or less than one so that you can play the animation as much as you want.

A similar condition can be added to cube location.


Export 3D model from Blender to .U3D for use in PDF file

You can find the scene button in the property Area, scroll down to find the u3d export.
I managed to export to u3d, but after putting it to pdf with latex the pdf failed to open correctly in adobe reader XI. a "3D data parsing error has occurred"


Is there a node or combination of nodes that can take an average colour out of a single image?

If you shrink the image to a size smaller than a pixel of the render result it will render as average, so you could just change the mapping of the coordinates:

You can use vector mapping node as well.

That might not be the most efficient way to calculate the average, but it's easy to achieve and it works.


In the provided example it seems the light groups are driven straight from the midi file for the instruments. You can load such file in the MIDI Driver addon and assign each instrument channel an animation Action for example (like turning a group of lights on and off).

Alternatively you can use animated texture to drive the light's emission. The bulbs should be mesh lights for this purpose.

Create a texture strip with as many pixels as you have bulbs. Unwrap each bulb into it's corresponding pixel.

Animate the texture strip in a loop to create whatever color and motion pattern you desire. It's easy to do in AfterFX or similar app.

Also simple animations like switching between odd and even bulbs could be also driven with lamp objects using drivers and #frame keyword to drive the light's strength. Drivers can be copied easily between many bulbs. This approach is not that flexible though.


I think you are trying to Say, 'How to remove Flat Edges'.
If you want Low poly But smooth Cylinder then;

Select The Cylinder & In Tool Shelf Click 'Smooth'

(It's A low-poly cylinder with only 24 Faces on curved Surface.)

Go to Modifiers Tab Add Edge Split Modifier To get the Caps Splited Rest of the Cylinder. This wont Split The Faces on Curved Surface. Because They Are Attached with a higher angle although you can split them in some cases by increasing the Angle of Edge Split Modifier. But I think 30 Degree will work.

You Will get Smooth Cylinder with this.


Things are a changin in 2.8

The creation parameters menu, for now, is at the bottom of the screen as a fixed window (supposedly will become a floating one at some point).


Using the fracture modifier with the principled shader?

No, both of the features you mention are part of blender's core source code and can't be combined without some work.

The principled shader is part of the current blender development that will be included in the next release which is planned to be released soon.

The built in fracture modifier is a separate development project that is being done parallel to blender's main development with plans to have it merged into a blender release at a later time. The developer working on this merges the main blender development into the work being done on occasions. Unless you know some C/C++ coding and want to help, I would suggest waiting until the next merge from master is done. You can find instructions for building your own versions of blender on the blender wiki.

The developer has a website dedicated to the fracture modifier project where you can find links to a blenderartist thread and a facebook page, so you can try contacting the developer and asking if they have any plans to merge soon, a donation to the project may help persuade them.

As you seem to have a copy of blender with the fracture modifier, you can setup a pbr shader that will give similar results to the new principled shader that you can use until the update happens. Blender guru has a tutorial on pbr shaders and you can find some pre-built shaders to download at BlenderBrit.


How to evenly divide a face when loop cut doesn't work

In my example I started with a plane with 5 vertices, so loop cut doesn't work:

I selected the upper edge, pressed W to subdivide 3 times.

Make the same with lower edge, then select a pair of vertices and press J to connect and divide the face.


Mirror modifier problem for only one cube

So from what I get from you question is that you are trying to model a low poly car with the mirror modifier activated. but you can't seem to apply it or add extra meshes?

To be able to apply any modifier you need to be in object mode.

So you would first create a cube and from front view in edit mode with "Control + R" create an edge loop in the middle

after that you want to delete the first set of vertices on any side.
And then apply the mirror modifier with "Clipping" checked

Then you can edit the mesh however you like and you have 2 ways of adding new meshes

While in edit mode press "shift + a" to create a new mesh
Go to object mode, press "shift + a" to create a new mesh and repeat
steps 1 / 3 with the new model.


Why does this Copy Loc contraint not work with this IK bone?

The issue you have is parenting. You would have the hand bone as a child of the lower arm bone, this parenting defines the position of the hand, preventing the location constraint from moving it. As the bone parenting doesn't effect the rotation, your rotation constraint can do it's thing.

You have the right idea with using IK, the IK constraint will set the location of the hand bone and move the arm bones to the right position to match it. What you need to do is remove the location constraint and set the empty as the target for the IK constraint.


You have two faces already.

You cannot create a face from that faces using  F .

I tried to dissolve the edge but no luck.

My solution:

Subdivide that edge and delete the vertex.

See the image below:


'object' option not available in Object Solver panel

I do not know what tutorial you are following, but I think you might have missed something. The modifier is on the cube, but the cube is the object you are trying to track to is what it sounds like. You can't use the object which is being modified as the target object in any field, in any modifier. The tutor might have duplicated the object, or done something without proper narration, but as far as I know the target object can never be the object being modified.


Why is symmetry not working in Texture Paint with my posed character?

After trial and error I discovered that by turning off visibility in the armature modifier, the symmetry goes back to working. This taught me that the painting symmetry is based on the global coordinates and original position, not the pose it happens to be in.
If using Texture Paint with symmetry, toggle the visibility of the armature modifier off for the session unless the misalignment is intentional.