The location that you have the issue is the barrier between what gets moved and what doesn't. The mesh faces in this section can easily get stretched too much with the motion of the attached pieces.

I would recommend using a curve object for the hose instead of a mesh. By giving the curve a full fill and a bevel depth and increasing the resolution you get a nice round hose.

To animate the hose you add a hook to one or more of the curve points. While in edit mode select one of the curve points and press CtrlH and select Hook to New Object. This will create an empty at the location of the curve point as well as add a hook constraint. in object mode when you move the empty the curve point will move with it.

The beauty of a curve in this scenario is it maintains the hose shape no matter how far you stretch the points from one another. Parenting the empty to your piston will keep the end of the hose in place.

while stretching the hose too far will create a noticeable distortion you may want to add more hooks to the next curve point and use a limit distance constraint so that the coiled hose picks up and follows the movement.

For the final animation you would want to animate some rotation on the empties to prevent kinks in the hose.

You can look at my simple example file here.


Load your video clip into VSE (I'm using an image here, but it is the same for videos)

Set the resolution to your output requirements.

Add an Effects Strip -> Transform

Change the Scale parameters and recenter with the Position X/Y

Render output resampled.

I spent sometime trying the Clip options in the Transform strip but they did not work when changing the output resolution.


How can I make the deformation to a canvas mesh in dynamic paint permanent?

Dynamic paint deforms the mesh through the modifier system. To leave a mesh permanently deformed based on any modifiers operation you apply the modifier.


nVidia driver causes flickering viewport background

After about a year with the same issue, I found a solution: use Blender in REAL fullscreen mode. By that, I mean, do not use it with maximized window, go to Window > Toggle Window Fullscreen. This solved the problem both in Blender 2.79b and in 2.80.

I dunno if we have the same machine, I'm using an Acer Aspire-E5, but it uses the same graphics card, 940MX.

I feel like this is some sort of conflict between it and the integrated graphics card, where when idle, it uses the Intel card. This would explain this bug, and another one I was getting recently in 2.79b, were the interface would not show what was really happenning currently and show still images of stuff that happenned.

`Putting the software in fullscreen may tell the NVIDIA card that it can take full control of it, so those bugs don't happen.


Joining different UVmaps from different objects

You can't combine the UV maps of multipe objects in Blender. Officialy the the TextureAtlas plugin only supports lightmaps (the link could be outdated).

But wait Gleb Alexandrov made a promising tutorial:

  John Carmack from id Software used megatexture. You use megatexture.

game-level-texturing-texture-atlas

Related Unity Links:

Draw Call Minimizer
whats-the-best-way-to-reduce-draw-calls


How to make fluids come out in a local coordinates?

Why don't you rotate the flow generator?


Problem setting parent with automatic weights

Select the object and the armature in this order; mesh, then armature. The armature must be the active object to get the options you are looking for. You have the mesh as the active object.
(lighter orange color is the active object)


Like in cegatron's answer, you should use Loopcut (CtrlR)

Once you have made a new edge loop, delete the faces with X or Delete> Faces, then fill the holes with F:


How to append an object and its material at once?

As first - assign materials to objects and when you append this objects to new scene, they will append with materials. If you append materials separately, Blender can't know which material assign to which object.


My Blender appears to be missing features

If you do not see render settings that you expect, you should check if the render engine you need is selected. If you need Cycles it should be selected in the header of the Info panel:


How to achieve a realistic material for an operative phone screen?

Here's an alternative method that deals with :

Parallax (where the emissive part of the screen is behind the 'glass' surface
Surface reflections
Pixellation of the image
Scattering of the image into the 'glass'
Dimming due to viewing angle
Surface scratches

First to the parallax. This is the effect where the screen image moves in relation to the surface due to the viewing angle - due to being set behind the actual surface. This could be modelled by placing an additional (glass) surface in front of the 'emissive' surface but can actually be faked using vector maths similar to https://blender.stackexchange.com/a/84618/29586.

The Cross Product is used to generate a vector in the required direction of displacement of the image and the Dot Product is used to calculate the amount of displacement to apply. Adjusting the Emitter Depth value node controls the effective depth below the surface.

Next for the surface reflections - this is easy to achieve with a basic Fresnel arrangement to mix a Glossy shader with a small amount of roughness to slightly spread the reflections.

To make the image appear pixellated we can use the Modulo function to convert the input coordinates into discrete "steps". Some additional maths can detect when the point in the texture is close to the edge of one of these 'pixels' and 'black' it out so as to produce a dark border around each pixel.

The bright image projected onto the back of the glass may produce some scattering or 'glow' below the surface, spread out by adding some Noise to displace the coordinates.

This uses the same 'pixellation' as for the main image (without the black border as it's an unnecessary complication since the result will be blurred anyway). The 'blurred' image will be in the 'correct' place on the screen rather than being offset to simulate the light being projected towards the screen causing a glow or scatter due to its high 'straight-on' intensity. Keep the intensity quite low so the effect is quite subtle.

Many screen technologies have limitations in the viewing angle where the image will become distorted or fade out at shallow angles. More Vector Maths can be used to achieve this by using the Dot Product to compare the Normal with the Incoming ray and using a Color Ramp to allow this to be tuned to affect the visibility as the angle changes.

Finally, we can add some surface scratches which helps to bring out the parallax effect (as the emissive image will move in relation to the scratches). The surface scratches control the mixing in of a Glossy shader with a high roughness. This will look light when illuminated and will also block the emission to look darker the the scratches are obscuring the content on the screen (just like real scratches).

Bringing this all together produces the following material :

The cyan nodes indicate parameters you can adjust - eg, the 'depth' below the surface of the emissive screen, the pixellation factor, the brightness of the emission and the glow. Also, you can adjust the color ramp to change the rate and angle of the falloff due to viewing angle.

And the final result :

Blend file included :  (you'll need to add your own HDR for the environment)

Here's an example of a phone screen (screengrab from an iPhone) with a Bevel added to the edges of the mesh (which actually interacts with the parallax quite well when the image is close to the edge). (click to see at full resolution)


Animation Nodes. Distribute objects based on distance

I found a quite simple solution. The Map Range node has an interpolation input where we can plug the Interpolation from Curve Mapping node. So we can adjust the mapping of a random value with a curve. See below:


BGE: altering a cube's shape in realtime (python)

Using the example shown for KX_MeshProxy

from bge import logic

cont = logic.getCurrentController()
object = cont.owner

for mesh in object.meshes:
   for m_index in range(len(mesh.materials)):
      for v_index in range(mesh.getVertexArrayLength(m_index)):
         vertex = mesh.getVertex(m_index, v_index)
         # Do something with vertex here...
         # ... eg: color the vertex red.
         vertex.color = [1.0, 0.0, 0.0, 1.0]

mesh.getVertexArrayLength(matid) tells you how many vertices are in the mesh, you then loop through each by increasing the vertex index which is the second value to getVertex(matid, index)

Applying that to your sample -

mesh = own.meshes[0]
for v_index in range(mesh.getVertexArrayLength(0)):
    vert  = mesh.getVertex( 0, v_index)
    pos = vert.getXYZ()
    #alter pos
    vert.setXYZ(pos)


Each object can be exported as a separate FBX file. Just select one and check the Selected Objects in the export settings.


2.8 Beta - Save all images "invalid path"?

this isn't broken or incomplete, it does work!!
What you haven't done is SAVE the files YOURSELF first!
Once you have done this the first time, every other time you press the Save All Images button, it WILL Save ALL your Images!!
Got me stuck for a bit too, but you just need to give it a path first, then you're good to go :]
Cheers
Wayne


The shortcut is SHIFT+` or you can use the menu View > Navigation > Fly Navigation

If you're looking for a shortcut you can search for them in the preferences (Edit > Preferences). They are searchable by name and key combination, depending what you've selected in the dropdown.


You should use FFmpeg video and MPEG-4. It will output a .mp4 file, which is the most common video file format and will probably work on any device, including mac.


How do I remove the UV grid from this image?

This solution was provided by a user on irc channel #Blender named JA12.
Also, please read Mr Zak's comments on the question.


Use the numpad keys to get the (orthographic) view you want
Numpad 1 = front,
Numpad 3 = side,
Numpad 7 = top,
Numpad 9 = flip (ex: top becomes bottom).
To toggle orthographic and perspective view use  Numpad 5
When you have the correct side, press Ctrl+Alt+Numpad 0 to snap the camera to your viewport view.
To get more specific, select the camera and press N to bring up the tool menu where you can adjust values manually (such as distance).


Colored matt glass shade for lamp in cycles

I think all you need is a rough glass shader:

Or perhaps something like this:

Filtering out certain colors is a fairly simple matter:


Texture paint uses one image for different objects

You were close. Instead of changing painting mode, you need to specify on what image you want to paint, selecting the canvas image in slots panel.

It's handy if you want to clone to specific image from multiple different UVs and images.


How can i recreate this orange texture in blender?

I agree with Duarte, I would use a voroni texture plugged into a normal map. Then use the principled shader with SSS set to 1 or 2.

I used a texture in the roughness slot just to break up the shininess.

maybe scale the voroni texture even more than I did to make smaller divits and then bump the strength up a little more. Possibly invert the bump.


Found the solution was to change the ownership of /dev/kfd from root:root to root:video. Then add it to a udev rule to make it persistant:

Add this to /etc/udev/rules.d/60-kfd-opencl.rules

KERNEL=="kfd", MODE="0660", GROUP="video"


Which is faster: A math node tree or an OSL shader?

Answer is hard to give, so I will rephrase the question to will an OSL script node eventually be faster than an SVM node graph with math nodes. The answer to this question is yes. Then the next question, when will this benefit happen. this one depends on many parameters. Would I recomment to migrate to OSL script fore solely this reason? No.

I did a test on this subject. As GPU depends on many other stuff I will stick to a SVM CPU vs OSL CPU comparison.

Specs of my test machine:

Intel(R) Core(TM) i7-6700 CPU @ 3.40GHz (8 cores)
Running on Linux
Using official Blender 2.79 release

Test scenes

I constructed 5 scenes for this test.

SVM-0: SVM without the math nodes

SVM-math: SVM with the math nodes

OSL-0: OSL without the math nodes

OSL-math: OSL with the math nodes

OSL-scipt: OSL with the script node

The scene uses around 12 math nodes. I used the emission shader as it will not scatter new rays.

SVM-0  SVM-math | OSL-0  OSL-math OSL-script
------ -------- | ------ -------- ----------
22.90  25.86    | 25.47  27.70    26.05
22.87  25.80    | 25.40  27.64    26.01
22.86  25.84    | 25.38  27.68    25.99
22.92  25.84    | 25.42  27.65    26.04
22.91  25.79    | 25.44  27.63    26.04
-----  -------- | ------ -------- ----------
22.892 25.826   | 25.422 27.660   26.026

What is important in these numbers:
 - SVM average time in the math nodes is 2.934
 - OSL average time in the math nodes is 2.238
 - OSL average time in script node is 0.604

SVM math nodes scales linear. Meaning adding more math nodes will add on average a constant performance penalty.

There is a positive effect on using script nodes. Where is the theoretically break even?

((26.026-22.892)/0.604)*12=62.2649

But different scenes will have different results. For example: the test scenes are constructed that the shader is full screen. Normally you have many different objects and materials in the scene. So let's calculate the number of samples that are needed.

1920*1080*128*62.2649 = 16526399569.92 # resolution * samples * breakeven

On my machine the benefit would happen around 16,526,399,569.92 samples that pass though a node graph where 62 mathnodes were replaced with a single script node.

Note: on different machines different things will happen and that can influence the results.

There are also other stuff to be aware off: SVM codebase is fully shared between CPU/Cuda/OpenCL. As GPU's don't have the ability to have a stack the cycles developers
came up with an idea to implement a fixed stack that could compile on all devices. This stack is limited to 256.
When node graphs get too large SVM will not become an option anymore so the artist might want to switch to OSL.

Would I still recommend it?

No. reason: other materials setup have other cost penalties in OSL. So this theoretically benefit in practice might be much higher. So for this reason I would stick to SVM.


How to create Onyx material in Blender Cycles?

I'm not experienced with cycles but share some ideas on how to approach this. You could start with a Voronoi texture to get the cellular look:

Then add a color ramp with colors occuring in the image.

The cells in your image have different sizes this means whe need to mix two Voronoi textures which different scales. The borders of the cells are not as smooth as in the Voronoi texture here some noise could help.

the upper part of the nodes (including noise) could look like:

the lower part (overlay) something like this:

Combined by mix shader:


Python scripting: How to hide from viewport all child objects linked through parent

Boolean with update

A hide_children boolean property is added to all objects.
If the property is updated all children are hidden, plus their hide_children is set, propagating the hide down the hierarchy.

2.8x Test script, with property drawn on text editor footer.

import bpy
from bpy.props import BoolProperty

def hide_children(self, context):
    self.hide_set(self.hide_children)
    for o in self.children:
        o.hide_children = self.hide_children

bpy.types.Object.hide_children = BoolProperty(update=hide_children)

def draw(self, context):
    layout = self.layout
    ob = context.object
    layout.prop(ob, "hide_children")

bpy.types.TEXT_HT_footer.append(draw)

Similarly to only toggle children

def hide_children(self, context):
    for o in self.children:
        o.hide_set(self.hide_children)
        o.hide_children = self.hide_children

These are object properties, to layout for all objects in scene

for o in scene.objects:
    layout.prop(o, "hide_children")

Note: For 2.8x would be very tempted to do this with collections, and their hierarchy instead of objects.


set special mouse button to toggle between selection modes

To cycle through the possible selection options, you will need an operator that looks at the current selection to choose which selection option should be enabled.

That can be done in a simple operator, which you can then assign to your mouse button.

class SelectCycle(bpy.types.Operator):
    bl_idname = 'mesh.select_cycle'
    bl_label = 'Cycles through selection modes.'

    def execute(self, context):
        ts = context.tool_settings
        if ts.mesh_select_mode[0]:
            ts.mesh_select_mode = [False,True,False]
        elif ts.mesh_select_mode[1]:
            ts.mesh_select_mode = [False,False,True]
        else:
            ts.mesh_select_mode = [True,False,False]
        return {'FINISHED'}

You can find a copy of this as an addon here, so you can enable it in your startup.blend.

In your input settings, you just need to enter mesh.select_cycle for the idname and choose the mouse button.


How to create a procedural embedded stone texture for ground/asphalt/pebbled concrete?

I'd recommend using Brick Texture as a core for stones generation. I've set up these nodes for some tests:

As you see I use Voronoi too (because you mentioned it) but just to shuffle the stones a little bit. I'm sure you can use noise or something else for it.

This gives us the sharp shapes we were after. We can use it as a mask then:

I multiply it by some color, mix with another instances of this "stones texture" with a bit different sizes/frequencies/color and finally add a simple noisy background. I also apply some Image Blur from b°wide NodePack

Personally, I like it when the stones are small and I'm not sure if you'll be satisfied with it much zoomed.

I also did't manage to reach the stones density as on your 2nd image without ending with many overlapping stones.
Here's my general set-up:

UPDATE:
To make it more clear how Bricks-Voronoi pair works I'll give some more images of Bricks without its companion.
No vector input (raw boring squares):

Noise texture:

Wave texture:


The code in the first answer you linked handles the data retrieval exactly as you want it (if you set the link flag to False, but it later on always instantiates the result. In plain English: The group you're looking for has been appended just fine, but it only exists within bpy.data so far, it is not connected to your scene yet. Just as with linked data, you can instantiate such a group. But if you want to instead link the objects to your current scene as well (which what the append command does by default), then you have to modify the lower part of the code a little:

import bpy

filepath = "//Source.blend"
group_name = "Test"
# link = False means append, link = True will link the group
link = False

# append the group defined in group_name from the .blend file
with bpy.data.libraries.load(filepath, link=link) as (data_src, data_dst):
    ## all groups
    # data_to.groups = data_from.groups

    # only append a single group we already know the name of
    data_dst.groups = [group_name]

    # link the objects contained in the group to your current scene
    # otherwise you won't ever see them!
for o in data_dst.groups[0].objects:
    bpy.context.scene.objects.link(o)

    # for safety measures, update the scene
    # most likely only necessary from within an add-on
bpy.context.scene.update()

The example above appends a group called Test from a file called Source.blend located in the same folder as the file you're working in right now.

The operators around bpy.data.libraries.xxx are low-level functions. The benefit of that is they execute really fast, and you have nice access to the retrieved data later on via the data_dst variable, which contains a bunch of lists with the stuff you retrieved. The downside is that a low level function really only does this one task. What the coder decides to do with the retrieved data is totally up to him, that's why you manually need to link the objects to the scene.

You can read more about the topic on the API pages: https://docs.blender.org/api/blender_python_api_2_78_0/bpy.types.BlendDataLibraries.html?highlight=libraries#bpy.types.BlendDataLibraries.load


How can I make a Bézier curve have sharp and curved points?

Being in Edit Mode you can select the desired curve point, press V and change the Handle Type to Vector

To have even more control you can set the Handle Type to Free


You can stretch any texture using the Mapping Node.

Add Mapping node right after Texture Coordinate node
Change type from Point to Texture (but it will work either way)
Crank up the scale disproportionally


How would I fade out the edges of a plane, in Cycles?

You would just mix the main shader with a Transparent shader using a mix factor driven by a gradient texture.

Here's a slight expanded version with an ocean plane and adding a Dif/Glos shader to the ocean surface before blending in the transparency.


selecting many objects inside blender and export them as seperate .obj with one click?

certainly! but it's a little hacky.  Run this from text editor for a few objects selected. Make sure to change the folder to a valid path.

import bpy
import os

folder = '/home/zeffii/Uploads/'

selected = bpy.context.selected_objects.copy()
bpy.ops.object.select_all(action='DESELECT')

for obj in selected:
    name = obj.name.replace('.', '_')
    obj.select = True
    fullpath = os.path.join(folder, name + '.obj')
    bpy.ops.export_scene.obj(
        filepath=fullpath,
        check_existing=True,
        axis_forward='-Z',
        axis_up='Y',
        use_selection=True,
        use_animation=False,
        use_mesh_modifiers=True,
        use_edges=True,
        use_smooth_groups=False,
        use_smooth_groups_bitflags=False,
        use_normals=True,
        use_uvs=True,
        use_materials=True,
        use_triangles=False,
        use_nurbs=False,
        use_vertex_groups=False,
        use_blen_objects=True,
        group_by_object=False,
        group_by_material=False,
        keep_vertex_order=False,
        global_scale=1,
        path_mode='AUTO')
    obj.select = False

Most of those options in export_scene are default and you can remove those lines, or comment them out, but some of them may be useful if you want to change them later.

There's a nice Template for this in (with a slightly different approach - as in, it checks to see if the destination is valid first, which is handy if you aren't too familiar with paths):
TextEditor -> Templates -> Python -> Batch Export

update:

https://gist.github.com/zeffii/529d435d5853e92dcc51

I'm not entirely sure how to inherit all the properties from the original exporter operator for objs. I could add them individually if you need specific props, else it would be wasted effort adding them all.

With the exporter code, you navigate to select a folder, don't have to type any thing, just hit the Export selected Objects as obj button at the end.


How to execute an operator from an EnumProperty?

Try this
The following script basically does what you want, although I stick to my recommendation to NOT add primitives based on changes of enumerations. Those changes are also tracked when you set the enum value through python, so you might run into real nightmare further down the road. This is only one possible reason for using a dedicated operator with a button that runs it, but in the end it's up to you.
The script here is only modified in three details compared to your's:

I've added the update_enum method at the beginning, calling the operator
I've corrected a spelling mistake for the operator call to the uv_sphere_add function
I've added the call to the update_enum() function in your EnumProperty

Besides that, the code is the same as yours. Note that in case of the update_enum function, self is already the current scene, so I can happily access the current enum value using self.my_enum.
import bpy

def update_enum(self, context):
    # self = current scene in an EnumProperty callback!
    print(self.my_enum)
    eval('bpy.ops.%s()' % self.my_enum)

class LayoutDemoPanel(bpy.types.Panel):
    bl_label = "Test"
    bl_space_type = 'VIEW_3D'
    bl_region_type = 'UI'

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

        layout.label(text="Enum prop")

        scene = context.scene
        layout.prop(scene, "my_enum", expand=True)

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

    bpy.types.Scene.my_enum = bpy.props.EnumProperty(
            name = "My enum",
            description = "My enum description",
            items = [
                ("mesh.primitive_cube_add", "Cube", "Create a cube"),
                ("mesh.primitive_uv_sphere_add", "Sphere", "Create a Sphere"),
            ],
            update=update_enum
        )

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

    del bpy.types.Scene.my_enum

if __name__ == "__main__":
    register()


How to import a Blender Model into Source Film Maker?

Importing from blender to source is a full process, and there are plenty of tools to make it easier, all of which are free.
technically it's possible to do it all only by installing blender source tools (https://steamreview.org/BlenderSourceTools/), an addon to export as DMX or SMD and use the stock tools provided by valve, that are in the game/bin folder.
But everyone uses community built tools, crowbar and VTFedit at least.

with your model created, export it as smd or dmx with the BST. the material you set will not be exported, but it's important you use the same name when you create your materials.

You'll then have to write a QC file, it's a conductor, indicating to source how you want it to behave in game. Naming the object, assigning it models and animations etc. (https://developer.valvesoftware.com/wiki/QC)

You'll also have to create your materials(https://developer.valvesoftware.com/wiki/Material). they can be as simple as a single color or an advanced material with light and reflections. it's important that you use the VertexLitGeneric shader for props. the materials are saved as VMTs and the location they should be placed is the one set in the QC, relative to the Game/game/materials folder.
A VMT assigns a role to each texture in your material, the simplest being $basetexture "" (a basic albedo map)
those textures should be converted into VTFs with the tool VTFedit and are conventionally placed in the same folder as the VMT (http://nemesis.thewavelength.net/index.php?c=178)

once all your assets are created you'll want to install crowbar, the tool for importing into source, (https://steamcommunity.com/groups/CrowbarTool) and set it up for your exports. selecting your QC file and compiling it will tell you if there's an error, if there isn't it'll let your "use in view" then "view" to open your model in the HalfLifeModelViewer to make sure evrything is working. If it is you can open SFM and find your model.

https://developer.valvesoftware.com/wiki/Main_Page
this site will be very usefu in looking up how to use any of the tools, commands and files.


The screenshot shows that the Extrude Region tool and gizmo from the toolbar were used. The gizmo is the yellow line with the plus icon that indicates in which direction the extrusion is performed when you click and drag on the icon. You can change the type of extrusion by positioning your mouse cursor on the extrude tool in the toolbar and holding the left mouse button. This will open a menu to select the type of extrusion.

The properties of the operator can be modified in the Adjust Last Operation panel. Use the Transformation Orientation to affect the direction of the extrusion. Please note that your options look different in the screenshot because you've executed Dissolve Selection.

Depending on the type of gizmo additional options may be displayed in the header and sidebar for the active tool. For instance the Extrude Region allows you to choose between the Normal and XYZ option.

Axis Type Normal

Axis Type XYZ

Alternatively you can use the E key for extruding without activating the gizmo.


New to blender trying to figure out how to make a text have a cylindrical side shape

I guess you're looking for a Boolean operation.

Convert your text to mesh (Object -> Convert to .. -> Mesh). This is important! Maybe make a copy of your text object first.
Add the modifier "Boolean" to either object (text, in this case)
Change mode to "Intersection" and select the cylinder in the object dropdown

Optionally: Apply [CTRL]+[A] the modifier and delete unused objects.


How to rotate a selected edit not at center

Please follow the steps as:

Select your point where do you want to set your origin, Hit Shift + S and select cursor to selected, as shown below:

Change your pivot point to "3D cursor" as shown below:

I hope it will be your out put:

Best of luck!


How to convert 3D pose sequences to the bvh format?

OK, found the solution myself. Posting here in case anyone else finds this useful. In the BVH format, the following relationship holds between the joints:

$$pos_j = R_{P(j)}offset_j + pos_{P(j)}$$

where $pos_j$ indicates the 3D position of joint $j$, $P(j)$ returns the parent of joint $j$ in whatever DAG the positions are modeled in (generally the DAG starts at the root and points towards the end-effectors) $offset_j$ indicates the offset of joint $j$ relative to its parent $P(j)$ (aka the connecting limb), and $R_{P(j)}$ is the 3D rotation that determines how much should $offset_j$ be rotated from an initial pose (generally a T-pose). In the BVH format, for each parent $P(j)$, we need to store $R_{P(j)}^{-1}R_j$.

The main trouble I had then was working with joints that had multiple children, for example, the root joint, which has connections to both legs as well as the spine. I eventually came across this repo and digging through their function forward_kinematics inside skeleton.py, realized what to do. Basically, for joints with multiple children, I had to make copies with $offset=0$, and assign those as parents of the corresponding chains. Thus I made 3 copies of the root: one became the parent for the left leg chain, one for the right leg chain, and one for the spine. And similarly for the other parents with multiple children. And yes, the visualization works great!


make invisible depending on point of view

Assuming that the room's normals point inwards, you can accomplish this by using the Geometry node, a Mix Shader and a Transparent BSDF.

Connect the Backfacing socket of the Geometry node to the Fac socket of the Mix Shader node. Next connect your actual material nodes to the upper Shader input of the Mix Shader node and the Transparent BSDF to the lower one.

This effectively creates a backface culling material.

If you're using Eevee, you will also have to set the Blend Mode and Shadow Mode to Alpha Clip or Alpha Hashed. In case you're only using Eevee and don't need a material for Cycles, you can enable the Backface Culling option (above the Blend Mode) instead of using the node setup.

Don't forget to add lights inside the room.

If you only want this for the viewport, then you can enable Backface Culling in the Viewport Shading options.


Exporting UV layout from Blender works fine and there are no options for the export procedure that could result in a shift of UVs so it is extremely unlikely the problem happens when exporting the UV layout.

As the UV layout is exported in a simple picture format any digital image processing software will most likely be able to read it correctly because that is a very basic operation as far as digital image processing goes so it is extremely unlikely the problem is there as well.

We are left with a few very likely possibilities - you either accidentally moved the UV map or you accidentally moved the image or the image of the UV layout. There is really little mystery here - it is very easy to accidentally click and drag an image.

You can select all the UVs (a) and hit g to move them to their correct position. You can zoom in to be precise and also use shift during the operation to increase precision.


The .blend file contains the 3D project.
To create an animation in a video format you need to render it first.
Select the output format and encoding, the name of the file and hit Animation (or CTRL F12

UPDATE:
One of the big changes in 2.79 is that they finally separated containers and codecs.
The encoding options from previous versions are still there, but now they have organized differently
If you select FFMpeg video, there will be a new tab for Encoding options.

There you can select the container and the codec for the output file.
Container is the file format for the file, (Mov, Avi, Ogg, MP4, to name a few) sometimes is referred as a "wrapper".
Codec (short for Compression-Decompression) Is how the image is compressed. The picture quality, file size and processing power needed to view the file are largely determined by the kind of codec used and the settings used for it.


OpenCL option not available in Blender 2.78c running on Ubuntu 17.04

As of march 2017 GCN 1.0 is no longer supported for gpu rendering.
Because the R5 M330 is using that architecture you won't be able to use it anymore in blender.

Sources:

https://wiki.blender.org/index.php/Dev:Source/Render/Cycles/OpenCL#Current_issues_and_limitations
https://en.wikipedia.org/wiki/AMD_Radeon_RX_300_series#Mobile_products


Assuming that the characters of the word are single object, because you want them one object ... so they aren't one object...

Select F and assign a boolean modifier.
For the "object" (see the modifiers panel) assign the "l".
Set mode to "union".
Apply the modifier.
That will give you one object consisting of "Fl" and the "l", which had
not modifier assigned to it...delete the "l".
Now do the same with the "Fl"-object (assign modifier to it) and the "o",
apply, remove the "o". Now "Flo" and the "w" and so on.


How to get original height and width of video strip in python?

I've found that you have to show strip in the VSE viewport to get dimesions to work. Since there's no viewports in background mode, Blender can't update information about a strip you added. So you're getting zeros.


Those ugly creases are caused by the n-gon cap.  The Subsurf modifier works best with quads and doesn't work well at all with n-gons.

Here are two alternate methods of filling the cap which produce quads, and thus much better subdivision modeling.

The first example was made by selecting the n-gon face and then hitting E (exturde) and then S to scale the extrusion inward.  You could move the extruded part up to make the top less flat.
The second example was made by joining half the opposing vertices, making a quad fan.  This could also be done by using the Grid Fill option.  Again, the central vertex could be lifted up to make the top more round.


The default (logic) frame rate is 60 frames/sec. Therefore 60 is a good value for your purpose.

There are more frame rates:

Animation frame rate (usually 24 frames/sec) used to play actions.
Physics frame rate (usually matching the logic frame rate) to calculate the physics influence to a scene. Be aware it can be even finer with so called-substeps. More sub steps increase the precision of the physics calculation (but costs more processing time).
Render frame rate (usually matching the logic frame rate) which tells how many images are rendered. If a frame lasts too long (exceeds the 1/60 time available) the BGE starts skipping the render trying to meet the frame rate. This can happen up to 5 times in a row. After that there is a forced render ignoring the time limit. The render frame rate is never higher than the logic frame rate as it is assumed there is no change to the scene and the output would be the same.

But:

I suggest to avoid this method to measure time. The BGE will try to keep the given frame rate as much as possible, but there is no guaranty.

I recommend to use a timer property. It counts the seconds. I think that is what you really want.

Then you have several ways to show the time. I think you want to format it to minutes:seconds. You can use this little script timeToText:

import bge
from datetime import datetime

textObject = bge.logic.getCurrentController().owner
time = datetime.fromtimestamp(textObject["time"])
textObject.text = '{:%M:%S}'.format(time)

It expects a property time to provide the seconds and should be applied to an text object.

You can indeed refresh the display each 60 frames. But you will not know when the seconds changed. Therefore I suggest to run it constantly.

Hint: If you want to show microseconds too, use this format: {:%M:%S.%f}


Why is the subsurf modifier not creating smooth geometry?

Scale along the Y axis to 0 (S > Y > 0), delete the faces (X > Faces), and remove doubles (W > Remove Doubles). The issue you are having is there are internal faces, if you just remove the doubles, then there is still a face inside of the mesh, which leads to this weird artifact.


Viewport Artifacts when working with big scales

Changing the clipping to:
Start: 1m and End: 1km
as suggested by @user1853 worked!


Open the properties panel in the viewport by pressing N. Then, under the "View" tab of the panel, check "Lock Camera to View".

Go into camera view mode, and then move around the viewport however you want (e.g. in walk mode) and the camera will follow.


Try to press the 1 button on your keyboard (not on numpad) in object mode. You are maybe viewing different layer. This happened to me a few times.


Partially disable File Output Node in compositing?

If you output to multiple png files, there is no downside to having separate File Output node for each instead of the one with many inputs. You can then select the ones you want to temporarily disable and press m for mute. If you had multilayer EXR that would be a problem, but since you only need to output separate PNGs, that should work fine. Disconnecting inputs also seems elegant enough for me.

You can also use this new node Switch (Blender 2.80) that you can find in Add -> Layout -> Switch

It gives you a checkbox and you can hit ctrl+h to hide unused inputs when you have it selected as you can see I have done on the first one for it to be more compact. It seems to be animate-able, but I have not tested it.


How to make a tetrahedron solid and grid?

This is fundamentally impossible because (surprisingly!) the platonic tetrahedron is not space-filling.
The dihedral angle of two adjacent faces of a regular tetrahedron is arccos(1/3) ≈ 70.53. So if you put 5 regular tetrahedrons together it makes 70.53*5=352.65 which is not quite the 360 you would need to fill space.


Add Image to Blender's VSE fails to display alpha channel transparency

Blender won't handle an alpha channel in a codec. Alpha in a codec is largely a nonstandard practice.


How to subframe particle emitter parented to a Bone?

The only one way I found is to use Output Properties > Dimensions > Time Remapping

Top row are particles emitted from animated Plane.
Bottom row are particles emitted from Plane parented to Bone.

Notes:

Subframes doesn't help because issue is related to a Bone that jumps to next frame (same as anim Plane, but there (for some reason) it works as expected.
For that I tried to add Step Modifier, that let you add steps even in between two frames (or negative), but even steps were visible on Timeline, zero influence for particles as well.

Constraint didn't work (parented Plane to Armature as well)

I didnt post this answer almost week ago, just because when I tried it I probably didn't refresh cache to see influence ... the only one way to refresh cache that works for me is to change Number of particles every time I do same change in setup.

Edit
According to this closed bug report from 2014 it is marked by Sergey as known limitation planned to be fixed with new particle system. Lukas created already fix at the same year, but wasn't published and was moved on TO DO list
But check blend file attached on bug report link. You have two other options

Bake Action
Constraint > Follow Path


Triangle fan is not needed to achieve round shapes. Use 4-sided faces whenever possible. Try something like this:

You can also add Subdivision modifier at early design stage to see how the shape is rounded nicely even with low amount of faces.


How to connect/bridge those edges most efficiently?

You can't really do it "without nonsense" since the other side has way more vertices than the other. You would need to either add some vertices to the farther side or remove some on the closer one. You should tell how you want it to end up so it would be easier to fix your problem.


Can i open the linked object to another blender session from current scene?

Found it. There's cool builtin addon : edit linked library.
https://docs.blender.org/manual/en/2.83/addons/object/edit_linked_library.html
I simply click the button on the side bar and it will take me to the linked .blend file , edit it and use the sidebar again to go back to previous blend file.


Error rendering on ec2 : Specified pix_fmt is not supported

Chances are your remote FFMPEG is missing one of the legion of codecs when it was compiled. You will need to use a version compiled with the codec required.


How to get rid of artifacts in corners - Bevel Object

Moving your Bezier Curve's origin (that you use as your Bevel Object) to the "outside" of your Curve will solve your problem:

Your Origin is now "in the middle of" your Bezier Curve so that your Bevel Object can't be moved along your rectangular path without these artifacts.


How can I crop and export parts of STL Objects?

Have you tried looking into the Boolean modifier?

If you object is a closed, watertight, manifold mesh you could use Boolean operations to break it into chunks of the desirable parts.

Just create a new closed watertight mesh object that as a shape or volume that engulfs or includes the part of the STL you want to keep and use it in a Boolean operation to intersect with the existing mesh and extract the part you want.

You can also try the Knife Project operator if a simpler cutting or slicing of the original geometry in one direction will suffice to obtain what you want.
You can use something as simple as a plane or a bezier curve to cut your geometry in the desired way.

Edit If your object is already composed of separate parts but all joined in a single object you can simply enter edit mode, select them all press P to separate them and select the option All loose parts to divide them into different objects.


How can I connect two edge loops with different numbers of vertices?

You have two options, which will both provide similar result here.

Edge > Bridge Edge loops
Face > Fill, Alt+F

As @vklidu pointed out, Face > Fill gives different results in many cases, notably  when some faces are flipped.


Is there a way to have my second action animation start at the last location of my first action animation?

For anyone with a similar problem to mine, I found the best way to resolve this issue is by adding a path for my character to follow. Using the shortcut Shift A, and selecting the Path option under Curve. I completed these steps in Object mode. I suggest searching for videos on how to create a path for walk cycles if you need further help with that step, I found many great resources on youtube.


How can elements be selected and moved properly?

The problem is with the mirror modifier. You already have your entire object completely meshed out, but are then mirroring it over on itself. The extra geometry that you are unable to edit is actually the mirrored mesh from the other half.

You should delete half of the mesh so that the mirror modifier isn't flipping the mesh over onto itself.


Smoke Render Not showing Smoke but the Flow Source(Particle System)

You need to uncheck emitter in the render panel of the particle system.


Rendering Freestyle along with Grease Pencil

This isn't a perfect solution (I don't know that there is one, at least as of 2.82) but when faced with the same problem, I added a utility mesh to put behind the grease pencil object, just so that the freestyle pass knew to obscure whatever was behind the mesh.  In order to stop the utility mesh from itself creating freestyle lines, I added to a collection that I then excluded under Freestyle Line Set.  I'm animating my grease pencil object using an armature, so I parented the utility object appropriately to the same armature, so it moved in sync with the grease pencil drawing.

Another cleaner possible solution, depending on what your scene required, would be to render the grease pencil object and the 3d environment separately and composite them together afterwards, but that only works if you never want any of the rendered objects in front of the grease pencil drawing (though, of course, you could also composite more than two renders together, but this could get more complicated than the first solution).


Transfer weight paints / copy vertex groups results in destroyed mesh

Warning I answer here about the weights transfer problem but this answer does not handle the "one armature" mentioned at the begining of the question.

From my experience, this approach can work only if the 2 meshes (the prerigged source and the destination to be rigged) are very close to each other.

This can be done more or less easily using mainly mesh deform and shrinkwrap modifiers and eventually doing a quick parenting (with automatic weights) on the source mesh (a copy of it).

Mesh deform or the parenting are here to bring the source mesh closer to the destination. And the shrinkwrap is here to give more accuracy to the correspondance of the two meshes.
In this process, you'll need to take into account each bones junctions by placing the (temporary) deformed mesh in accordance to these junctions.

If all these conditions are not met, the data transfer wont work correctly (this is at least my experience).
Also, the point is to evaluate the shorter process : rigging again your other meshes or using this kind of method.

If you choose the data transfer, you'll probably need to use "projected face interpolated" option and eventually the ray radius value (not to low and not to big). Becareful : these options may needs much more calculation time.

Edit 1/note : I encountered some problems with the "data transfer modifier" as the "Data transfer / data" in the tool panel works well (shortcut CtrlShiftT) (same function and options but not a modifier).

Edit 2 : another approach, dependy on the accuracy you need for the rigging :

Copy the armature
Adapt it (edit mode) to your destination mesh
Parent the destination to this armature copy with automatic weights
Reparent to the original armature (with empty groups)


How to iterate name of output image name in blender via python?

Just call RenderSettings.frame_path() which returns the absolute path to the filename for a given frame or concatenate your string like  ".../folder/image_" + str(250) + ".jpg"(error prone due to OS differences).

Proof using the Console:

>>> rd = C.scene.render
>>> rd.frame_path(frame=250)
'/tmp/0250.png'

For multiple render iterations, I'd suggest append the iterator to the filepath:

C = bpy.context
rd = C.scene.render

for r in range(1,3):
    path, ext = rd.frame_path(frame=250).rsplit('.', 1)
    multi_path = path + "_" + str(r) + "." + ext
    print (multi_path)

Terminal Output:

/tmp/0250_1.png
/tmp/0250_2.png


Why does sculpting with dyntopo produces small cracks on the mesh surface?

The first screenshot shows big amount of faces stretched horizontally really much, probably as a result of dyntopo atop of already subdivided mesh with maybe not proper base topology. They are bulging out of the model, most likely as a result of the brush drawing.

In short, don't use dyntopo in this case. It is useful for rough and quick adding details when e.g. base and draft sculpting is done; it's possible to do the final mesh with it only as well, but not mixing it with Subsurf or any other type of subdivision. The reason to use dyntopo is to selectively subdivide mesh where needed and sculpt it at the same time. On the other hand in the case shown you have big amount of geometry which as you see will prevent you from easy editing. Further, it's mostly useless as much less geometry is pretty much enough for showing details.

The thing also to keep in mind is that if you need more details continue subdividing the mesh relatively equal for all its surface. There are plenty of tutorials about subdivision while sculpting which will show you that in more details.

The easiest solution is to undo dyntopo (using backup copy of the mesh is assumed) and go with Multires only (instead of Subsurf). Then it will be possible to go with clean topology as much as possible while leaving base mesh relatively simple (Multires will do that for you).

If dyntopo is undoable then it's possible to use it for unsubdividing as well, just enable Collapse in the Dyntopo rollout and continue scultping on the mesh while checking what geometry it generates.


Why are portal area lamps slowing down my renders?

Portals have limitations — it depends on how "open" your scene is

As mentioned by @Leander, the blender manual says that portals are not good for "outdoor" scenes.

portals lamps provide diminishing returns as your indoor scene becomes too "open"
in other words, if your indoor scene has several very large windows, you may be better off without using the portals (because the cost of portals starts to outweigh the benefits)
in my experience, I found portals to be unfit (by a narrow margin) for an indoor scene where I have a room with a whole wall basically missing (huge floor-to-ceiling window), and also an open doorway in one of the intact walls (think of a garage with the big door open, and also a side-door open too)


How can I get physics objects to for a tight container?

Very fast or small objects seem to miss the collision detection. Keeping objects bigger and slower manages this issue.


Rendering single .exr from passes with different shaders?

The first tutorial lists a number of different shaders that may have their own render pass. Cycles doesn't separate the render result based on the shader used, cycles uses node based materials that can combine many different shader types to get the final result.

In cycles the passes that are available will each contain a portion of the scene that when combined makes the final image (or render layer). The way that the passes are combined is shown in the manual and has been explained in a few video tutorials. If an object's material has only a diffuse node then all the information for the object will be in the diffuse pass. If it has a mix of diffuse and glossy then it will have information on both the diffuse pass and the glossy pass that when combined give the final appearance of the object. When saving a render to an OpenEXR Multilayer file, each render layer and it's passes will each be saved as a layer in the one file.

The second tutorial you linked to talks about creating object masks and combining them into one OpenEXR file. We have a few options to perform a similar task. Every object can have an ObjectID and every material can have a MaterialID. These ID's can be used by an IDMask node to get a mask matching the object/s or material/s with the same ID. We can also assign a single material to a render layer that makes every object visible on the layer render using the same material.

When using the compositor we have the option of adding a File Output node. If an OpenEXR Multilayer format is used for the file output then we can add as many layers as we want and choose what goes into each layer, that may be a direct render pass result, an edited and combined result or even object masks. When other file formats are chosen each input will be saved to a separate image file.


set random active face in python without toggle mode

Random active face

Please heed the advice given in comments above.  One of the (IMO) dopier rules on bse is the inability of new users to comment.

Noticed your deleted post here re Deselect Neighbours Faces

Here is a test script using method outlined in https://blender.stackexchange.com/a/81425/15543  Sets a random face active, and selects it.

import bpy
import bmesh
from random import randint

def random_face(bm):
    bm.faces.ensure_lookup_table()
    return bm.faces[randint(0, len(bm.faces) - 1)]

context = bpy.context
ob = context.edit_object
me = ob.data
bm = bmesh.from_edit_mesh(me)
print("before", bm.faces.active)
bm.faces.active = random_face(bm)
bm.faces.active.select = True
print("after", bm.faces.active)

bmesh.update_edit_mesh(me)

To also make the face the active select history

bm.select_history.add(bm.faces.active)
print(bm.select_history.active is bm.faces.active)


Join function creating unwanted edge loop?

What you see is what I would call unexpected behaviour of the Vertex Connect Path tool, this is the tool that has a J shortcut.

The expected behaviour is to add an edge between selected vertices, existing faces are cut through in the process. In your example the missing face between the selected vertices causes this to take the long way around the entire object, effectively cutting an edge loop around the whole model.

To get the result you expect, the space in the middle needs to have a face.

In the tutorial, at that stage, the hole is filled in with an n-gon before using J to cut it into quads.


Move object towards/away from camera in 2.8?

Change the Transform Orientation to View

Now you just press G to grab along Z.


Viewport only showing objects in camera shot

AltB (or the corresponding menu 'View/View Regions') can be used to define (or remove) a 3D clipping region.


Know all the mesh selection tools.

In your case the Lasso or Circle Select tool could help.

Other mentionworthy tools:

Expand Selection - ⎈ CtrlNumpad+
Reduce Selection - ⎈ CtrlNumpad-
Select Edge Loop - ⎇ Alt RMB

You could also use a boolean modifier.

Select the torus and apply a boolean modifier with the cup as Object and the Method to Difference. Apply the modifier. Now you can use the Select Linked Tool L to delete the unneeded vertices.


Blender 2.83, was sculpting and suddenly my smoothing brush stopped working

In the Properties sidebar, go to Stroke > Stabilize Stroke and turn it off.
Stabilize Stroke basically drags the "actual" brush behind your cursor when sculpting. This results in a red line indicating the distance the actual brush is from the cursor. I do believe this red line is resulting from Stabilize Stroke.


Why does this plane's UVs distort when there is exactly one Subsurf subdivision level set?

Each quad face is always made of 2 triangles in 3D softwares. I guess the result you see has to do with the way Blender will triangulate each of the 4 faces it creates when it subdivides.
Here I use a grid as image texture to make it more understandable. On the left, the original object, on the right, subdivided once. Here is how Blender triangulates:

If I select my original object, cut edges the same way to make only triangles, and turn the outline into a circle, I'll have the same result:

It would work better that way:

With a higher subdivision, the problem tends to be less noticeable.


How to get rid of excess vertices lined up in a straight line

Someonewithpc's answer is almost right. The correct operator for this purpose is located in the same menu, it's the Limited Dissolve. It allows to limit the max angle, so setting the value low enough will remove only the excess vertices on straight edges.


You have to change the layer or priority of one of the action actuators :

OR

instead of having two actuators and activating and deactivating the other one, you can use just one and switch the used action :

import bge
cont = bge.logic.getCurrentController()
own = cont.owner
sens = cont.sensors['Move']
if sens.positive:
    if own['Y Axis'] == 1:
        cont.actuators['Axis'].action = 'Action1'
        cont.activate(cont.actuators['Axis'])
    else:
        cont.actuators['Axis'].action = 'Action2'
        cont.activate(cont.actuators['Axis'])


"Fade out" with Blender internal engine?

Certenly is possible, but you have to consider that Blender Render and Cycles handle transparecy in a different way, so you'll probably have to make a few adjustment to your scene to get similar results.

You can animate the alpha factor directly from the Material's menu

Or the alpha output factor in the node editor (if you are going for node based material).

Don't froget to enable Z Transparecy or Raytrace option for transparency calculation method (for node based material you can find it under Render Pipeline Options).


How can I turn off mirroring in sculpt mode?

If you want to disable/enable symmetry when sculpting, go to sculpt mode, then select/deselect the axes in the tool panel under the Symmetry/Lock section.

See Also :
How to disable Symmetrize in Sculpt Mode?


Transform cube face in the z up direction to vertice above (need automation method)

You may be asking for the DupliVerts feature.

In this case, the general steps would be:

Move the origin of the cube to the center of its top face;
First select the cube, then select the vertex cloud object, press CTRL P > Object;
Keep the parent object (vertex cloud) selected, go to Properties > Object Data > Duplication, select 'Verts". As shown in the image below.

P.S.: Remember to keep their origins staying at same location.


How to delete recorded position of mesh on animation timeline?

You set the handle as a rigid body. The yellow line in the timeline shows you how much of the physics Simulation is cached. To delete the rigid body and all of the motion calculated from it Select the handle, then in the physics tab of the tool bar press remove.

You can also get to the physics settings in the physics tab of the properties window.


How to copy keyframes from one action to other

this script will copy the animation data from the active Object to the selected object:

import bpy

active_obj = bpy.context.object
ad = bpy.context.object.animation_data

properties = [p.identifier for p in ad.bl_rna.properties if not p.is_readonly]
objects = [o for o in bpy.context.selected_objects if o.type == active_obj.type]
objects.remove(active_obj)

for obj in objects :
    if obj.animation_data == None :
        obj.animation_data_create()
    ad2 = obj.animation_data

    for prop in properties:
        setattr(ad2, prop, getattr(ad, prop))

here is test run :


Cycles + Glass + Light, Preview different than render

There are one or more objects, which are visible in the viewport, but hidden in the render.

Tick the camera symbol for all objects, which are supposed to be rendered.

If you want to clear all render restriction, go to the 3D Viewport, and press W in Object mode and choose Clear All Restrict Render.


Can we change the frame rate for a video to 24 after the image sequence is rendered with a different fps, say 30?

To my knowledge using another frame rate while rendering an image sequence will ,without changing anything else, change the quality of the output video because a different number of the images out of the sequence will be shown in the output video per second. But the other more noticeable effect would be that by packing a different number of frames in each second you would effectively speed up/ slow down the output video.
It is possible to correct for that speed up in the strip options under time, but you run into another issue: While the video is paused it makes no difference in quality, but if the rendered frame rate of the image sequence is not a multiple of the the new frame rate it can lead to glittery motion. This happens because blender sometimes would need frames that lay between the given frames in the images sequence. Because that is not possible it has to decide for one of those frames. The distance between the chosen frames can vary, sometimes be 1, sometimes be 2, so in the rendered video the motion seems to jump.
so most of the time it makes sense to stick to one frame rate from start to finish.

For why the frame rate needs to be able to be changed even if you render an Image Sequence:
One simple reason is that the viewport animation works with the same frame rate so to change that you need that option exposed.
Does that answer your questions?
I hope my explanation makes sense.


Apply all modifiers, .poll() a bpy operator with keyword argument?

The short answer is no, poll checks that the basic context is valid but it doesn't do extensive checks that every operation will succeed (It's often not trivial for tools to know this ahead of time)

You can simply use exception handling for this.

for mod in ob.modifiers:
    try:
        bpy.ops.object.modifier_apply(modifier=mod.name)
    except RuntimeError as ex:
        # print the error incase its important... but continue
        print(ex)

In this case I think you would be better off using,

bpy.ops.object.convert(target='MESH') - converting a mesh to a mesh will replace the mesh with a version that has modifiers applied.
Object.to_mesh() - gives you most control, uses Pythons internal API.


How can i add more duplicates to a curve?

You can adjust the amount and density of dupliframes from two different parameters.

Adjust the density of duplicated objects from the number of Frames in the Curve Object data > Path Animation > Frames*. A higher number will yield a denser amount of duplicated objects.

If increasing the value high enough gives too few objects to fill the whole curve, then select the duplicated object and under Object > Duplication increase the End Time value so it fills the whole curve again.


Shapekeys before or after normal mapping?

First of all, is your character using a Mirror Modifier to generate symmetry? If it is, you should apply it first before doing your UV mapping, texturing, rigging, and shape-keying. (Symmetrical UV maps are OK in some special cases, but definitely avoid them if you will need to use a Normal Map.)

As for creating a low-poly mesh from your high-poly one, check this technique out. It might seem a bit confusing if you're just starting out, but understanding it can save you a lot of time when creating your low-poly meshes.

Your Normal Map will not change with the Shape Keys, nor should it need to unless you're trying to do something overly complex.

Use the high-poly mesh to bake your maps onto the low-poly mesh. Keep both handy, and only delete your high-poly sculpt once you're done baking textures. Keep a version of your project saved that still contains your final sculpt in case you need to re-bake later.


Does FLIP fluid support more then one domain in one scene?

The FLIP Fluids addon does not support more than one domain in a .blend file at the moment. A workaround to have multiple simulation animations in a scene is to export the simulation to the Alembic format through File > Export > Alembic (.abc). Once exported, you can import the animated Alembic files back into your scene.

More information can be found in this documentation topic: https://github.com/rlguy/Blender-FLIP-Fluids/wiki/Alembic-Export-Support


Is there any way to change viewport preview pass through script?

Developer Extras
Relying on the info area to write scripts is IMO not the way to go.
Some posts explaining how to find what the property is.
Changing the shading type in Python
Blender python : How to set object appearance in viewport?
With developer extras turned on mousing over the property

Telling us the type and its property of interest View3DShading.render_pass  For a 3D viewport, will find any property setting belongs to the space.   Scrolling to References at bottom of page confirms this ie SpaceView3D.shading is an instance of View3DShading
To the python console:
>>> for i, a in enumerate(C.screen.areas):
...     i, a.type
...
(0, 'PROPERTIES')
(1, 'CONSOLE')
(2, 'VIEW_3D')
(3, 'TEXT_EDITOR')

Area 2 is a view 3d, its active space
>>> space = C.screen.areas[2].spaces.active

The render pass property of shading group
>>> space.shading.render_pass
'COMBINED'

Set to something else.
>>> space.shading.render_pass = 'MIST'
>>>

Note in a script to run from the context of a view3d, then use
space = context.space_data


camera clipping settings not extending far enough

Welcome to Blender Stack Exchange!
There's actually 2 different clip distance settings. One is for the viewport, but the camera also has its own separate clip distance, which is probably set too low.
With the camera selected, you can find this in the camera tab of the properties panel.


Yes, you can get it without moving the cursor.

    import bpy

o = bpy.context.object
vcos = [ o.matrix_world * v.co for v in o.data.vertices ]
findCenter = lambda l: ( max(l) + min(l) ) / 2

x,y,z  = [ [ v[i] for v in vcos ] for i in range(3) ]
center = [ findCenter(axis) for axis in [x,y,z] ]

print( center )

(That was not made by me)

Will print the location of the active object.

Note, in the image it shows
[5.960464477539063e-08, -1.1920928955078125e-07, 3.3469696044921875] instead of [0, 0, 3.3469696044921875]
 but it's a super tiny difference of at most 0.00000011920928955078125


How can I select all objects with the box select tool in blender 2.8?

Alt+Z to enable X-Ray mode. 'Box/Circle/Lasso Select' then picks up everything.


How to disable only a visual in renders and not the effect

Of course there is a way.

You need to make your fish image transparent.
Not the whole image, just the grey parts.

Here is how you do it:
01) Use Photoshop, Gimp or other software to remove the fish image background.
02) Save it as a PNG.
03) Add it to Blender and set the nodes like in my example.

