You can probably achieve better results with animation nodes similiar to cegaton's second linked answer. This answer will be the inaccurate, fast method. If you followed the linked tutorial, you can probably skip to step 4.

Use the Extra Objects Addon to add a curve spiral. Extrude the end of the spiral accordingly.

Add a subdivided plane. I created only a small stripe and used the array modifier. Use the curve modifier on the plane to deform it along the spiral curve.

Moving the plane will curl it around the spiral curve. Create two keyframes, making the curve roll around the spiral.

Add a spool cylinder. Currently the plane will initially not adhere to the spool, but rather curve around it with a gap between them. Select only the points which wrap around the curve and press ⎈ CtrlH  > Hook to new object. An empty will be created. I selected a cube as the empties shape.

Scaling the hook object will scale the hooked points. This way we can start with a smaller scale and shift the outer points of the spiral to the spool.

Go the end of the animation and keyframe the location of the plane and the scale of the hook empty. Go the the start of the animation, scale down the hook object and move the plane (along Y) and keyframes their respective values. You may have to add additional keyframes for the scale of the hook empty.


What's the purpose of the EEVEE rendering engine?

You can read this code.blender.org post describing the development goals for Eevee: https://code.blender.org/2017/03/eevee-roadmap/

In short, Eevee is meant to be a modern, high-quality viewport that will perform better than the current Blender viewport, and can better approximate the shaders for game engines or renderers such as Cycles. It will also be able to function as a final renderer in its own right, removing the need for a dedicated scanline renderer such as Blender Internal. Since it is GPU based (using the same render techniques as game engines) it will be very fast, rendering in seconds or fractions of a second.

You can use it as an alternative to Cycles if you prefer the speed, or use it as a preview of Cycles for when you need the extra quality of path tracing and don't mind waiting around for it. Since the renderer is very similar to game engine renderers, it is also very useful for prototyping game assets before sending them on to engines such as Unity or Unreal.


Why won't Rigify deform my High Poly Mesh?

It's hard to tell what's going wrong if you provide only your mesh without the rig you did.

But certainly, you can't do animation with a raw mesh of 2 billion triangles. It's just unmanageable. Performances will be below ground level, you wont be able to have correct control over the weights and deformations, ...

The common workflow is to work on a low poly mesh with an optimized topology for the needed animation's deformations and let the details be handled by the shader (via normal + height maps) and by some displacements with additional subdivisions when rendering.

As I just want to test your model for rigging, I used a decimate modifier in un-subdivide mode with an even iteration. The suit being a more complex organic part, I used Instant Meshes, it's certainly not the best solution but it a nice last hand option in my case.
Then I tried to use Rigify on it, and it went well. I had to do some weights assignments manually on some parts (especially the pockets and some parts of the helmet), but nothing fancy. So IMO you should work on obtaining animation ready models first.


Import csv to Python syntax eludes me, what did I miss?

There were a couple of issues with the code.

The 'obj.select = True' line was referencing an invalid property of 'obj'. I've simply disabled that line.
I've put back in the commented out code in the last function to use the values extracted from the CSV. Note that the CSV data is returned as strings so each value needs 'casting' into the expected type - ie, to cast PARTS into an integer you can use `int(PARTS)'.

Here's my amended code - additionally implementing XW and YW for the width and depth of each circle (I changed the other functions to pass them through and use them in the calculation of the vertex position :
# -*- coding: utf-8 -*-
"""
Name: 'Add cirkel'
Blender: 2.80
Group: 'Add'
Tooltip: 'Creates a shape object'
"""

import bpy, csv
import bpy.types
import time
from mathutils import *
import math

fp = "C:/Users/rich/Desktop/generate-object.csv"

def object_from_data(data, name, scene, select=True):
    """ Create a mesh object and link it to a scene """
    mesh = bpy.data.meshes.new(name)
    mesh.from_pydata(data['verts'], data['edges'], data['faces'])

    obj = bpy.data.objects.new(name, mesh)
    scene.collection.objects.link(obj)
    bpy.context.view_layer.objects.active = obj
    #obj.select = True
    mesh.validate(verbose=True)
    return obj

def vertex_circle(segments, xw, yw, z):
    """ Return a ring of vertices """
    verts = []
    verts.append(( 0, 0, z))
    for j in range(segments):
        angle = (math.pi*2) * j / segments
        verts.append((math.cos(angle)*xw, math.sin(angle)*yw, z))
    return verts

def add_circle(name, segments, xw, yw, z):
    """ Make a circle """

    data = {
    'verts': vertex_circle(segments, xw, yw, z),
    'edges': [],
    'faces': [],
    }
    data['faces'] = [(j, j+1, 0) for j in range(segments)]
    data['faces'].append((segments, 1, 0))

    scene = bpy.context.scene
    return object_from_data(data, name, scene)

with open( fp ) as csvfile:
    """ make series of circles """
    rdr = csv.reader( csvfile )
    for i, row in enumerate( rdr ):
        if i == 0: continue # Skip column titles
        #FRAME, PARTS, XW = row[0:3]
        #add_circle(FRAME, 8, 0)

        FRAME, PARTS, XW, YW, Z, EXP1, EXP2, WALL = row[0:8]
        parts_number = float(PARTS)
        #add_circle(FRAME, 8, 0, 2, 0, 1, 2)
        #add_circle(FRAME, parts_number, 0, 2, 0, 1, 2)
        #if WALL == 1: add_circle2() else: add_circle()
        add_circle(FRAME, int(PARTS), float(XW), float(YW), float(Z))

Here are the results from your sample CSV file (you need to amend the code to point at the location of the file if different to mine) :


I found a solution to my problem in the mean time. Similar to here: http://pythology.blogspot.com/2014/08/you-can-do-cool-stuff-with-manual.html I used the Blender voxel data format (I also tried 8bit RAW, works too).


Strange crease being formed from filling face?

It looks like it's a harsh transition between normals.  You can get this even on the flattest of planes if the normals point in different directions:

it can happen easily when you're joining two separate areas like that, because it's not always immediately obvious which way Blender thinks the geometry faces.

Fortunately it's super easy to fix, if that's your issue...just select all faces, then go to Mesh->Normals->Recalculate Outside, and Blender should make all the normals face properly:

If Blender makes it inside out, you can just use Flip Normals (or Recalculate Inside) to flip it.

EDIT: To explain normals -

Normals are a vector that is always* perpendicular to a face. In computer graphics, they're used to decide how to shade the face, based on the angle of the light vs. the angle of the normal. If the normal is directly pointed at a light, the face will be completely bright, and obviously if it's facing away from a light it'll be dark.

If you think of an object, like a vase for example, the outside of the vase is mostly bright because it's exposed to light. However, if you look inside the vase, it's mostly dark because no light gets in there:

If you model a vase, and part of the outside is marked as inside, or vice versa, it'll look really weird. This is what you're seeing, because Blender tries to figure out which way the normal should face based on how you model it. If you model two pieces separately and then join together, Blender might've thought one of the pieces faced inward and the other outward.

If you use Flat shading, it doesn't matter (as much) which direction a face points because each polygon has its own color/value, and its own normal:

In Smooth shading, Blender tries to average the normals so you get nice shading across the model. This is why I put a * next to "always" above, because the normals at the vertices of the face can point in other directions besides perpendicular so that the color blends smoothly from one face to another. You can imagine then that trying to average opposite values won't work well, and that causes artifacts like what you experienced:

Recalculate Normals then tells Blender to try to figure out which direction the normals SHOULD face:

Much better.  Those few faces on the edges that have sharp edges are just because it can't do miracles if there aren't enough faces.  An Subdivision modifier would smooth those out, but it WON'T smooth out the flipped normals.

I also put the * next to "always" because you can purposely mess with the normals to get lighting effects. For example, that's how normal mapping works (hence the name). It moves the normals around to give the illusion of bumps or patterns on the surface that aren't really there.

Hope this helps!


I’m sure there are many ways to accomplish this. Here’s one possibility.

SHIFT + “A” Add Mesh > Circle with 64 vertices (Top View “7”).

TAB into Edit Mode press “E” and “S” Extrude Scale three times.

Select this vertex and press SHIFT + V and slide it until the corresponding edge is parallel to the X Axis.

Repeat for this vertex until the corresponding edge is parallel to the Y Axis.

Select 3/4 of the vertices and press “X” choose Vertices from the drop down menu to delete them.

Add a Mirror Modifier check off “Y” “Z” (“X” is checked by default). Also add a Subdivision Surface Modifier (Change the View to 2). Tab into Object Mode and select Smooth Shading then Tab back into Edit Mode.

Add two Loop Cuts (CTRL + “R”).

Select the following ten interior faces and press “X” and select Faces from the drop down menu to delete them.

Press “A” to select all and press “E” to extrude them up.

Select the following interior faces and press “X” to delete them.

Check off Clipping in the Mirror Modifier.
Select these faces and press “E” to Extrude them up.

DE-Select these six faces then press “E” to extrude the remaining faces up again.

Tighten up some of the edges with Loop Cuts.


Strange shader/material on all my cubes I created in blender 2.8

Unfortunately you cropped the screenshot too tight so we can't see the shading settings on top of the screen.

That shading you see is just to help you see objects better in the 3D viewport, specially in solid mode, where you don't have materials to help you and it would be hard to distinguish shapes otherwise.

You have some control on how things are presented on the screen by clicking on the controls for shading. For solid view you can choose from several presets Flat, Studio or Matcap.
Among the setting and you can also choose to rotate the light source. In matcaps you can see the object with different textures.

For DevLook,is the same, you can visualize your object under different environments, or the actual light from the scene.

Note that this is not necessarily faithful representations of materials or lighting. Depending on your choice of shading for the viewer you might see a material that has nothing to do with the actual materials, but will help you visualize your object. will render or how the lights on the scnene are working. The light on final render will depend on the light sources and the environment. To make an assessment of the real materials and the actual lights of the scene use Rendered view.


How to project (bake) an environment texture onto a mesh as if from a slide projector?

One cheap and fast way of doing it is to use The unwrap option "Project from view" Like in this Picture:

This uses your current 3D viewport as to unwrap it 1to1 into the UV image editor. If you align your camera just right it behaves like a Projected Image. I recommend to do this in the orthographic 3D view as well.