Remove image background

Enable transparency for your image


where can I set the axis for the simple deform modifier ?

You can add an empty and chose it as origin object in the modifier on the deformed object.

By rotating the empty you can change the direction of the deformation.


Why can't I access the 'name' of an object when looping through the scene's objects?

enumerate(iterable, start=0) returns a tuple for each element from any given iterable and its position based on the actual iteration. Proof using the Console:

>>> for i in enumerate(["Hello","World"]):
>>>     print (i)
(0, "Hello")
(1, "World")

A tuple is a composite data type, composed out of two elements (item1, item2). If you want to access its individual components (left, right) you can either use the index operator [] or create 2 variables for the actual return value (tuple) on the fly: left, right = ("Hello", "World"):

>>> my_tuple = ("Hello", "World")
>>> my_tuple[0]
"Hello"

left, right = ("Hello", "World")
>>> left
"Hello"

Means in your case that you can't access the object and its name this way because the returned tuple by the enumerate() function in your loop has no name property. Proof using the Console again:

>>> for ob in enumerate(C.scene.objects):
...     print (ob)
(0, bpy.data.objects['Cube'])
(1, bpy.data.objects['Light'])
(2, bpy.data.objects['Camera'])

In summary: you have to find a way splitting the components of the tuple if you want to access each element separately which basically leads into the following pattern:

>>> for left, right in enumerate(C.scene.objects):
...     print (left, right, "Name:", right.name)
0 <bpy_struct, Object("Cube")>, Name: Cube
1 <bpy_struct, Object("Light")> Name: Light
2 <bpy_struct, Object("Camera")> Name: Camera

Also notice that python has a lot of awesome tools dealing with strings. In order to determine whether a string is part of a another string (substring), you could use the in operator to test its "membership":

>>> "ell" in "HelloWorld"
True

To remove the objects, you might want to create some kind of black list before removing it. The following example removes all objects in the scene that have "Cam" in their name (substring):

import bpy

objects_to_remove = []

for ob in bpy.context.scene.objects:
    if "Cam" in ob.name:
        objects_to_remove.append(ob)

bpy.ops.object.delete({"selected_objects": objects_to_remove})

There is also str.startswith(prefix) returning True if the string begins with the prefix passed:

>>> "Hello World".startswith("Hell")
True

The following example removes all found objects whose names begin with "Cam":

import bpy

objects_to_remove = []

for ob in bpy.context.scene.objects:
    if ob.name.startswith("Cam"):
        objects_to_remove.append(ob)

bpy.ops.object.delete({"selected_objects": objects_to_remove})


snap perpendicular to an edge/line like in CAD

It can be frustrating in other ways, but this just happens to be what the Blender snap system does without add-ons.