Is there a way to display the view of an active program/screen as a texture on a 3D object?

Rotating live data out of view is what it sounds like you are after.

You can create a screenshot of the static elements you want to animate and turn them into a gif from frame by frame files. But live data would not be possible, not without extending blender with a new plugin.  Even then, the best place for this kind of transformation to take place would be within rainmeter.

You may want to approach the rainmeter community with questions about how to take a screen cap, and use lua to apply rotation transforms on a flat screen capped image.

Hope that helps.


I want to make animations, is Blender the right program for me?

Blender is definitely a good program to use, seeing your purpose. It just needs a bit of patience and practice.

And  about saving actions — it can be done using the action editor in the Blender interface, so that you can use it multiple times. Though you should go through some tutorials on how to do this. There are numerous tutorials on YouTube that explain this functionality. Here's a link.


Determine/Find any usage of a bone in a rig...how?

The outliner offers the best overview of your scene data that is available.

You can search the contents, one drawback is that the list stops at matches. That means you can search for bones that have constraints, but you won't see the constraints listed. The other thing is that it shows and searches by the name of items, you can rename an IK constraint to be "mydoohickey" and searching for "IK" will then not find it.

Searching for ik can show bones that have an IK constraint. Note that bone constraints only show when the rig is on pose mode.

To find bones used in an action, you probably want to look at the graph editor where you can search for bone names to see if they have any animation data.

For listing other info, we are left to using python scripts. For example to list bones that have an IK constraint -

import bpy

for b in bpy.context.object.pose.bones:
    for c in b.constraints:
        if c.type == 'IK':
            print(f'{b.name} has an IK constraint')


I'm on windows but AFAIK it's the same method, the code for downloading 2.8's repo is:

git clone git://git.blender.org/blender.git -b blender2.8

If your make doesn't work, try maybe make 2017 full (or make 2017 release for CUDA handling).


How would I go about creating a Toroidal coil?

Add a new mesh plane, adjust its dimensions so it matches the desired size of the coil square section.
In Edit Mode move it along the X axis the desired distance you want for the larger radius.
Erase the outer edge and rotate both vertices along the Z axis a desired angle $α$ so it roughly forms a spiral.
Use an Array modifier set to Object Offset and as offset use an empty rotated about the Z axis $α$ degrees just like the vertex previously.
Complete the array, apply the modifier, and in Edit Mode use Remove Doubles so it becomes a continuous loop.
You can then transform into a curve objects to bevel and add thickness as desired.

To give it a more smoothed square section set the curve type to Bezier select all handles and make them Automatic first, then converto to Free. Once as free you can scale them all individually to adjust the smoothness of the squircle.


Why is my fire simulation so blocky in Cycles rendered view?

I've animated flames in blender a few times in the past, and one thing I learned is that if you want the flames to look realistic.  You usually have to set the resolution divisions REALLY high.  Around 600 or even 700 division should make it look really nice. Or maybe 400-500 if you're not going for super realistic.  Yes, it will drastically increase your rendering time, but that's the price you have to pay sometimes.


I'm not quite sure what you mean by face outwards, but I think you could use an align rotation to vector, with the position as the vector attribute, like this. If you want to use this technique on other meshes you might need to fiddle with the rotation axis:


Is there any parts repository available for blender?

Blender uses addons (like plugins) to extend its resources and tools. These are found in File>User Preferences.

Blender comes packaged with Extra Curve objects and Extra Mesh objects addons. But you have to activate them first in the User Prefs panel as shown above.


As stated in the readme.md, you would have to copy the lsystem folder to your add-on directory:

Copy lsystem directory over to F:\SteamLibrary\steamapps\common\Blender\2.80\scripts\addons or wherever your blender installation is.

Linux: $HOME/.config/blender/<version>/
OSX: /Library/Application Support/Blender/<version>/
Windows: %USERPROFILE%\AppData\Roaming\Blender Foundation\Blender\<version>\

Link to the manual for reference: https://docs.blender.org/manual/en/latest/advanced/blender_directory_layout.html#blender-s-directory-layout


To get out of Ctrl+NumPad0 which goes in camera view, you can use any "moving" command MMB  (or Alt LMB , if Emulate Three-Button Mouse is enabled, which it typically is for touchpad setups. It is enabled by selecting Emulate Three-Button Mouse under the Input tab in the Blender User Preferences.)

Some numpad commands :

Home center 3D View

NumPad0 camera Perspective

NumPad1 front ortho

Ctrl+NumPad 1 back ortho

NumPad3 right ortho

Ctrl+NumPad3 left ortho

NumPad7 top ortho

Ctrl+NumPad7 bottom ortho

NumPad5 toggle between perspective and ortho

NumPad 4/6, 2/8 roll scene left/right, up/down

Ctrl+NumPad 4/6, 2/8 scroll scene left/right, up/down

Shift+NumPad 4/6 roll scene clockwise / anti-clockwise

NumPad+ zoom in

NumPad- zoom out

NumPad. focus on the selection


Textures Showing Up In Rendered View But Not Texture View

With the object selected :

From the Properties panel open the Object tab and then from the Display menu change the Max Draw Type from Solid to Textured.

Now you should be able to see your texture when the viewport shading is set to Texture.


You can choose "Pivot point" for manipulate with objects. Default is "Median Point", which is Origin in your case. You need switch Pivot point to "3D Cursor"


How can I give a single object multiple colors in cycles?

While you can assign a different material to each face on your model, I don't think that will give the result you want. I expect you want to use some noise to get colour variations, one way is to feed the noise into a colour ramp node.

There are other noise textures such as wave, voronoi, musgrave or magic that can give varying results, you may even want to mix a couple together. Just experiment with the scale, distortion and detail values to get a variation that you like.


See this answer

def rotate_around_center(mat_rot, center):
    return ( mathutils.Matrix.Translation( center) *
             mat_rot *
             mathutils.Matrix.Translation(-center))