Set snap to 'Vertex' and 'Active'
CtrlAltSpace Create a Custom Orientation from side B. (Check 'Use after creation')
K Cut an edge from side A to side B
With Snap on,  G Y Ymove point B up and down its edge

When you hover over point A, it will snap to  the point on side B from which a perpendicular is dropped to it.

What if the new edge isn't in the right place?

Cut another edge, and  G G slide it up and down the face, making the edge parallel to the correctly oriented one by hitting  E, and  F if necessary.


How can I store an animation action for later use?

Stash Them.
By stashing the actions we are doing little more than using the NLA as a bag to hold them, and associate them with their object.  If the object is linked or appended to another blend all the actions will come too. (Similarly with many export formats)  Pushing them down adds a track and action strip contributing to the animation result. Stashed actions do not.

Example of Action Editor above NLA Editor, with 3 previously stashed actions, Hop, Throb and Spin.  The new action "Walk" is in the slot, then stashed too.

To save an action it only needs to be stashed once.

Adding a new action to the slot in action editor automatically
stashes the prior.

The stashed animations do not contribute to the animation result.
(They are disabled by default), whereas those that are pushed down
do.

The top shown animation in the NLA editor, is the one in the slot..
(I call the active action the one in the slot, like putting a record
from your stash on the turntable. ... pushing down on the other hand
is like having multiple turntables, and some kind of mixing is
required. Would generally say if you are going to use NLA to animate
don't have one in the slot (unless editing)

Can select a stashed animation in the NLA and hit Tab to
put it in the "slot" to edit. (tweak) Shown as green in my colour scheme.

Have demonstrated editing by dragging keyframes in action editor, if
it's in the slot can also use timeline, dopesheet or inserting in 3d
view or over property field, or in graph editor to edit.


Yes. You can change the path in Physics > Fluid with the domain object selected:


How to make overlayed composited images stay intact while changing render resolution?

Scale node set to Scene Size mode will scale image accordingly to the render resolution:

  Scene Size
      Sizes an image to the size of the final render resolution for the scene. For example, rendering a scene at the standard 1080p resolution but setting the render percentage at 50%, will produce a 1080p image with the scene scaled down 50% and leaving the rest of the image as alpha.

If feeding it with original image and then plugging the output of the node into nodes shown in the setup above it will work for different render resolutions:

The node setup will be the same with the only difference that now it has 1 additional Scale node.  Fit option used here which is the easiest one for preserving image original ratio:


here's a grid OSL shader I wrote a while back.

/*
  Grid Lines
  : Author Dealga McArdle, 2013
  : modified from Sine Stripes by Thomas Dinges

  example shaders:
  http://www.openshading.com/osl/example-shaders/

*/

#include "stdosl.h"

shader GridShaderUV(

    // input and output parameters
    vector Vector = P,
    color GridColor = color(0.8),
    float Intensity = 1.0,
    float Distance_U = 0.02,
    float Distance_V = 0.02,
    int Stripes_U = 10,
    int Stripes_V = 10,
    output float Fac = 1.0,
    output color Color = color(0.8),
    float World_X = 1.0,
    float World_Y = 1.0
    )
{

    // shader code
    point Pos = Vector;
    Pos[0] -= World_X;
    float pattern_col = 0.0;

    for(int i = 0; i < Stripes_U; ++i ) {
        Pos[0] += Distance_U;
        pattern_col += abs(Intensity / Pos[0] / 1000.0);
    }

    Pos = Vector;
    Pos[1] -= World_Y;
    for(int i = 0; i < Stripes_V; ++i ) {
        Pos[1] += Distance_V;
        pattern_col += abs(Intensity / Pos[1] / 1000.0);
    }

    color C = transformc("hsv", GridColor);

    Fac = pattern_col;
    Color = color("hsv", C[0], C[1], (Fac*C[2]));
}

It generates a grid of black vs some user defined colour. There are many ways to use it, but to get a feel for it I suggest sticking it as a material on a Plane, and see what the sliders do.

If you add a Suzanne, you could set the Stripes U and V to 1 so there's only one grid line, then animate the Distance X between the extents of your object., and you'll get the laser scan effect. Or animate the WORLD X,Y as they are the center of the shader's coordinate system.

Looks like this

It's a grid osl, therefore capable (and intended) to make grids.

Alternatively, xyz banding

remove the axis you don't need. You can offset the Geometry position by some vector amount if the missing Axis band (0,0,0) bothers you


If there are triangles in your mesh the Subdivision Surface modifier will not play nice. It wants to have only quads. If you find that this is indeed the issue, you can try to fix it by remeshing your model. The easiest way to do that may be to use the new QuadriFlow Remesh option (rather than the standard Remesh modifier, which is harder to get good results with right out of the box). Make sure you are either in Object Mode or Sculpt Mode (NOT Edit Mode!), then bring up the search field (F3) and type in Quadriflow Remesh. Select it and a window appears where you can enter settings. Play around with it. It's actually pretty straightforward. When you get your model rebuilt as all quads, the Subdivision Surface modifier should work.


Using Curve modifier inevitably leads to some deformation.
In this case, try the following.

Change curve spline type to Bezier
Move the handles a bit closer (that will correct the geometry)
Increase the curve resolution to 128 (that will improve corners)

Change Spline Type to Bezier and move the handles a bit.

Increase Curve resolution to 128 to improve corners


How do I import a custom icon set in the theme options?

Currently, you can't.
In 2.67 there is a button in the theme preferences, but since this is non-functional its been removed for 2.68.

Note that you can of course build your own blender from source with modified icons and fonts but this is outside the scope of stack-exchange.


Hide an object from reflecting in the ocean modifier using nodes

This answer uses a reflexion plane for the mirror. And it seems that "Screen space reflections" alone won't produce the wanted ligth path.
Consider adding a "reflexion plane" and scale it until it covers the grid reflexion area:


How to bridge edges without creating a twist?

With those faces selected use ctrl-n to activate the Make Normals Consistent operator.  If their orientation afterwards is not to your liking, use the Inside checkbox in the operator options panel to flip them.  If you can't find that checkbox, go ahead and use the Flip Normals operator in the Mesh > Normals menu.

If this does not work, then the face sets probably do not share an edge.  Maybe the Remove Doubles operator will fix that problem.  Or you could just select the normals that are facing the wrong way and use Flip Normals on them alone.


Try using remove doubles in the tool shelf (T) while having the part selected where the edges are separated. You can increase the merge distance beneath the tool shelf. If this doesn't give you what you want you can do it manually by zooming in to the edge that you want to correct in vertex select mode and selecting the two separated vertices. Then press Alt M and choose the option that's the best for you, probably at center.

Side note: Please make clearer question titles. 'Question about Sculpt Mode' is pretty general and nobody really knows what your question is about. Something like e. g. 'Connecting separated edges' would be better. Keep that in mind.


In texture menu is only World and Brush to choose

Problem solved I guess... When I change render mode to Blender render and add new voronoi texture, change influence to length then change it back to cycles... the effect retained... suddenly the particles appeared in rolled up menu above. Thanks everything for helping me :-D


The reason is quite simple: transmission depth

In the real world, if you look at a glass of water, it is transparent, while the sea is blu.
That's because when your partially transparent material is thicker, more light is stopped and its color becomes darker.

You can see in your scene that the bowl is much larger than the tube, so it stops more light.

if you watch it from above you can see that the bowl is now lighter, because the light has less material to go through, and its color is similar to the tube

So, if your goal is photorealism, this scene is accurate.
If you want them to be the same color you can "water down" (make the color lighter or the transparency higher) the liquid in the bowl, but then it would become physically incorrect


You have to put a color ramp in front of the multiply node to crush the noise node input into something workable with a color mix.


Some dirty ways

1) Inset faces

Here's a possible workaround based on Inset faces (Individually), Dissolve edges and Extrude (Vertex normals) . It won't give you perfect results, but maybe can help.

First step is select all, than press I twice and tune the inset amount.

Switch to vertex selection and invert selection. Store the selection in a vertex group. Invert again and delete the faces. Than select the items from previously created vertex group and run Dissolve Edges command.

At this point we should have obtain a pletora of n-gons, most of them will probably be non flat and have other issues, but they should approximate our mesh not too badly.

Extrude the Region along Vertex Normals by an amount that may do the section look like if it is a square (or a rectangle) and you'll get the illusion of a squared section wireframe.

Result:

This method works best when there is a smooth transition in surface's curvature. For the 90° degrees angles of the image below it was needed to fix the n-gons (with Split Non Planar Faces command) as their non-planar nature was too pronounced:

Notice how the polygon below the gizmo is clearly distorted.

2) Bevel Wireframe modifier

Another possible workaround could be to take advance of the wireframe modifier:

Add and apply a Wireframe modifier:

Select one vertex of the four that marks each hole and then extend selection to all the vertices that has the same amount of connecting edges

Invert selection and then Bevel the edges connected by the freshly selected vertices

Invert face selection, delete the faces and then delete one of the two resulting mesh pieces too.