eu = mathutils.Euler(map(radians, (20.0, 30.0, 40.0), 'XYZ').to_matrix().to_4x4()
newRotMat = rotate_around_center(eu, boneWP.location) * boneWP


Can normals be forced to point outward at each vertex/face?

When you have normals facing in different directions you need to recalculate them.

In Edit Mode select everything and press CtrlN to make the normals consistent (also refered as recalculate normals outside).

Th opposite of that operation is ShiftCtrlN to recalcuate the normals inside


I had also such a problem and solved it by deselecting WITH_CYCLES_CUDA_BINARIES in cmake(-gui).

Without this blender will compile the correct .cubin file when you first try to render with the GPU. This will take a while (a few minutes on my i7), but it works.

To solve the problem with 32-bit you probably need to install glibc-devel-32bit (or similar, so called on openSUSE). There was some error about missing a header out of this while compiling blender.


How to smooth only one side of the model?

One side of the coin as in top and bottom? If so you can extrude the bottom faces and apply "Smooth vertice" then apply "shade smooth" but only with those bottom faces. To do this you have to be in edit mode and only select the faces that you want make smooth.


How can I update a menu via an operator?

Hopefully this is concise and shows how to work with the callback and the custom PropertyGroup. A subtle detail is that each property in the group must have a name (never undefined or None). See PropertyGroup docs

Where the information that populates the menu is taken from, be it a list, or some function call is none of bpy's business.

import random
import bpy

from bpy.props import (EnumProperty, PointerProperty)
from bpy.types import (Operator, Panel, PropertyGroup)

own_name_space = {}
own_name_space['list 0'] = ['m']
own_name_space['list 1'] = ['a', 'b', 'c']
own_name_space['list 2'] = ['d', 'e', 'f']
own_name_space['list 3'] = ['g', 'h', 'i']

def get_menu_items(self, context):
    items = [(t, t, "") for t in own_name_space[self.menu_key]]
    return items

class CustomMenuProps(PropertyGroup):

    menu_key = bpy.props.StringProperty(
        name='custom menu key',
        default='list 0',
        options={'HIDDEN'})

    some_selection = EnumProperty(
        name='custom menu result',
        items=get_menu_items,
        description='choose menu item')

class CallbackChangeList(Operator):

    bl_idname = "scene.callback_change_enum"
    bl_label = "Load new list items"

    def execute(self, context):
        key = random.choice(list(own_name_space.keys()))
        context.scene.menu_tool.menu_key = key
        return {'FINISHED'}

class LayoutDemoPanel(Panel):
    bl_label = "Layout Demo"
    bl_idname = "SCENE_PT_layout"
    bl_space_type = 'PROPERTIES'
    bl_region_type = 'WINDOW'
    bl_context = "scene"

    def draw(self, context):
        layout = self.layout
        col = layout.column()
        col.label(text=" Simple Row:")
        col.prop(context.scene.menu_tool, 'some_selection', text='')
        col.operator('scene.callback_change_enum')

def register():
    bpy.utils.register_module(__name__)
    bpy.types.Scene.menu_tool = PointerProperty(type=CustomMenuProps)

def unregister():
    bpy.utils.unregister_module(__name__)
    del bpy.types.Scene.menu_tool

if __name__ == "__main__":
    register()


This is (probably) because your mesh isn't correctly assigned to your rig.

Each vertex needs to know which bone(s) to follow, and how much. If you've got one vertex assigned to two bones, then that vertex will do a combination of what both bones are doing. If you've got a vertex that's only assigned to one bone, but only at 50%, then it'll only move/rotate/scale half as much as the bone does.

To check this, go into pose mode and then from there directly into weight paint mode and check the colors of the mesh as you select each bone. Blue is zero, red is one. Zero means that vertex will not follow the selected bone at all. Red means it'll follow that bone 100%. Somewhere in between will do some combination.

You can use the painting tools to modify this, but they are also just vertex groups. You can use normal vertex group assignments to assign vertices to a given bone. With a mesh as simple as yours, that might actually be easier.

Hope that helps!


Blender installation package not opening

Check the version you are downloading. And if the executable didn't work you can try downloading the zip package where you do not need to do any installation. The zip package lets you drag it's content into any directory and run blender directly from it.

A Zip package can be found just below the installer versions.

But you may have to do a manual registry entry using this method. That being said 2.7 versions have a registry bug that sometimes doesn't register even if you do a proper install so this step may still be necessary even if you did a proper windows installation.


Really slow 3D viewport render preview with gtx-970

When you switch to GPU rendering you need to adjust the render tile size. CPU requires small tile sizes, GPU works better with large ones. Start with a size like 128x128 or 265x256 and see if that makes it better. Make a few test to find an optimal setting for your system


Normal and Ambient Occlusion Map baking issues in Cycles Render

So Gandalf3 did have the answer, although I did not understand the previous topic he had posted. What I did to solve it was move the high-polygon object into another Layer. As I also had multiple materials for the object to be exported into a certain game engine, I had to remove one material before being able to bake the maps in question.


How is the force necessary to counter gravity calculated in Blender?

The force field has many paremeter such has application point, shape of the object, range ... whereas the gravity is the global variable that has no parameter except it's the value.
So you can't expect to counter the gravity with a forcefield at a value of 9.8 .


Invisible Object Show Up In Final Render

I finally figured this problem out. I keep moving objects around then would render to see if the invisible object would move with it. After about a half hour of moving objects around I found the one object that was attached to the invisible object. It must have come in when I appended an object to the scene.  This invisible object was attached to many objects joined together. Which one is the culprit attached to the invisible one is beyond me.  It would be very time consuming to separate them all so just deleted. This fixed the problem.  But this still does not explain why the object came in invisible when it was appended into the scene.


Multiple stacked planes image distortion (Noisey Images effect)

A way to achieve a similar effect is the following:

Use several planes or parts of planes
One on background with the full image
Others with marks or dust and an alpha transparency
Others which cover only a part of the original image and moving between the background and the camera

low quality gif here...

The animation is the following. Planes are simply moving and/or scaling in face of the camera.

Two materials are used:

A simple texture on one plane

A texture with transparency for others

The plane UV are adapted to cut parts of the images where needed (you can adapt depending on what you want):


Unable to properly Import OBJ file in Blender 2.8

For me, it imported into Blender HUGE.  Took me a minute playing with the View clipping to see it.
You can try Clamping the bounds (in the import window) to set a maximum X dimension, for example.
But once I brought it in, it looks fine.  Good luck!


Those nodes are red because they are muted, which is a means of disabling a node temporarily. M toggles the selected nodes muted/unmuted.

Grouping in your file works fine for me, so I'm guessing you pressed M accidentally while pressing CtrlG.

To fix, just select the muted nodes and press M again.


Rotating Objects In the Direction I want

If I understood you correctly, you should select the crystal, under the Transform tab(N) go to Rotation, change XYZ Euler to ZXY Euler. Then press R to rotate and then Z twice to get it rotating around local Z axis.


How to access the bundled Python executable for subprocess in Blender scripts?

The path to access this is bpy.app.binary_path_python

The exact details on how you should run the process are up to you, and not Blender spesific.

Best try the subprocess module, but os.system will work too.

Heres a very simple example calling a Python sub-process.

import bpy
import subprocess
import time

command = (
    bpy.app.binary_path_python,
    "-c", "import time; time.sleep(2)",
    )
proc = subprocess.Popen(command)

while proc.poll() is None:
    print("Waiting...")
    time.sleep(0.1)

print("Finished with exit code %d" % proc.returncode)

For an example of how to run Python as a subprocess without locking up Blender, see this Q & A.


In object mode, select one of the cylinders and press U to bring up the Make Single User menu.  Choose the Object Animation option. Now they will each have their own Action datablock you can animate.


Unfortunately, light groups were removed in Blender 2.8. "Light linking" is a much requested feature but isn't currently supported in Cycles or Eevee.
Here is a video from Blender Conference 2018 with an AMA with Blender developers where they talk about this specific topic. One of the lead developers talks about how there are no "fundamental problems" including it in Blender, but that he mostly discourages its use, instead advising that users test their materials in different lighting environments to avoid having to resort to these kind of edge-cases.
Here is the current developer task about this feature where there is further discussion (and pleading).
There are some alternative ways to do this via compositing that I am looking in to, and will update this post if I find anything viable.


When you duplicate an object, by default the copy keeps the same material as the original. If you want to create a new material for this copy you need to:

2.79: Press U (Make Single User) > Object & Data & Material
2.8: Header menu > Object > Relations > Make Single User > Object & Data & Material.

In the case of a linked duplication (AltD), go in the Properties panel > Material > On the right of the material name click on the dropdown menu and choose Material, this way the meshes of the objects are still linked but not their material.


How to change the angle of an edge in a cylinder

The add-on LoopTools can change a non-circular loop to a circular loop.  Add ons need to be installed.  33 second task.  Search info here at BSE.

Example. LoopTools changes a beformed cylinder into a more regular frustrum. We need only to select in Edit Mode the Top and Bottom loops. Regular Cylinder is easy variation.

You need to be able to specify one or more starting points in your mesh so the equal angle bend can begin.  This a design goal for you to state, not a difficult technical issue.  This is not quite so obvious in your image since the shape is a cylinder rather than a more common case of a plane.

Armature with constraints can specify an angle, and circular arc.
A subdivided curve with a Curve Constraint may be useful.
Proportional Edit may be useful
If you want manual labor, you change change the pivot center for rotation scaling to be the cursor and move the cursor to the current selection.


What is the correct 'data_path' to animate the colour of a Principled BSDF node with Python?

Keyframe the default value of the socket
Animating by keyframe  the base colour of the bsdf node
To the python console.
From material "Material" get the bsdf node
>>> mat = D.materials['Material']
>>> bsdf = mat.node_tree.nodes['Principled BSDF']

What color is it now?
>>> bsdf.inputs['Base Color'].default_value
bpy.data.materials['Material'].node_tree.nodes["Principled BSDF"].inputs[0].default_value

>>> bsdf.inputs['Base Color'].default_value[:]
(0.800000011920929, 0.800000011920929, 0.800000011920929, 1.0)

Make it red and insert a keyframe at frame 30
>>> bsdf.inputs['Base Color'].default_value = (1, 0, 0, 1)
>>> bsdf.inputs['Base Color'].keyframe_insert("default_value", frame=30)
True

Same for blue at frame 50
>>> bsdf.inputs['Base Color'].default_value = (0,  0, 1, 1)
>>> bsdf.inputs['Base Color'].keyframe_insert("default_value", frame=50)
True

True above is indicating the success of adding the keyframe.  To keyframe a single channel (r, g, b, a) -> index 0, 1, 2, 3.  To keyframe just the green channel
input.keyframe_insert("default_value", index=1)

One material.
See this answer, https://blender.stackexchange.com/a/185314/15543
Could instead consider using one material and animate the object color.
ob.keyframe_insert("color", frame=33)


You should have a '+' button that allows to add layouts:


Mesh created with connected vertices don't create correct mesh

Yes; I would highly advise against modeling in this way. It would be much better to use extrude operations (E key) to create your mesh.

If you wish to continue with your current mesh, two ways I would recommend trying to fix it is by first removing any doubles (Spacebar > Search "Remove Doubles"), and then recalculating the normals in the 3D View Tools menu:

If you can attach a Blend file, I could take a look at your mesh and see what else may be able to be fixed, but I would honestly recommend starting from scratch on this one and modeling with better practices.

EDIT:

Here is an example of how you might start building a mesh with extrusion and loop tools, although for a car, I would highly recommend using Background Images of your car and start working your way around that. Here is an excellent resource to get you started in that workflow: http://darkscarab.com/view/43


Making wheels spin as car moves on local Y axis

You cannot easily do this, because it is impossible. @Nathan is right, but I'll add here my explanation:

When moving the car in the scene, you want the wheels to correctly follow - let's move the car 2 different ways:

In first example the wheels traveled longer distance, yet the end car position is the same.

Without Blender accessing and knowing what the path was, it is impossible to compute the wheels rotation, because it can be anything based on how the car was manipulated. When you interactively move objects in the viewport, Blender does not store your moves. The bones only remember their rest and their final (pose) position.

Blender can access what the path was from:

animation keyframes
from defined path the car is traveling (follow path constraint)
from simulation that treats the movement on frame-by-frame basis (you can have a little python script running in background as app.handler and turning the wheels, it could look similar to this, or you can implement this with nodes in Animation Nodes addon)

The easiest and most common method would be to use the path. How to setup a driver that rotates the wheel is here:

How can we animate a ball rolling over a path?

It's convenient to offset the curve for left and right wheels and setup both sides separately, so they rotate correctly when turning.


How to combine circular two shapes and subdivision surface properly and curved cylinder cap?

It looks like this kind of topology could work, tell me if it's ok:


Slightly edited Mesh disappears when activating Dyntopo in Sculpt Mode. Blender 2.8

This is because for Sculpting you have to apply all the modifiers before applying dyntopo. I think It would solve your problem.


Each loop (= corner of a poly) has its own vertex color. You can print the vertex color for each corner with
# Get the first Vertex Color layer; can also use its name (eg. "Col")
layer = bm.loops.layers.color[0]

for face in bm.faces:
    for loop in face.loops:
        color = loop[layer]  # gives a Vector((R, G, B, A))
        print(color)

Btw, if possible you should get the triangulation with calc_loop_triangles instead, since it gives you the triangulation that Blender actually draws.


Transforming a cube to a sphere using transform to sphere isn't creating a sphere it creates a spike shaped mesh

There may be a scaling issue here. If you take a cube and:

In edit mode, subdivide it
In object mode, scale it along one axis
Back in edit mode scale it back down the axis so it looks like a cube again
And then use ShiftAltS .. 'To Sphere'

...you wind up with a similar result to yours.

In short, in object mode, CtrlA apply any scale that might be locked into the object's transform matrix.

If ever you make a non-uniform scale of something in Object Mode.. make a mental note of it, and/or keep an eye on the Transform panel in the Properties Region of the 3D view (in Object Mode). You may need to go back and bake the transform into the mesh by applying it.


problem opening files after moving them to a different folder

There is a file called recent-files.txt that is saved where the config files are.
If you edit that with the new paths you should be fine.
For the location of the file refer to this post:
Where is the startup file stored?


This isn't a complete solution, because it doesn't work for the ambient occlusion, but you can get rid of the shadow in compositing.

Create a emission Material, with the Backfacing output of the Geometry node fed into the Color in the Emission node.

Then create a new render layer, that includes the same layers as the Background layer, but replaces the materials with this new one, using the Material option in the render layer panel (you still want no materials on the actual objects, to keep the correct shadow calculations).

In compositing, use a Mix node with an Add blend mode to combine this render layer with your shadow/AO nodes.


One part of the problem - i.e. OpenGL-rendering an emitter and its particle system being spatially transformed at a definite keyframe of a physics animation - was solved thanks to Rich Sedman comment about locking the 3D View to the camera (Numpad 0).
Yet, I also had two additional constraints:

make the physics animation as short as possible in an orthographic view and rely on its end (physics) state to produce a panoramic view of the particle system;
hide the emitter and leave the particle system alone while panoramically showing around the last frame of the physics animation;

To reach these goals, the particle animation render (Particle System ‣ Render) was chosen of type Object (or Group of objects) with a (small) UV sphere in place of each particle. In the Display panel of the emitter, I had to switch the Maximum Draw Type from Wire to Solid though Wire was enough for my purpose of showing the (haloed) particle system alone but with Object as render type it ran into the pitfall of drawing the edges of each single sphere. So, I had to rely on Transparency which had to be checked off in the same Display panel to enable the alpha channel of emitter Viewport Color set to 0 (Cycles Render).
Having run and baked the animation and selected its end frame, pink vertex (I would like to generate a particle star field that I could keep as static background) provided a super script which allowed to supersede the particles with a real mesh of point-vertices. Then, using the DupliVerts technique (Object panel ‣ Duplication ‣ Vertices), a copy of the (small) sphere chosen for the physics animation render was used to replace each point-vertex.
From this point forward, it was just a matter of making up the animation through the Dope Sheet (Action Editor) applying Restrict View / Restrict Render keyframes to show the original particle system for the actual duration of the physics animation and keep the duplicated one hidden at the same time. On the contrary, during the part of the animation which was not physically baked, the duplicated system was visible while the camera moved around and the original particle system was hidden.


I going to assume that you really mean 15 layers (objects in separate blender viewport layers) and not referring to render passes (Z, Vector, Normal). +someonewithpc is correct, but I thought I would expand and clarify the answer.

Here's what you need to do. I'm going to assume that you will want multiple render passes per render layer, since it's the more complicated solution. If not, it will be a little simpler.

View the image in a new window to see it full resolution.

Set your output file format to OpenEXR MultiLayer in the the render output panel.
In the Render Layers panel, setup a render layer for each of the viewport layers you want to render. Select the output render passes you need for each render layer (Z, normal, etc)
In the compositor, Add a Render Layer node for each render layer you setup.
Create a File Output node for each corresponding Render Layer node. In the property panel on the right, you will need to manually add additional output layers in the file output node (Z, alpha, etc). You can do this because you set the output file to OpenEXR Multilayer previously.
Hook up the matching input/outputs between each render layer node and file output node. You'll also have to enter the output Path in each file output node. It's good to choose a separate folder to keep each Render Layer frame set separated.
Make sure that the Compositing checkbox is checked in the Post Processing panel in the Render Property section.
Render the animation. You should end up with one folder per layer with 1 EXR file per frame rendered. In each EXR file you will have the render passes selected (Z, normal, alpha, etc.)
You can use the EXR files for further compositing in Blender or another external compositing app.

Note: The main render image (whatever is piped to the composite node in the compositor will still be rendered and written out. I believe you still need to have this hooked up for the rest of the process to work properly (I haven't tested this recently but know it worked like that in the past).


Can you control Explosions/ Smoke by frames?

You should do some complex stuff, buy you can achieve it.
In general you should work with "Time Scale" attribute of Smoke Domain > Fluid > Settings so you can "pause" the physics or slow it down.
If you are using the particles system to create the explosion, the same should be done in sync with the Timestep value under Particle properties > Physics > Integration
Here's how to pause the smoke:


In your Video Strip Properties make sure, Image Offset and Image Crop are unchecked.


In Blender 2.8 where did the Lock frame selection to range button go?

You can go to the timeline and click playback then tick the limit playhead to frame range


Objects in group make the entire group move

Hitting the O key (thank you, @LeoNas) fixed the problem for me. If anyone knows why, please edit this answer.


Modeling complex shape of a monitor backside

I am not sure if it is the most efficient way but it can probably be made with regular box modeling and a subsurface modifier.


You just need to turn ON Viewport Overlays button next to display modes on 3d view header ...


How to configure which Blender version opens when clicking on a .blend file?

For Windows:
On windows 7 right click on any .blend file and select open with and choose default program . Then use the browse button to navigate where the version you want of the blender program is on your hard drive, and select blender.exe as your default program to open this kind of file. To make the selection permanent check the box that says  always choose the selected program to open this kind of file.

On Windows 10 right click on the file and use choose other app:

Then on the next screen navigate all the way to the bottom and click on look for other app on this PC

On Linux it's basically the same procedure:
Right click on the blend file and select Open with other application

then from there navigate to the folder the blender version you want to use:

On OSX
Ctrl Click on the icon and select open with->Other and select the blender executable you want to use.


Why I am I unable to mix matrix nodes multiple times with Animation Nodes?

Okay, So, after some testing I realized that the output of a mix matrix node is actually a "result" (mind you im not a programmer) which gets inputed into an "object matrix output" node, so I simply connected an "object matrix input" immediately after the former and began a whole new sequence of Matrix calculations and it seems to work perfectly as I wanted. –


Personally I would do this with simple mesh modeling.

Start with one vertex and Extrude it to create faces. F2 add-on (bundled with Blender) could be your friend here.

After making the shape you will need to snap it to selected edge on Rocket body.

At the end you can use this method: How to make a circular array using offset object as center? to position your fins and add Solidify modifier.


How to randomize wood pattern in many object?

so you can use object info node for this!

just add a mix rgb node and put the image texture in the first node and a color ramp in the second one. just choose some shades of grey in the ramp. you might want to choose similar types of shades. just vary them a little( my colors are too drastic).

no each copy of the wood mesh will have different color due to the mixing. rememder to make the wood meshes different objects(duplicate them in object mode not in edit mode).

Now to vary the wooden pattern, yoou can scale he uvs differently and get different patterns, just move the uvs randomly and scale them a litle. remember to use UV coordinates in your image texture.

you can combine both methods to get different looking wood materials.


Sure.  The output of the color ramp can be interpreted as a factor, which can be used as input to a color Mix node to mix two textures, like so:


What is the difference between blender render and blender game?

If you are making a still render or animation, then you most likely want to use the rigid body physics in the 3D view.

If you are making a game or a program that users will interact with in some way, then you most likely want the game engine.

Not too long ago blender didn't have any way to simulate rigid body physics outside of the game engine, and there are still lots of tutorials floating around from before that time.


erase C:/Users/[USER NAME]/AppData/Roaming/Blender Foundation/Blender). and reinstall


In my experience (my laptop has this issue) it's a problem with OpenGL implementation affecting the selection. This causes dragging the manipulator to result in repositioning the 3D cursor instead of manipulating the object.

To resolve this you need to change the Selection option in the System tab of the User Preferences :

In my case, changing from 'Automatic' to 'OpenGL Select' resolves the issue.


How to animate the creation of a straight line?

I don't have much time here but I think I can help. First make your line, I'm guessing a rectangular prism type shape. You can animate the scaling of it in one direction to show it growing, just make sure you set the origin to the side you don't want to move. (Select the face you want to stay put, then Shift-S and set cursor to selected, then go to object mode and set the origin to the cursor.

I would give a video for reference or something but I'm still figuring this site out, hopefully that was clear enough.


Scritping: rename while using bpy.ops.mesh.separate(type='MATERIAL')

This script will rename all separated objects according to the material applied to each. It assumes the object you want to split and rename is selected and active.

import bpy

bpy.ops.object.mode_set( mode = 'EDIT' )
bpy.ops.mesh.select_all( action = 'SELECT' )
bpy.ops.mesh.separate( type = 'MATERIAL' )    # Separate by material
bpy.ops.object.mode_set( mode = 'OBJECT' )

# After separating, all pieces are selected
for o in bpy.context.selected_objects:
    # Rename object by the material applied to it
    o.name = o.active_material.name


Texture rendering in Eevee but not in Cycles

Have you UV-unwrapped the model?
And I would try to take that colour ramp out and see if it fixes the problem.


How to enable openCL rendering in Blender 2.75 rc2

I have found solution to my problem. To enable openCl on Linux Mint 17.1 with ATI radeon video card just install ocl-icd-libopencl1 package for 64 bit system, or ocl-icd-libopencl1:i386 for 32 bit system. No need to run Blender as root or set up environment variable.


Why colors of a Blender exported .obj mesh differ in Meshlab and Sculpteo?

Well, I think I found the answer by myself:

It's well known that the colors we see on a Blender rendered image are not the colors we have given to the material. Generally speaking this is due to World's impact. Blender exports in .obj format without taking in view this factor. It does not export the colors you have set in advance, but the colors they change to, when the impact of environment is not there. So even if you open your exported .obj file with Blender you will see your mesh with changed colors (darkened). So in order your .obj file to open the mesh with desired colors lighten them in Blender before exporting.

:)


How can I parent multiple meshes to one bone?

So, as explained by Jaroslav, the basic way to do it is to switch your armature to Pose mode, then select your object, select the bone you want to parent to, and parent with ctrlP > Bone.

You also have this solution, better if you'll need to join the objects or some other cases, so it really depends on the situation:

First deparent the objects from the armature. If you want to deparent several objects at once, select all your objects, select one last (make it the active one), deparent it, then in the Properties panel > Object > Relations, right click on the Parent field and choose Copy To Selected.
Now select your objects and parent to the armature With Empty Groups, which means that each object will have vertex groups created with the names of the bones, except none of these groups are assigned to vertices yet.
Then select each of your object, go in Edit mode, and in the Properties panel > Data > Vertex Groups, assign to the object the group it is supposed to be part of, meaning the bone it is supposed to be controlled by (it looks like it's the root you want).


I think the best thing you can do is to take a screenshot, either using external software or via Window> Save Screenshot:

The downside is that you will have to crop out the rest of the interface afterwards as that will also be captured.


You have to assign weights to meshes you want to move with a bone.

(After selecting your mesh and armature and parenting using automatic weights)

Select your armature and press ctrltab to enter
pose mode
Select your mesh and press ctrltab and then you can assign weights to parts to want to move with the bone


It turns out that this seems to be an issue with importing bpy into JARCH_matierals. I changed around the code so that bpy is passed into the function instead of being imported and I got it all to work together fine. This might be since bpy is already imported into the module? I don't know for certain.


Let say you have this tile picture:

You can either scale up the floor UV map in the UV Editor:

... or plug a Mapping node in the Image Texture node and play with the scale values:


print number and index of selected lines in text editor

import bpy

txt = bpy.data.texts['Text']
line_begin = txt.current_line_index

#select_end_line_index missing - iterate over txt.lines
for line_end, line_obj in enumerate(txt.lines):
    if line_obj == txt.select_end_line:
        break

selection = [i for i in range(line_begin, line_end + 1)]
print(selection)

There is already a comment function


Instantiating objects and applying different material to them

Both the Object and Mesh classes actually have place to store materials. For object it is Object.material_slots and Mesh.materials. This means that Mesh always has their own "default" materials but they could be overridden on Object level. I don't know the origin of this but it comes in handy.

Normally the settings are paired but to override material per object, you need to set the object's material slot from "DATA" to "OBJECT". This makes Blender store the material per object instead of reading it from the mesh data. It is easiest to set this up for the source Object, all clones will inherit this setting afterwards.

In python you can set this via.

object.material_slots[i].link = 'OBJECT'

After you make the change, you need re-assign the material slot as setting this clears any reference.

Here are links to official Blender python API in case you want to dig around some more:
https://docs.blender.org/api/current/bpy.types.Mesh.html?highlight=materials
https://docs.blender.org/api/current/bpy.types.Object.html?highlight=material_slots

Depending on your case though, if you only want simple color variation instead of having completely different materials, it might be better way to set up your material so that you get a random per object color using Object Info > Random and color ramp for example. Or Object Info > Location plugged into textures like Musgrave or Voronoi for patterned variance.


In the Properties panel > Particles > Render, make sure that the Show Emitter option is enabled.


Procedural random/different colors based on normal direction

Technique #1

A psuedo-random color can be assigned to a range of normals (needed if there are small variations in face normals) and stay with the object as it rotates. The normal vector for the object faces is transformed to local coordinated, then rounded, then passed through a noise texture, and finally a color ramp.

For the sample model in the question, the geometry for the lights was separated from the original mesh and simplified so the faces for the light were approximately flat. To illustrate how the colors are assigned based on normals, a sphere with random colors is shown along with the disco ball.

Solution (tested on 2.79)

Create a shader for the random face colors. The input will be the geometry node followed by the vector transform node. The vector transform node allows the object to be rotated without the normal changing (See Cycles normal input relative to object's rotation ).

Add logic to the shader to quantize the normal values for x,y, and z. The values for x,y, and z are rounded so they have a fixed number of values. The input at the bottom controls how many different levels of normal values are considered. This keeps faces that are almost flat a single color.

Changing this value changes the number of normal ranges that will result in a unique color.
For a value of 2

For a value of 10

For a value of 100

Finally, the quantized normal is input into a noise texture, then through a color ramp and to an emissions shader.

Putting it all together, the complete shader is shown below.

The geometry as shown in the question needed one change for this to work as expected. The lights mesh needed to have flat areas for the colors. The way the geometry was created, results in curvature around the edges of the lights which results in small areas with different normals. Applying this shader as-is to those areas, resulted in unwanted artifacts.

By separating this mesh and removing the modifiers, the light meshes are flat and get a single color.

An example blend file:

Technique #2

The advantage of this technique is that a texture can be used to assign the colors to the normals. A psuedo-random color can be assigned to faces with unique normals by converting the normal to spherical coordinates, then using a procedural noise texture and color ramp to set the colors.

Solution (tested on 2.79)

The key to make this work is to convert the normal for face from a vector into two angled using spherical coordinates (see Wikipedia - spherical coordinates). To do the conversion, the atan2 function is needed, but not available in 2.79, so this is done using math and the arctangent function (see atan2 in Blender).

The spherical coordinates are converted into a value between 0 and 1 by scaling using radians.

The coordinated are used as a lookup into a texture. To test the mapping the default blender UV texture is used. Using smooth shading on a sphere shows the mapping works as expected. The colors for the faces can be assigned using an image texture.

To procedurally assign the colors, a noise texture is used. The spherical coordinates are input to the noise texture. Using the default settings, the colors are not independent and blend together.

Changing the settings helps make every face's normal have a  difference color.

Finally, a color ramp can be used to control the colors assigned. Add a color ramp between the noise texture and the shader. The output of the noise texture is scaled to use all of the range of the color ramp.

The complete procedural shader for this is shown below.

Sample blend file -


How to make a curve on the face of a plane

A solution with Blender 2.82.

In Object Mode , add a bezier curve then pass on Edit Mode.

You can draw a new curve by clicking on icon Draw.

You can draw on a mesh if you select on Tool tab , the Method of projecting depth : Surface.


Transfer weights of selected faces to an other bone possible?

I don't know how you named your bones, but each bone should have been assigned to a vertex group named as the bone. See the mesh "object data" properties tab, under "vertex groups". There you can select/deselect, assign/remove vertices from the selected vertex group.

You can control which vertex is in which group, and eventually remove wrong vertices from the wrong leg group and assign them to the right leg group.

Beware that weight painting can add painted vertices to the selected bone's group.

Marco


This is probably more akin to "moving the object origin without changing the location".  The object's origin is the location of (0, 0, 0) in local coordinates.

Basically, find the minimum z location (minz) of all bones' heads and tails, then translate all such that the lowest local z is now 0.

With operators, select all bones, translate.

import bpy

context = bpy.context
arm_obj = context.object
arm = arm_obj.data
bpy.ops.object.mode_set(mode='EDIT')
# get min z
minz = min(min(b.tail.z, b.head.z) for b in arm.edit_bones)

bpy.ops.armature.select_all(action='SELECT')
bpy.ops.transform.translate(
                       value=(0, 0, -minz),
                       constraint_orientation='LOCAL')

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

Without operators (except edit toggle), create a translation matrix (T = Matrix.Translation((0, 0, -minz))) and use it to translate the matrix of each bone.

import bpy
from mathutils import Matrix

context = bpy.context
arm_obj = context.object
arm = arm_obj.data
bpy.ops.object.mode_set(mode='EDIT')
# get min z
minz = min(min(b.tail.z, b.head.z) for b in arm.edit_bones)
# calculte the translation matrix
T = Matrix.Translation((0, 0, -minz))
# translate all bones.
for b in arm.edit_bones:
    b.matrix = T * b.matrix

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


First move object with rigid body physics, then animate manually

You can use the Rigid Body Tools panel available from the toolshelf. Just setup your objects as normal, select the one you want to manually animate after the simulation and hit Bake To Keyframes.
(In this example, I have a cube as the active object with its mass set to brick and the plane as a passive object)

A dialog will popup, select the start and end frames and optionally the frame step and hit OK.

Once this is done you should see the rigid body simulation keyframes for the object appear in the timeline from the start and end frame you specified. You can then select the object and manually animate from thereon and even tweak the baked keyframes if you want.


Adapt dimension axis of an object to viewport

Try Object->Apply->Rotation. This should make the object's current orientation the 'real' orientation.


No there is no GPU assist for the VSE (sequence editor) and before you ask, no you can't have more cores either. You can make an OpenGL render (without audio IIRC) though. If you look at an OS task manager or resource monitor you will notice that there is very little stressing the CPU or memory. As it is not a core function of Blender it is not well optimized for system resources.


Fake Motion Blur on Video Footage using Compositor

I am afraid that there is no optical flow available in Blender at this time. Optical flow technology uses motion vectors to estimate motion vectors across an image.

To simulate something similar try animating a pseudo mask object that follows the moving 2D image. You can animate it manually or you could use the tracker to follow elements of the animation then hook an object to it in 3D view. Take these actual object movements to use as vectors for the compositor.

For a better result, you can separate the character from the background if you have a clean plate of the background using a Difference Key node.


Material preview mode transparency (Blender 2.8 Eevee)

Solution 01
Add a reference image

Blender can add Reference images, that are visible in the 3D viewport, but not in renders.
They're great choice for modelling, and have many options available.
Add > Image > Reference

Solution 02
Enable transparency in Eevee

To make a material appear transparent in Material preview, use the Alpha value.
Don't forget to set Blend mode to Alpha-blend.
(If you cannot find these settings, switch to Eevee render engine in the render tab)


How do I make backfaces override transparency into a flat color?

You can use nodes to set different materials to the front and the back faces.

In your case, I would use the outer mesh exclusively for the outline, with a node material:

The green materials is shadeless.

Then, again using nodes, you can mix the shadeless and the toon shaded materials for the inner shape:


Smoothen, close and simply surface in very complex objects

The remesh modifier will simplify your mesh and remove the smaller holes and at least some of the internal mesh. You may need to apply the modifier and then manually clean up the bigger holes.

A more manual approach is to retopologize the mesh, which is a common method used to cleanup sculpts. You can use the built-in snapping tools, the bsurfaces addon that is included with blender or CGCookies retopoflow to make it easier.


Fluid is not simulated at the target location

Origin point of the fluid object was set putside/on edge of the domain.


Uncheck "origins" here:

Or Ctrl. shortcut.


One object having two different colors and distortions

Tab into Edit Mode and A to select all then hit Ctrl+N to make the normals consistent.


You can use the Grid Fill option to create many faces.

Select the edge loop (Alt + RMB), key Space, type Grid Fill, and select the option.

Example on a cylinder:


Scroll to the very bottom of the Materials panel, go to Settings and use the Viewport Color. ;)


You can limit the movement by locking other axes for rotation. Open the numeric panel (N, or click on the + sign on the top right of the 3D viewport.

Then lock the rotation for the X and Y axes.

Your object can then rotate on Z axis only.

An alternative without locking the axis is pressing RZ on the keyboard, the rotation movement will be restricted to the Z axis.


For the answer, you can use this (as shown):

How to Create a Vinyl Plastic Toy Shader?

Just try to pay attention to detail!


Changing amount of decimal digits in dimensions, without source code?

When you set blender to show units, it doesn't display zero only fractional values. Values that have a fractional component will display as you expect.

You can get the values via python, see the object api reference for property names.

>>> bpy.context.object.location
Vector((1.2345000505447388, 0.0, 0.0))

>>> bpy.context.object.dimensions
Vector((100.12300109863281, 2.0, 2.0))

As you can see, you also get floating point binary storage issues.


Is there a low level alternative for bpy.ops.object.origin_set()

Set the object location to the target location and translate the mesh vertices in the reverse direction (the negated vector of the difference between start location and target location of the origin = start minus target).

Note that Mesh.transform() is not supported in Edit Mode, you need to use a wrapped BMesh instead.

If you use blender 2.79 change bpy.context.scene.cursor.location to bpy.context.scene.cursor_location

import bpy
import bmesh
from mathutils import Matrix

ob = bpy.context.object
cursor_world_loc = bpy.context.scene.cursor.location
cursor_local_loc = ob.matrix_world.inverted() @ cursor_world_loc

mat = Matrix.Translation(-cursor_local_loc)

me = ob.data
if me.is_editmode:
    bm = bmesh.from_edit_mesh(me)
    bm.transform(mat)
    bmesh.update_edit_mesh(me, False, False)
else:
    me.transform(mat)

me.update()

ob.matrix_world.translation = cursor_world_loc


How to temporarily hide armature for other mesh?

Hiding the top object will only hide the skeleton, not the mesh.
If this is what you want to accomplish, Just click the hide button and you should be good!


Why does my character model bunch up when posing?

The weights probably aren't proper. Click on the mesh and press Ctrl + Tab, then click the bone you're moving. The more red an area is, the more it's influenced by that bone. Play around with it until you achieve the desired result.


How can I get only textures (with out shaders) from rendering image in Blender 2.8?

1-You can enable color pass in view layer settings. And access it in compositing.

2-You can do screenshot of the solid with right size by doing Viewport render image.
Its in view menu of viewport.

3-About

  Just use the texture color directly to the surface output, with no
  shader in between. – lemon

With Node wrangler addon shift-click on texture in material editor to show just texture.
Or connect texture to emission shader and this shader to output node.


An alternative to iKlsR's answer:
You can close a panel by right clicking on the line between the two pannels (i.e. the shadowed area. Your mouse will turn into a double-sided arrow when you hover) and clicking join area:


How to read and print data from a dictionary using a modal operator?

Pass a globals dict to exec

Not sure of the reason why it doesn't work.. only have some inklings.

However can populate a dictionary and pass as globals to the exec function.

        if event.type == 'TIMER':
            mydict = {"a":4}
            myglobals = {"testDict": eval(json.dumps(mydict)),
                       "mylist": ["a","b","c"] }

            msg = 'def printTestFunc(num1,num2):\n'
            msg += '    print(num1)\n'
            msg += '    print(num2)\n'

            msg += 'for i in range(5):\n'
            msg += '    [printTestFunc(0,testDict[key]) for key in mylist if key in testDict]\n'
            exec(msg, myglobals, None)

        return {'PASS_THROUGH'}

Alternatively could define vars in the method and pass locals() which will include self, context and event

Note: Good idea not to use builtins like list and dict for variable names.  EDIT: Oops did just that with globals


How to use blender create square-section spiral objects?

To make a spiral

Press ⎈ Ctrl+⎇ Alt+U to access the user preferences

And enable the extra objects add-on:

Back in the 3d viewport, press ⇧ Shift+A and add a Curve>Curve Spirals>Archimedian

Set the steps, turns and radius grow to get a spiral that looks the way you want.

To give it shape, use another curve with the profile you want (I used a curve>circle and adjusted the handles to make the shape more square).

In object mode select the spiral and use that newly created curve as bevel object. Make sure you enable the fill cap option.


Can't scale two edge loops around the X axis

You have 'Individual Origins' set as your pivot point for transformations in the 3D view header toolbar. At the minute each loop is scaling towards it's individual origin but because the loops have no thickness themselves nothing appears to be happening.

You need 'Median Point' set:

This will find the point in between the two edgeloops in 3d space and use that as the origin for transformations.


Load images with substring in filename from a given path

Regular expression example.

For the most part this is a generic python question, some answers from stack overflow.

python finding substring inside string

Python glob multiple extensions

Python glob multiple filetypes

For blender specifics, the image file extensions that your blender can open are

>>> bpy.path.extensions_image
frozenset({'.dpx', '.pdd', '.jp2', '.hdr', '.j2c', '.rgb', '.tiff', '.sgi', '.tga', '.rgba', '.png', '.cin', '.jpg', '.exr', '.tif', '.dds', '.psd', '.psb', '.bmp', '.jpeg', '.tx'})

Here is a sample method, that searches for image files that have a substring in their name and an extension suitable to blender. A regular expression search is used in both cases. The searches are case insensitive.

The links above show how to do this using other tools such as glob, pathlib and fnmatch

import bpy

def find_files(substring, path='.', extensions=[]):
    from os import listdir
    from re import search, IGNORECASE
    return [f for f in listdir(path)
            if search(r'%s' % substring, f, IGNORECASE)
            and any(search(r'%s$' % ext, f, IGNORECASE)
                    for ext in extensions)]

def image_files(substring, path="."):
    return find_files(substring, path=path, extensions=bpy.path.extensions_image)

def movie_files(substring, path="."):
    return find_files(substring, path=path, extensions=bpy.path.extensions_movie)

def audio_files(substring, path="."):
    return find_files(substring, path=path, extensions=bpy.path.extensions_audio)

# test call, search for "screenshot" in image folder
# and load images
from os.path import join
image_path = "/home/batfinger/Pictures"
for fp in image_files("screenshot", path=image_path):
    print(fp)
    bpy.data.images.load(join(image_path, fp))

Notes maybe switch extension search to first. For recursive folder search would use something like os.walk instead of os.listdir


Make a smoke sim. Model flowing branches, set as smoke flow. Set Density to desired opacity. Set temp diff to 0. run sim. add balls at smoke termination points.

If you want it in motion, give balls a negative (-500) force field, raise temp diff slightly to .05, set dissolve time to 1 in domain, lower temp diff and vorticity in domain to taste.

In all cases you'll want to hide the original smoke model.


How to disable the automatic UV stretching after an image size is changed?

Normally, it is not likely to happen. You need to learn more about how the UV coordinate space works. However, you can correct it by manually scale it down to the old proportion if you really want to keep the aspect ratio of that UV:

For example, let's say the old image resolution is 1000px * 1000px, and the new resolution is 500px * 1600px:

First, calculate two ratios: Rw={image_width_old}/{image_width_new} and Rh={image_height_old}/{image_height_new}. In this case, Rw=1000/500=2, and Rh=1000/1600=0.625.
Press A to select all UV elements, and SX2Enter, then SY0.625Enter. Done.

Furthermore, if you just simply unwrap it directly by some of the unwrap methods listed in the U menu (e.g. Project From View), then you can also consider do that again after switching to a different image, instead.

I'm sure this can also be done by scripting to make it semi-automatic, at least. So, welcome anyone who know the scripting version of this method and edit my answer.


The sequence of the modifiers is important here. Move the Edge Split modifier to below the Solidify modifier - the modifiers are applied in sequence so this way the edge split is applied to the result of the solidify.


How do you export bones relative to parent?

The code snippet you give seems to be correct if you want the transform from the head of the parent bone to the head of the child bone.

How is the translation incorrect? There are supposed to be two translations between these bones, one from the head of the parent to its tail, and (if the child is not connected to the parent) one from the tail of the parent to the head of the child.

In the 2.40 armatures guide, bone.matrix is bone_mat and bone.matrix_local is arm_mat. This is how they relate in python:

# parent head to tail, and parent tail to child head
bone_translation = Matrix.Translation(Vector((0, bone.parent.length, 0)) + bone.head)
# parent armature space matrix, translation, child bone rotation
bone.matrix_local == bone.parent.matrix_local * bone_translation * bone.matrix.to_4x4()


It is definitely possible to run Blender on a DigitalOcean server. That being said, I wouldn't recommend it as it's pretty expensive if you want good performance and fast render times.

Here's how to install Blender on a DigitalOcean droplet:

Download the latest 64-bit version of Blender (choose the right one for your droplet)
Move the file to /usr/local and unzip it
Add Blender to the PATH variable
Install some missing libraries. There's a how-to guide on which packages you'll need here: Installing Blender on a virtual server
Once everything's installed, you'll want to run your render via the command line: ./blender -b path/to/your/file.blend --engine CYCLES [the rest of the render options]

I toyed around with the idea of building a DigitalOcean-based render farm. After a few tests I concluded that it would be prohibitively expensive.


Color distortion when saving as video file

[...] I chose a white (hex-code #ffffff) background, which works very fine for a single png file. However, when importing the mpeg file [...] all subsequent frames have a slightly grayish background (hex-code #ebebeb).

Suspiciously 0xEB ends up being 235, which just happens to be the broadcast YCbCr BT.709 level. That might be a hint that your decoding is failing you. The decode should correctly scale that value back up to 255.

If you read any of the other diatribes I have written on the subject of codecs, encoding, and decoding, you will know that they are absolutely and horrifically bound to complexity. Is the encode correct? Are the proper flags set? Is the decode correct? Were the proper flags honoured? Is the GPU to fault? Is there something else somewhere that is bungled.

The long story short is that while we can't precisely answer your question, we can determine a few possible things:

Did your encoder encode the correct 255 8 bit value to 235? Check also with 0, which should be scaled up to 16.
Did your decoder decode the correct values and scale them back to their original positions?
How are you evaluating the output? Is it a screenshot from a full screen player? Windowed? Are there differences? Are there differences between players?

My best guess is that it encoded correctly but your player of choice is mis-guessing or not displaying the output correctly. Either that or it is encoded correctly but a flag that the player is looking for isn't set correctly.

Best advice is to check the encoded output with several players, at both full screen and windowed. Compare results. VLC, MPlayer, and your resident OS media player are good starting points.

Good luck...


You could use a 'binary encoding' technique to allow you to assign each object to a limited number of groups.

To achieve this, allocate each group a power of 2 :

Group 1 = 2^0 = 1
Group 2 = 2^1 = 2
Group 3 = 2^2 = 4
Group 4 = 2^3 = 8
Group 5 = 2^4 = 16
...etc.

You can combine these 'groups' by simply adding them together :

Groups(1,3,4) = 1 + 4 + 8 = 13

So setting the ID to 13 would indicate that that object is in groups 1, 3 and 4.

So '0' is in no groups, '1' is in Group 1, '2' is in Group 2, '3' is in Group 1 and Group 2, '4' is in Group 3, '5' in Group 3 and Group 1, etc.

ie, in binary and each column representing a group (with the first being the right-most digit)

000000000000000 = 0
000000000000001 = 1
000000000000010 = 2
000000000000011 = 3
000000000000100 = 4
000000000000101 = 5
000000000000110 = 6
000000000000111 = 7
000000000001000 = 8
000000000001001 = 9
000000000001010 = 10
...etc....
111111111111110 = 32766
111111111111111 = 32767

Once you've assigned the IDs using the above scheme, you can use Math compositor nodes to determine which groups any particular ID represents by splitting off each binary digit in turn using Modulo 2 (which will give the value of the rightmost digit), subtracting the Modulo 2 to remove that digit from the result, and divide by 2 to shuffle the remaining digits to the right - then repeat for the next group and the next, etc. This can be repeated until you've split off all of the groups/digits into individual outputs to indicate the grouping.

The above image shows splitting to give 3 group outputs. Simply duplicate each block of three nodes (Modulo, Subtract, Divide) and continue the chain linked to the previous one in the same way.

It's quite cumbersome but can work for up to 15 individual groups (the ID has an upper limit of 32767 which is 111111111111111 in binary (15 digits)) but any object can be assigned to any or all of the groups as required.


How to create realistic stainless steel gloss in Blender?

Here is the setup I used.

To start I added a cylinder (Shift + A), the edit mode and using Ctrl+R to put 24 cuts into the cylinder. The Selecting alternating circles (Alt-Click) and then scaling them (S+Y+.989) then (S+X+.989) Then I used the Bevelr addon to first bevel the smaller circles and then the Larger ones to create a smooth ridged can shape. (Bevelr will automatically create the vertex groups and add the Modifiers.) And edge split will also help as soon as Smooth shading has been enabled. The material set up is quite simple so not much to explain on that. Just make sure you have the colours right and the lighting will always be key.
Here is the final render at 256 samples.


Well the only inputs that can affect distortion on the Checker texture is the Vector input and the Scale input. You can plug the colour output of any other texture node into either of these 2 inputs to distort the checkered effect quite dramatically.

Solution 1

Solution 2 - Distortion created by mixing Texture Coord and Noise texture with more subtle effect.

Please note the Subtract node is optional and is used if the texture doesn't reach the edge of the object. It is used to offset the texture so that it fills all surfaces of the object.

Credit for this technique goes to Bartek Skorupa in his Manipulate texture coordinates like a boss presentation.


Is there a way to switch selection via hotkeys?

CtrlI inverts your selection.

That is, anything currently selected becomes unselected; anything unselected becomes selected.

That will include any cameras and lights you have on the current layer.


Loop over face loops.

import bpy
import bmesh
from random import uniform
context = bpy.context
mesh = context.object.data
bm = bmesh.new()
bm.from_mesh(mesh)

color_layer = bm.loops.layers.color.new("color")
# make a random color dict for each vert
# vert_color = random_color_table[vert]

def random_color(alpha=1):
    return [uniform(0, 1) for c in "rgb"] + [alpha]
random_color_table = {v : random_color()
                      for v in bm.verts}
for face in bm.faces:
    for loop in face.loops:
        loop[color_layer] = random_color_table[loop.vert]
bm.to_mesh(mesh)

Should your table be indexed by vert index use something like

color_table[loop.vert.index]

If you notice that you are getting -1 for index value run

bm.verts.ensure_lookup_table()

Related

How to get random color variation on a single mesh?

set a specified vertex color to black via python


An if statement does not cause the code following it to loop, it merely executes the code indented after the if only if the statement following the if (in this case 1 > 0) is true.

While loop:

If I understand what you are trying to do, you want a while statement instead of an if statement:

var = 0 # define the variable "var"
while 10 > var: # while 10 is greater than whatever value "var" is equal too
    var = var + 1 # increment var by one
    print (var) # print var to the console

This will execute the code indented after while 10 > var: until var is no longer less than 10.

The result of running the above code is:

1
2
3
4
5
6
7
8
9
10

So if we apply this to your code:

import bpy

var = 0 # assign these variables to 0
mx = 0 # I removed these from the scene for loop because you don't need to set them again for eaach scene.
sx = 0
sy = 0
my = 0
for scene in bpy.data.scenes: # loop through each scene in the .blend and set these values in each one:
    scene.render.use_border = True # enable borders
    scene.render.use_crop_to_border = True # enable crop to border

while var < 3: # as long as "var" is equal to a number less than 3, execute:
    var = var + 1 # increase "var" by one (very important if we don't want to run the loop for infinity)
    my = my + .2
    mx = mx + .2
    scene.render.border_max_x = mx
    scene.render.border_min_x = 0
    scene.render.border_min_y = 0
    scene.render.border_max_y = my
    #                                                          vv var is an INT, so we convert it to a string for the perposes of using it in the output image file name
    bpy.context.scene.render.filepath = "/tmp/test_render_" + str(var) + ".png" # bpy.context.scene gives us the currently open scene, so we can set the path for outputting images for only that scene.
    bpy.ops.render.render(write_still=True) # I added the write_still=True so the render is writted to the file spcified in scene.render.filepath

Explanation:

Here is an explanation of what each line does:

import bpy This imports the bpy module.

var = 0 This assigns "var" to a value, 0. See the wiki for more about variables.

for scene in bpy.data.scenes: This is a for statement that will repeat the code indented after this line for each scene in bpy.data.scenes. (this will also assign scene as a kind of variable containing the location of the current scene being iterated through.)

scene.render.use_border = True This sets blender's variable use_border to True. This is the same as ticking the check box in the GUI (Render settings > Dimensions):

To illustrate this, you can run bpy.context.scene.render.use_border = True in the Python console and the Border check box will become enabled in the GUI.

scene.render.use_crop_to_border = True This enables Crop to border ([use_crop_to_border][13])

while var < 3: Test if var is equal to a value less than 3. If true, then execute the indented code following this line and test if var < 3 again. If false, skip to the next unindented code.

var = var + 1 Assign var to the result of var + 1 (increment by one)

scene.render.border_max_x = mx Set blender's variable border_max_x to the current value of the variable mx.

bpy.context.scene.render.filepath = "/tmp/test_render_" + str(var) + ".png" Use bpy.context to get the active scene and set the scene render property filepath to a string. to use the variable var (type INT) in the string, it needs to be converted to a string type with str(var). See the wiki for more info about strings and variables.

bpy.ops.render.render(write_still=True) This renders the image and writes it to the path specified in filepath.

Result:

The above code outputs the following images in /tmp/ when run in the Text editor:

test_render_1.png is created with the border settings set to these values:

scene.render.border_max_x = .2
scene.render.border_min_x = 0
scene.render.border_min_y = 0
scene.render.border_max_y = .2

test_render_2.png is created with the border settings set to these values:

scene.render.border_max_x = .4
scene.render.border_min_x = 0
scene.render.border_min_y = 0
scene.render.border_max_y = .4

test_render_3.png is created with the border settings set to these values:

scene.render.border_max_x = .6
scene.render.border_min_x = 0
scene.render.border_min_y = 0
scene.render.border_max_y = .6

The total number of images is limited to 3 because the third time the loop code is executed, the variable var is incremented to 3 which is not less than 3.

Here is a code that moves to the next "tile" over:

import bpy

var = 0
mx = 0
sx = -.2
sy = 0
my = .2
for scene in bpy.data.scenes:
    scene.render.use_border = True
    scene.render.use_crop_to_border = True

while var < 3:
    var = var + 1
    mx = mx + .2
    sx = sx + .2
    print (mx)
    print (sx)
    scene.render.border_max_x = mx
    scene.render.border_min_x = sx
    scene.render.border_min_y = sy
    scene.render.border_max_y = my

    bpy.context.scene.render.filepath = "/tmp/test_render_" + str(var) + ".png"
    bpy.ops.render.render(write_still=True)


There are a few ways to shrink/fatten a region of an extrusion.. I don't know if this one is exactly in line with your tutorial....

E Extrude the end of the rod to the desired length of the region to be scaled
Now you have a set of faces whose normals you can extrude along ...  Alt select that face ring
Alt E > (Region, Vertex Normals) extrude the
face selection along its faces' normals.

Now, if you have the Transform Orientation set to 'Normal', you can select the faces at either end of the fattened section, and GZZ to adjust its ends.


.mp4 can be accessed normally outside blender but I can't make the sound work on blender vse preview or even render a video with audio

You will find folks giving you advice and make you jump through hoops and walk through fire just to get your video to play in blender, but the bottom line is that Blenders VSE is a very inefficient and antiquated program. Why put yourself through a poor experience when there are better, friendlier and responsive programs out there? Transcoding shouldn't be necessary in today's software and hardware. Try shutcut, DaVinci resolve free, openshot, media composer first, premiere, etc etc. A search in your favorite search engine for free or cheap video editing sotware will give you plenty of choices. Be happy, stay creative. Don't be bogged down by the tools. Make the tools work for you, not the other way around. Blenders is great for creating 3d, but not a great video editor.


Discard mesh zones from solidify modifier

You can choose which part you want to solidify by setting Vertex Groups.

Go to Edit Mode (TAB) and select vertices you want to solidify.
Go to Data tab and under Vertex Group section add ('+' sign) new group and choose Assign (with vertices still selected).

Go back to Object Mode (TAB) and add Solidify Modifier.
Under it's option choose created vertex group.

Set Thickness and a little bit of Factor not to have Z fighting problem.


You don't want to Add both Texture Image and Glass Shader.

The thing you need to do is Mix both of them by Mask.

In below example I've used texture 2048x2048 with centered label and transparent background (PNG).

I don't know exactly how have you added your texture (and UV) so I can't describe precisely what should you do.

Feel free to add more information so I can extend my answer targeting your particular setup.


The vertices in this area are causing an indent in the surface. When the subsurface modifier is applied, the subdivided surface has a smoother transition and intersects the coarse mesh in edit mode. This is completely normal.

A basic torus

One vertex moved along the z-axis to create a dent

You can hide the subsurface modifier for the edit mode.


How to select outer edge of selected faces?

With the desired faces selected, go to Select > Select Loops > Select Boundary Loop.

If you use it frequently, right click on Select Boundary Loop, and add it to the Quick Favourites menu (Accessed by Q)


So whats going on is because of your model's many edges regular old Bevel won't work. So what you need to do is to go into edge mode and only select the outer most edges, as shown in the first picture. Now when you bevel it shouldn't glitch out with with weird geometry.

Lastly on the second picture I circled in red where two edges  were getting too close together and would cause a problem if beveled a bit more. Essentially watch out for overlapping edges when beveling.

Hope this helps!

(Also having all those edges is a good thing it means you don't have any N-gons, if you didn't know N-gons are any faces with more then 4 edges. N-gons can cause problems with lighting and texturing and sometimes modeling).


BPy add Path in Textfile from Text-Editor

Couple of ways.

Already pointed out hassle re slosh in comments

To include a string in another block string, could use formatting, I like the old and deprecatious % Checkout the python docs for string formatting str.format(...)

text = '''
%s blah
%s blah
%s blah
''' % (("XXX",) * 3) # all 3 occurences
print(text)

output

XXX blah
XXX blah
XXX blah

or use a unique TOKEN and replace

print(text.replace("XXX", "YYY"))

output

YYY blah
YYY blah
YYY blah

Since the parts are paths strongly recommend you lookup in python docs , os.path.join(...).


Check Manipulate Center Points, select all, press S and scale them down.

You can change Pivot Point to 3D cursor if you want.


BGE: KX_GameObject Attribute description unclear

It is deprecated since ages, but nobody dares to remove it from the API. Simply do not use it (and do not use position).

The world reference describes changes along the scene's coordinate system (scene space).

The local reference describes changes along the object's origin (object space).


How can I set my origin point in the center of my cube so it can be the same in both edit mode and object mode?

The origin of your object is where you put it .. you can still see it there, the dot in the center of the half-cube.

What's not where you want it is the 'Pivot Point for Rotation / Scaling', which you have set to either 'Individual Origins' or 'Median Point' (It's hard to tell from the picture - just to the left of the manipulator button). That, in either case, will be at your selected vertex, if you only have one vertex selected.

If want your transformation of elements to be centered on the object's origin while in Edit Mode, go into Object Mode, select the cube, and hit ShiftS > 'Cursor to Selected'. That will move the 3D cursor to the origin of the cube. Now, back in Edit Mode, select '3D Cursor' as the pivot for rotation/scaling, either by using keyboard . or selecting from this rollout:

In Object Mode, you can manipulate only objects, not their meshes, and their 'positions', for transformation purposes, are defined to be the positions of their origins.


You can create a weight paint at the ends, and assing that vertex group to a skinwrap modifier.


Line 25 is missing a closing bracket. Python assumes line 27 is part of the high = (h) parameter to the sound_bake() function.

    bpy.ops.graph.sound_bake(filepath=r'path/to/file' , low = (l), high = (h)

should be:

    bpy.ops.graph.sound_bake(filepath=r'path/to/file' , low = (l), high = (h))


Instead of one shader (Glossy), use a Mix shader node that is fed by the Glossy node and a Diffuse node, and plug that alpha image into the mix factor of the mix shader to control where the shader type is.


Mesh deforms after automatic weights (IK and pole vector)

I think that’s the main problem is that you need to correct the Pole Angle of your IK bones or they are going to rotate crazy once in Pose mode, -90° for both right and left IK.

Also in Edit mode you need to bend the knees bones a bit forwards so that they’ll bend correctly in Pose mode. And join the 2 pole targets to your main armature. Make sure some bones (controllers, pole targets, root) won’t deform the mesh: Select each of them and disable their Deform option. And it looks like you have a lot of overlapping vertices, so altM > Merge By Distance and play with the parameters.


reset a custom PropertyGroup of an object to initial state

The answer is so stupid simple:

del obj['ObjectProp']

However i hope this question is still helpful for some others.


Here's what you can do with the Curve modifier.
For 2.7#
Add your desired text, Shift + A  > Text, then press Tab  to go into edit mode and type in your new text, press Tab again to exit edit mode. Now move your cursor to the center of the bottle mesh you have.
Press Shift + S  and choose cursor to selected. Now add in a circle (Shift + A) under the Curves. Scale it to match the outside of your bottle. Now click back onto the text and convert it to a mesh Alt + C  choose convert to mesh.
Now go under the modifiers tab and choose the curve modifier, select the circle you just created as the Object. You will then have to rotate your text 90 on the x-axis and change the scale of the circle to -1. You may have to mess around with the scale a bit.
For 2.8+
] Everything above will remain the same, though there is no Alt + C shortcut in Blender 2.8, you will have to either use Fn + F3  to search for it or go under the Object Tab -> Convert.

You can also add a Solidify modifier to your text as well to help it stand out a little.


Why can't I translate parts of my mesh with the 3d widget?

There are three main transformations available: Translate, Rotate, and Scale.

Keyboard shortcuts:

Grab (G) (aka translate/move)
Rotate (R)
Scale (S)

From the wiki:

  the normal Transform commands (G for Grab, R for Rotation, S for Scale), can be used to manipulate objects along any axis.

Widgets:

You can also use the the transform manipulator widgets to do this by pressing on the arrows with LMB.

You can enable or disable the transform manipulator widget by pressing the  icon in 3D view > Header:

Or by pressing CtrlSpace.

You can change the transofm manipulator type by selecting one of the buttons again in the Header of the 3D view:

Location ()
Rotation ()
Scale ()

It sounds like you want Location manipulators, but you have Scale type selected.

Try setting it like this by pressing one of the icons:

Also note that you can select multiple widgets at once by holding Shift while selecting them.


How to drive a value with linear fcurve on both positive and negative axis?

Solved it with abs() function!

abs(var)

and it affected in the same way in both positive and negative values! :)


how to extrude along a path to connect 2 meshes

I don't think you can do it this way but you have something close to it with 2 LoopTools > Loft or Bridge. Also, you'll have a better topology if the first and last selection have the same amount of vertices. Activate the LoopTools addon, then:

LoopTools > Loft

Select one of your circles, duplicate it several times where you want the pipe to follow. Select the first and last circle and all the duplications. Then right click to make the Context menu appear > LoopTools > Loft. The pipe appear. You can tweak some parameters in the Operator box (bottom left).

LoopTools > Bridge

This solution is not as precise as you don't determine any intermediate. Select the first and last circles, then right click to make the Context menu appear > LoopTools > Bridge. The pipe appear. You can tweak some parameters in the Operator box (bottom left).


Standard way is to remove tha Ngon face and use Grid Fill to fill in with quads. Another a bit less fast way is to use either Connect Vertex Path tool (J) or Knife tool (K) to cut edges according to existing geometry.

However there might be another way without removing that face:

Press Alt+P to poke faces.
Press Alt+J to convert tris to quads.

Note that it depends on geometry what resulting topology you will get. Also note - Grid Fill restores the curvature of the filled surfaces, this way doesn't.


You must have hit the Q key. I think its someing like "sculpting for UV editing"
With your mouse hovering over the UV/image editor window tapping the Q key again will toggle it back to the regular selection mode.


Firstly, 'Apply Scale' to each of your objects - this is important for any simulation.
Secondly, in your particular case you don't need to enable self-collision since the cloth isn't looking to be at risk of hitting itself. The self-collision will slow down the simulation and can cause its own problems if its parameters aren't appropriate.
Thirdly, 'Apply Scale' on your 'frame' objects and check the direct of the normals - you need to ensure they're pointing 'out' of the faces, not 'in' (otherwise the collision will be in the wrong direction). In your case the bars of the frame are quite thin - reduce the 'Inner' setting in the Soft Body And Cloth collision settings - you currently have it set to 0.200 and this is quite large for a "thin" structure such as this as it can result in the 'back face' affecting cloth at the opposite side of the bar.
Fourthly, ensure there are no overlapping meshes at the start of the simulation as this can cause significant problems as the simulation attempts to eject the vertices out of the collision mesh.
Don't forget to clear any baked simulation and re-run it to see if this helps. If this helps you can then start tweaking the simulation by re-enabling self collision (if needed) and potentially increase the 'Inner' and/or simulation quality. If this doesn't fix the problem, please post a video of the new behaviour.


Find the color at a particular surface point on a mesh

Particle System

You can generate cubes or other as particles.
Convert them in the modifier panel.
Join them into Single Mesh
Vertex [Remove Doubles] may produce large surfaces if desired

Above image. Plane with UV Map Bounds.  Particle System Grid Resolution 50.  Adjust to Needs.

Image above. Particle System Texture affects density. Blender Internal Render.

Image Above. Converted Particles with [Convert] in Edit Mode.

Image Above. Vertex Remove Doubles with a Tolerance. Only the top surface had Remove Doubles. The original cubes had spaces for sake of explanation

Above image.  Sphere shape which is a high density Cube to Sphere Transform.  UV Mapped while in Cube appearance.  Thus 6 repeating UV faces even though the repetition is difficult to see.


World colour is creating some fog like effect in eevee

I figured it out, all I had to do was remove/disconnect volumetric scatter in the world tab.


Can you make Three-Dimensional games in Blender?

Blender itself has a built-in game engine, meaning yes it is not only possible but rather easy to do.
Right here is an excellent tutorial series explaining in detail the process of creating an operating and clean game using Blender Game Engine.
Welcome to Blender SE :)


Maya to blender pivot point location changes

I had a similar issue and I noticed that the objects causing trouble had their transformations frozen in Maya. Once I unfroze objects transformations & exported to Blender again, everything was working as expected. I found this handy script to unfreeze objects transformations in Maya. Hope this helps anyone going through the same issue in the future.