Finish by extruding the faces with a Solidify modifier with an appropriate value of Thickness (to match the beveled edge lenght).

Final result:


Can multiple animations be saved in a .blend file?

I think your issue is that Blender is not saving the animation datablocks because there aren't any objects using them. You can protect the datablocks by adding a fake user like so:

Go to the NLA editor

Select the Action

Open your properties panel (N)

In the top panel (Animation Data) select the action you want to protect from the dropdown.

Click the F next to the name to give the action a fake user:

Alternatively this can be done in the header of the Dope Sheet editor while in Action Editor mode.


How to get custom menu items show up in the search bar?

All the math node operations
Note: this doesn't answer how to put your operators into the search, rather is intended to offer another way to have same functionality in a far more easily extendable way

From one look at the question code instantly has me quoting

Foghorn Leghorn
No, no, no your're doing it all wrong

No menus one operator
Have taken code above and edited to have functionality as demonstrated, with no menus and one operator.
All the question operators are doing pretty much the same thing, the code varies little between them. Instead of an operator for each operation, one operator and an enum of possible operations.
The tricky bit.
When we add a math node, we add an instance of the type bpy.types.ShaderNodeMath.  All the possible operations are available from its definition of the "operation" property.
[Look for links, been well covered]
Our one operator is going to pinch these.
The menus can be ditched because blender can automatically make a menu from the options.  And boy there are a few.  The items list can be narrowed to a select few if desired
Categorize the other way
The naming convention of your operators is, going by "standards", a bit A about T. Using "node.add_math_subtract" will classify it with all the other bpy.ops.node prefixed operators.
Operators use context
For any code run in the shader editor the material we're "lookin' at" is context material. This is the material the bpy.ops.node.foo_bar will work on.  This will not always be bpy.data.materials["Material"]
Similarly only the first math node added via operator (bpy.ops.node.add_node(..)) will have the name "Math".  Hence on subsequent runnings of question code will add a new node but change the operation of the first one added, ie the one with name "Math".  Directly after running the operator the new node will be context.active_node .. another context member of the node editor.
Have instead added a math node to the node tree of the context material and set its operation and name accordingly.
import bpy
from bpy.types import Menu, Operator, ShaderNodeMath
from bpy.props import EnumProperty

class AddMathNode(Operator):
    ''' Add Math Node '''
    bl_idname = "node.add_math"
    bl_label = "Add Math Node"
    items = [
        (p.identifier, p.name, p.description)
        for p in ShaderNodeMath.bl_rna.properties["operation"].enum_items
            ]
    #print(items)
    operation : EnumProperty(
        items=items,
        name="Operation",
        default='ADD',
        )

    def execute(self, context):
        # the material in the node editor
        mat = context.material
        # add a new math node to its nodes
        n = mat.node_tree.nodes.new("ShaderNodeMath")
        # set some properties
        n.operation = self.operation
        n.name = self.operation.lower().title()
        # make active
        mat.node_tree.nodes.active = n
        return {'FINISHED'}
        #return bpy.ops.transform.translate('INVOKE_DEFAULT') # use translate

classes = (AddMathNode,)
def draw_menu(self, context):
    layout = self.layout
    layout.operator_menu_enum("node.add_math", "operation")
def register():
    for cls in classes:
        bpy.utils.register_class(cls)
    bpy.types.NODE_MT_add.append(draw_menu)

def unregister():
    for cls in classes:
        bpy.utils.register_class(cls)
    bpy.types.NODE_MT_add.remove(draw_menu)

if __name__ == "__main__":
    register()

Sorting them
There's lots of them. This change circa lines 9-12 sorts them by IDENTIFIER, eg ADD, SUBTRACT
    items = sorted(
        (p.identifier, p.name, p.description)
        for p in ShaderNodeMath.bl_rna.properties["operation"].enum_items
            )

Adding to the search menu.
Because this is now only a single operator removes the sense of searching for it.  Possibly the logical extension of this is to categorize the operation (as is done via the UI to select math node operation)
With developer extras set to show view source option can right click over the add nodes menu and view source, revealing how the search menu is constructed and laid out.
def draw(self, context):
    layout = self.layout

    layout.operator_context = 'INVOKE_DEFAULT'

    if nodeitems_utils.has_node_categories(context):
        props = layout.operator("node.add_search", text="Search...", icon='VIEWZOOM')
        props.use_transform = True

        layout.separator()

        # actual node submenus are defined by draw functions from node categories
        nodeitems_utils.draw_node_categories_menu(self, context)

Which reveals a helper module nodeitems_utils which we can pretty much pinch, to instead of using enum menu expansion can search and categorize.  Perhaps for another day.


How to turn off pressure sensitivity for grease pencil with a tablet?

For Wacom tablets (I don't know about others) you can set pressure sensitivity at OS level using the control panel (not blender's user preferences). You can customize the behaviour for different applications, so you can have blender have specific settings to your particular needs.


Replacing a material found on many objects to another material at once for all of those objects. Possible?

Yes

If you bring up the select linked menu (Shift-L) with one object that have the material of interest and then choose Material, then use the link menu (Ctrl-L) you can link material from the active object (last selected).


Blender 2.8 sometime I can not open my blender file by OpenGL 3.3 Error

Graphics drivers sometimes crash. Try restarting the PC and closing all other graphics intensive applications before opening the file. You may also try using older version of the driver. Sometimes there are bugs in the driver updates even though it's rare and probably unlikely. It might be that the file is just corrupt. This might happen if your storage device is malfunctioning or for other reasons like overclocked CPU failing during writing the file. Try appending stuff from it to a new file.


Filling Curves never work; Apply Rotation useless

Found that the mesh needs to be aligned ALONG the X and Y axis, as if it's lying on the ground for the fill to work.
All the sources I saw didn't clarify that, only that it "needs to align with the X and Y axis", so I took it as having a value of zero for the alignment in general.


Try this :D

Also, I suggest getting the PBR materials add-on if you want accurate materials.


It looks like you have an extra face inside the geometry, if you delete it, the bevel should work.


I found the reason:
I didn't apply the modifier inside Blender, but applied it when exporting.
That's why it crashed. Just apply the modifier in Blender, before exporting, then everything is OK.


Creating orthogonal axis in blender (geometric model)

I would create a Cube and position then delete unwanted Edges in Edit mode.

In Object Mode I would press Alt+C to convert the Object to a Curve from Mesh and then in the Data Tab for Curve, Fill: Full at a Depth and Resolution that suits my needs.

Once settled, I could color the axis or texture the object by converting it BACK to a Mesh from Curve so I was back on familiar ground (Curves have different behaviors).


Move connected vertices along their individual normal paths?

Okay, so apparently there is something called the shrink & fatten tool. Use Alt + S to activate it. Make sure the pivot point setting is not on individual origins. It looks like pretty much any other setting will work, though. Individual origins applies it onto island paths. The other modes apply it to each specific vertex path.

Hope this helps someone looking to do the same!


how bake three different materials belonging to an object into one single textured one

After some correction I got the baked image.

Second Figure is original .blend. There were some errors.
The Map name on the right is painted with a caution color. In addition to it, there are blank names in Map of other textures.
Blender is not specified what to use from multiple UV maps.
And perhaps the active material of object _2B.004 is UVMat.2A.


Why does blender allow me to rotate an HDRI?

Lighting provided by the World environment is always considered to be infinitely far away from the scene. In other words, when you use HDRI lighting via an Environment Texture node connected to a Background node, you are essentially projecting the HDRI onto an infinitely large sphere wrapped around your scene. Correspondingly, the actual information recorded in a HDRI is generally a spherical capture of an environment mapped onto two flat dimensions using an equirectangular projection.
Since the World is an infinitely large sphere, the notion of “proportionally scaling” it doesn’t make very much sense. If you start with an infinitely large sphere and halve its size, it’s still infinitely large. Since this does not in any way affect how the HDRI is projected onto the sphere, such an operation has no effect whatsoever.

Rather than thinking about scaling or otherwise transforming the World sphere itself, it’s more useful to think about altering the way the HDRI is projected onto the sphere. For example, suppose we use this HDRI for our world lighting, which looks like this using the standard projection:

We can smoothly distort the projection along the Z axis using a Vector Curves node, effectively adjusting the position of the equator:

This produces an image like this:

Note that any smooth reprojection fundamentally distorts different parts of the image differently. In the above example, our remapping of the Z axis stretches the sky and pinches the ground, leading to a curved horizon line. This probably isn’t what you want.

In practice, it is likely to be difficult to get exactly the transformation you want. This might seem frustrating, since all you want to do shrink the ground plane without distorting other parts of the image. Unfortunately, an HDRI just doesn’t contain enough information to do that.
If you wanted to perform such a transformation without any distortion, you’d need to know the depth of the various points in the HDRI so you could perform perspective correction as part of your reprojection. Of course, HDRIs have no such information: they’re just a spherical capture of the light that reaches a given point in space, which effectively bakes the projection of that point into the image data.
In other words, you can no more adjust the size of individual objects in an HDRI than you can rescale or reorient individual objects in an ordinary photograph. The information just isn’t there.


How to partially blur an image in the compositor?

you can use the box mask node. if you need a gradient from top to bottom you could blur the box mask


It looks like the ColorRamp you're using to drive your Mix Factor has too soft of a falloff (because it's set to linear). You can overcome this rather easily by using a Separate ColorRamp to the one you are using for your displacement for your Mix Factor, and setting it to Constant.


Particle system issue - hair moves at the start of animation even without force fields

I'm not sure if this is what you're asking... but if you move to frame 0 it will reset it, unlike moving to frame 1.

Hope this solves the issue you were having!


How to make a material change based on the light it recieves?

I am sure Rich Sedman can figure out a mathematical way with nodes.

However I think I would just use drivers for this.

For your material have your glossy shader mixed in with an emission shader.

Right click on the fac of the mix node and choose single driver "set up later"

Make sure you have auto run python in the user pref.

In the graph editor make sure you have it set up like I did. You will need to set up your variable and name it correctly. Choose the spot light and rotation as the object to link the driver to.

When you move the spot light it changes the fac amount on your mix node.


Walk cycle animation not working in blender game engine

This is caused by the Mirror Modifier and modifier order, to fix it apply the mirror and
change the order so that it looks like:


Why do Rigify controls no longer move my figure easily?

Rigify's Controls
Blender's built-in addon Rigify provides the user with many "handles" or "controls" used to manipulate the position of mesh parts. Here, all of these handles/controls are shown highlighted:

Forward Kinematics (FK) vs. Inverse Kinematics (IK)
Forward Kinematics
Forward kinematics (FK) is one of the two ways Rigify uses to calculate joint movement of a rigged character. When using FK rigging, any given joint can only affect parts of the skeleton that fall below it on the joint hierarchy.
For example, rotating a character's shoulder changes the position of the elbow, wrist, and hand. However, moving the hand only moves parts from there down the joint hierarchy, i.e. only the hand & fingers:

When animating with forward kinematics, the artist typically needs to set the rotation and position of each joint individually -- to achieve a desired pose the animator would work through the joint hierarchy sequentially: root → spine → shoulder → elbow → etc. The final position of a terminating joint (like a knuckle) thus depends on the joint angles of every joint above it in the hierarchy.
Inverse Kinematics
IK rigging is the reverse process from forward kinematics, and is often used as an efficient solution for rigging a character's arms and legs. With an IK rig, the terminating joint is directly placed by the animator, while the joints above it on the hierarchy are automatically interpolated by the software. For example, when moving the hand's IK controls, all unconstrained joints above the hand will be effected:

IK is most appropriate when the animation calls for a terminating joint to be placed very precisely; a character climbing a ladder is a good example. Because the character's hands and feet can be placed directly on the ladder's rungs rather than the animator having to adjust their position joint-by-joint, an IK rig would make the animation process far more efficient. One drawback is that because IK animation uses software interpolation on all the effected joints, there's often quite a bit of cleanup work that must be done precisely positioning specific joints in order to perfect the pose.
FK / IK Settings
Each one of these handles/controls has it's own settings you can see and adjust in the Properties panel. To see these settings, do the following:

Select the rig

Switch to Pose mode

Select a control/handle on the rig

Press N to open the Properties panel, then scroll down to the bottom to see the Rigify settings in the Rig Main Properties section:

The first control setting listed in the Rig Main Properties section is the FK / IK Switch and it controls to what degree the mesh is controlled by the Forward Kinematic handle/controls or the Inverse Kinematic handle/controls. For example, here, the Left Foot's Inverse Kinematics control/handle is selected:

When the FK / IK (foot.ik.L) value is set to 0, the rig's FK handle/control position effects the foot's position 100% and the IK handle/control position effects the foot's position 0%. As the value is increased, the rig effects switch from being FK controlled to more IK controlled, until at 1.0, the foot's IK handle position effects the rig 100% and the FK controls effect it 0%.
So, when you say you are finding "it's nearly impossible to move the "Legs" of the model", that is because the FK / IK (leg parts) handles/controls are set to inappropriate values, so they barely exert any influence on the leg's position when you move them.
Solution
The solution is to set a handle/control's FK / IK Switch value to:

0.0 if you are using an FK handle/control

1.0 if you are using an IK handle/control

Unfortunately, I don't know of any way to do this all at once for all the handles/controls, so you have to do it one at a time. The easiest way to do this is:

Select the rig

Switch to Pose mode

Press A to select All of the handles/controls

Press N to open the Properties panel, then scroll down to the bottom to see the Rigify settings in the Rig Main Properties section

Set all of the FK / IK Switch values appropriately


If I understood correctly you want the bottom of the cube to be at z height zero.

You can edit the cube in edit mode (press tab), select all the vertecies (by pressing a) and then move them up by 1 (gz1).

After leaving edit mode again, you can set this scene to be the default scene when you open a new file by pressing Ctrl + u. If you open a new file now with Ctrl + n, you will find that the bottom of the cube is aligned to z=0.


The Node Wrangler add-on is shipped with Blender and can be enabled in the preferences.

Open the preferences (Edit > Preferences).

Select Add-ons in the preferences and search for "Node Wrangler". Enable Node Wrangler by clicking on the checkbox next to it.


Can't figure out how to fix non-manifold geometry in my game title

You sure you merged by distance? I tried it upon first opening your file and it removed 195 vertices right from the get go (shown at bottom).

As you can see from the face orientation overlay, half of your mesh has faces facing inwards and the other half outwards. There is also a problem with the circled face (there may be a couple more instances). It looks connected, but it is in fact overlapping (you can tell by the z-fighting). This may be a result of the merge, but it needs attention nonetheless.

You can fix the normal direction by selecting all and then selecting mesh > normals > recalculate outside, but the face will have to be edited and "re-connected" manually.


Making indented panel lines for 3d printing

The tools you are asking about are quite simple, you can make loop cuts with CtrlR. Roll your mousewheel to create multiple cuts and use left click to confirm/right click to cancel.

Since Blender can handle ngons, if your shape is a flat hard surface, feel free to cut it. Activate the Knife took with K, click an edge as a starting point and then click another edge as the end point, when satisfied. Press Enter to confirm.

You might also be interested in the Inset tool. This can be useful for giving your faces a bit of distance from the sharp edges so any further modifications don't look odd or modify parts of the mesh you don't want. Press I while selecting multiple edge loops or faces and use your mouse to adjust the inset level.

The Extrude tool is what you will use to create the indentations. Just select the face(s) and press E, you can use your mouse to adjust how far the extrusion goes in/out.

And all of those combined on a simple box model, produces this. Tri's aren't so bad when working with hard surface models but they make editing a pain.

Decent topology is a must when doing 3D printing. See, What exports does blender have for 3d printers?.


Try this:

source : http://www.blendswap.com/blends/view/61707

I added the license and packed the textures into the file. I'm still on windows 8 but I can confirm it opens in 2.78a.