You should be able to using existing python libraries, such as pycuda, which can be installed into blender's built in python (for installing libs you could setup pip or whatever: How to install Pip for Blender's bundled Python?). You can also link an C/C++ program from your script and do it there.

You will always, however, be limited by the speed in which you can use python to transfer data too and from blender's internal format, so this may or may not provide much speedup depending on your use case.

Gpus can provide a speedup to some kinds of operations. In general, code for that operation needs to be specifically written for use on a gpu to take advantage of it. If you wanted to accelerate existing blender functionality you would have to rewrite it to run on the gpu, you can't just magically tell cpu code to run on the gpu instead.

In general, only tasks with many repetitive, independent, but similar math operations work well on GPUs. Because of these restrictions, GPU code and algorithms are generally more difficult to create than just for the CPU.


What techniques are the best to make a gradually curved surface for the side of a model train? (photo attached)

Personally I would not use a modifier to do this, but block it out low poly at first.

This was created (very fast) using extrude E, creating loop cuts ctrl+R then beveling these cuts Ctrl+B (using the mouse wheel to control the amount of bevel).

Windows are created with Ctrl+I to insert faces, then F3 to repeat the same insert amount for all the windows.

the side curve are created with a single loop cut Ctrl+R, and scaled on the width and beveled it out Ctrl+B to get the rounding.


How to project picture onto hair particles?

Add an image texture to hair-emitter-object and use object-coordinates. Then change the rotation (location and size if needed) of texture with mapping node to get the required result (In this example, for side projection, x or y = 90).


Python, get neighboring objects on an axis

Did not test this yet:

import bpy

COL_COUNT =  8 # number of columns
ROW_COUNT = 12 # number of rows

objects = bpy.data.groups['group_name'].objects[:]

# no cmp function
# use round to circumvent floating point precision errors
key_x = lambda o: round(o.location.x, 2)
key_y = lambda o: round(o.location.y, 2)

objects.sort(key=key_y, reversed=True) # from top to bottom
objects.sort(key=key_x)

for i, obj in enumerate(objects):
    col = i  % COL_COUNT
    row = i // COL_COUNT

    #do something with obj

See Sorting HOW TO from the official documetation for more information. The most relevant part is:

  Sorts are guaranteed to be stable. That means that when multiple records have the same key, their original order is preserved.

To retrieve the object for a given row and column calculate the index:

index = row * COL_COUNT + col
obj = objects[index]

I.e. for ROW_COUNT = 2 and COL_COUNT = 4 the objects are tagged like this:

0 1 2 3
4 5 6 7

For the second row and the third column the index is 1 * 4 + 2 = 6. (zero based indices!)


Active Gizmo show all even when axis locked

You have changed the orientation for the gizmo. Locking the global X,Y-axes will cause the X,Y-axes to be hidden in the gizmo only if the gizmo is set to global or default orientation.

The setting for this is found in the top left of your screen. Do not confuse the Gizmo Orientation with Transform Orientation. The transform orientation (middle of screen) is used as the when you use a hotkey such as G to edit an object.


How to increase the scrollback history of the Python console/terminal within Blender?

You can do this by going to User Preferences > System and changing the value in Console Scrollback under the General category. It's set to 256 by default.


How to quickly position many different objects (not copies of a single object) in rows with an offset?

You could use a particle systhem.

Group your objects in a collection
Create an plane with as many vertecies as you want to spawn objects.
Attach a particle systhem to this plane
Adjust the particle system to spawn all particles in the first frame.
Set the particle systhem to use the objects from the collection as particles.
Set the scale of the particles to 1


Why is part of mesh deformed by IK Constraints

Switching the pole angle to -90 alone will result in the leg bending backwards and breaking knee caps when you play back the animation. To fix that, I added a Limit Rotation Constraint above the IK Constraint for each leg. I found Rotation Limit values (differing for each leg) that allows the frames of animation to look correct without the mesh distorting or bones bending in the wrong direction:

Uploaded the edited .blend here:

This seems like a quick fix, and I would love to hear more experienced rigger tell some preventative measures that you could take to avoid IK twisting issues in Blender.


Determine which way Bezier path is 'facing'

Here's the code that I got working to solve this problem:

import bpy

obj = bpy.context.active_object
curve = obj.data
spline = curve.splines[0]
# setup array for points to be written to
xGlobalPathPoints = []
yGlobalPathPoints = []
zGlobalPathPoints = []
# Iterate through the control points in the spline and append them to the array
for i in range(0, len(spline.bezier_points)):
    if float("{:.3f}".format(float(obj.location.x)))+0 != 0:
        xGlobalPathPoint = obj.location.x * spline.bezier_points[i].co.x
    else:
        xGlobalPathPoint = spline.bezier_points[i].co.x
    xGlobalPathPoint = "{:.3f}".format(float(xGlobalPathPoint))
    xGlobalPathPoints.append(float(xGlobalPathPoint) + 0)
    if float("{:.3f}".format(float(obj.location.y)))+0 != 0:
        yGlobalPathPoint = obj.location.y * spline.bezier_points[i].co.y
    else:
        yGlobalPathPoint = spline.bezier_points[i].co.y
    yGlobalPathPoint = "{:.3f}".format(float(yGlobalPathPoint))
    yGlobalPathPoints.append(float(yGlobalPathPoint) + 0)
    if float("{:.3f}".format(float(obj.location.z)))+0 != 0:
        zGlobalPathPoint = obj.location.z * spline.bezier_points[i].co.z
    else:
        zGlobalPathPoint = spline.bezier_points[i].co.z
    zGlobalPathPoint = "{:.3f}".format(float(zGlobalPathPoint))
    zGlobalPathPoints.append(float(zGlobalPathPoint) + 0)
# determine if path is facing X, Y, or Z
if len(set(xGlobalPathPoints))==1:
    print("faces X")
if len(set(yGlobalPathPoints))==1:
    print("faces Y")
if len(set(zGlobalPathPoints))==1:
    print("faces Z")


E< to extrude followed by the axis you want to constrain to. So E Xwould constrain to the X axis.

Alternatively E to extrude and hold down the middle mouse button and that also constrains.


combining two slow motion videos in split screen

You can use any effect strip (like speed control) same way like original videos. So, to get the transform effect over the speed control, select the Speed control strip and select Add -> Effect strip  ->  Transform. Or if you already have the Transform strip on original video, select the Speed control strip, then - Transform strip with Shift and then press R (Reassign Input)

Also you can group strips with Ctrl + G and you can use this group like a usual video strip:


How can Waves of the Ocean Simulator flattened on a Beach Area?

I just tried out using the shrinkwrap modifier and it worked. Set the mode to "project". You might have to make a separate mesh that the ocean shrinkwraps to that doesn't include those things that look like rocks and stuff.

Beyond that, you might also want to look into using fluid simulation or animating little waves or something similar if this isn't what you're after.


How to have a script run from a keypress?

Return a status set from invoke.
AFAICT the issue here is as simple runtime error, not returning a valid status set from an operators invoke method.  No return, returns None.
Pretty obvious from error message printed to system console on testing a keypress.
evt type RIGHT_ARROW
Python: RuntimeError: class KITFOX_OT_grid_rescale,
function invoke: incompatible return value , ,
Function.result expected a set, not a NoneType

Possible suggestion.
def invoke(self, context, event):
    print("evt type %s" % (event.type))
    return self.execute(context)

PS in a method where context is passed, common in operators and panels, there is never a need to see bpy.context


At the last lines you didn't assigned the vector to the attribute dLoc with the = operator, but 'called' it with parentheses instead, as it were a method. Put the = and everything should be fine.

Also, you don't need to add parentheses on the vector. The script with several corrections as follows:

import bge

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

# Constants have UPPERCASE identifiers
MAXVEL = 0.5
BRKVEL = 0.05
CRSVEL = 0.005
ACCELL = 0.001

# Sensors
w = cont.sensors['W']
s = cont.sensors['S']
a = cont.sensors['A']
d = cont.sensors['D']
space = cont.sensors['space']

# Actuators
motion = cont.actuators['motion']

## Movement

# Accelerate
if w.positive:
    own['vel'] += ACCELL
    motion.dLoc = [own['vel'], 0.0, 0.0]
    cont.activate(motion)

if space.positive and own['vel'] > 0 :
    own['vel'] -= BRKVEL
    motion.dLoc = [own['vel'], 0.0, 0.0]
    cont.activate(motion)


Are you using an unapplied Skin modifier, right?

So the "real mesh", the one who receive the automatic weights from the armature it's actually made of a bunch of vertices, the ones that they are moved. The problem is all here: the vertices created by the skin modifier aren't affected by the armature because they don't really exist yet.

You can try to move the skin modifier to the bottom of the list, so it will occour after the armature deformation, but to get nice an smooth deformations, you'll have to provide more "real" vertices to the mesh. You can for example subdifide your skeleton or apply the skin modifier.


You can just use a Particle Info node and use it's Position output to control the color of the particles


In this case it sounds like you want to use a dynamic enum, rather then passing a list, pass items as a function (which returns a list), then you can change it dynamically.
See: https://docs.blender.org/api/current/bpy.props.html#bpy.props.EnumProperty


Make sure you have the Edge Selection enabled (3 vertical line icon), as well as the individual vertex selected (3 white dots).


How to scale an object relatively to the distance of its edges?

Not sure if this is what you need.

Enable edge length in the overlay

Add an edge between the two points. You can do this with fill f to make sure it does not split the mesh at all.

Scale the whole object s and hold down the shift to be more precise. Stop when you get to the correct length and then delete the edge you added.


why bgl meshes flip when nothing is selected?

The script does its job.
The problems is caused by old nvidia graphics driver. A new nvidia gameready graphics driver solved the problem.


Select overlaping vertices from vertex groups

Deselect all the vertices, with A.
Select the first vertex group with the Select button under the vertex group list in the properties window.

Invert the selecting by pressing CtrlI.
Hide those vertices, with H.
Select the second vertex group (same way as in step 2).

Any vertices that are now selected are in both vertex groups.
After doing what you want with the double grouped vertices, you can show the whole mesh again by pressing AltH.

Animated gif showing first the two vertex groups, then how to find double grouped vertices, using the procedure listed above.


Character modeling:Front view model is not aligned with Side view model


This is probably a particles system on your object.

Go to the particle panel here. Near the green arrow you can click on the "eye" icon (just hides the particles) or click on the minus sign (to delete the particles).

At the bottom, the texture you are (probably) talking about :

If you remove it, you model may be "full of grass".


How can I prevent force fields from affecting hair or other particles?

I set the effector collection to the collection the hair emitter is in and the hair stopped moving. You should set it to the collection that the hair is in instead of the collection the smoke is in.


is a great video for your problem. it does involve some python but that's mostly taken care of in the description.

http://www.youtube.com/watch?v=-IeNnw6zzvQ

if your character want to walk though walls and obstacles just to get to the pointer, you'll have to set up a more complex NavMesh.
this is basically a mesh that covers all the area that the characters have access to.


Since 3D space and texture coordinates are stored together with the mesh to distinguish between them texture coordinates are associated with a separate letters sequence (U, V and W)

U and V denote the X and Y axes of the 2D texture that is projected onto the 3D model. 3D generated textures have another coordinate W that is equivalent to Z


How do i make particles flow along this curve object?

Don't use a "curve guide", use the "force" ;)

Using a "Force Field" type "Force" on your curve.
Select shape "Curve"
Set the Strength to -25 (this affects the speed in which the particles flow along the curve)
The Flow value should be at least around 2.0, i used 3.5 (affects how much the particles stick to the curve, higher value, closer to/on the curve)
See to the lifetime of the particles and the end of spawning them, it will need a long .. i mean really long time to get through the curve you made (maybe raise the strength to compensate).
Eventually you can save and work over the curve like as in switch it to Bezier type so you can Clean up -> Decimate Curve to roughly 20% as in 0.2. (will get rid of most unnecessary points, after which you can switch it back to poly type)

That should do the trick, as you can see in the little visual demonstration:


How to make an ice lake with the Principled Shader?

Final:

Node setup & overview:

First of all you want to have Roughness value to be pretty low. I've used procedural Roughness map, but without it value around 0.05 will give good results. This is based on the ice you want to make.

Secondly, don't forget that clear ice is transparent, you'll need to add Transmission (like for glass). It don't need to be fully 1.0. Also ice has IOR value 1.309, I've forgot to change it.


Thank you very much for your comments.
Later i was solving how to import model by separate floors and it gives me a spoiler to solve this.

The problem causes import options and complicacy of model:

In Blender OBJ import options unchecking Smooth Groups and no Split by helped (in case of shadows on simple blocks //Groups in SketchUp had one surface identical and Smooth Groups in blender causes this problems).

Next - SketchUp allows making very complicated surfaces (many edge lines, only one surface [i used it for floor // it isn't showed in pictures]). But OBJ exporter probably has problem to divide it to triangles. It causes overcasting triangles and same shadows in flat surface. Dividing very complicated surfaces (in Sketchup by line tool) helped.

Good luck in rendering ;-)


Blender Brush doesn´t work in Ocean Modifier

Honestly, i don't know why it does not work, but i have some tips for you.

Fake it 'til you make it:
Do not use your ship to create the waves - it has to much details, too complicated. Just slows down your computer - although i am not sure whether you are working on a render farm, because your blend file is so fully packed and on my macbook i got 0.1 fps with your settings....
So i just build a quick mesh like this to create the waves:

first try out with very simple models/blend - files, whether your "idea"/concept works at all...

test: https://youtu.be/jhXz2EItvZ4
check, works

try to adapt your model in that way....

so i deleted your brush and added the super simple model from 1 to your blend file

added some movement by adding keyframes

-> that's what i learned from this time consuming "session": copy location does NOT work together with dynamic paint. Don't ask me why. I have no clue. But it works if you animate via keyframes. I guess that's why dynamic paint never worked with your ship because it is also moved via copy location.

result: (of course you should hide the primitive model and tweak the settings so that it is looking good. My waves are shitty, i just wanted to show that it works)

https://youtu.be/qFZQnPT3q9I
and this is how it looks without the "simple model", so the ship is really making the waves -> is just deleted the copylocation modifiers and animated it by keyframe.
Result:
https://youtu.be/vuQTpul-YHM
and rendered it looks like this (ok, boat was too quick ;))
https://youtu.be/musNu7EPj1Y


Do you have smooth shading active? If that's the problem, try marking some edges as sharp, use the "Auto Smooth"-option in the object data panel or split some edges.


Of course there is a simple way :)

Use Bevel modifier set to Weight, and with  Clamp Overlap
set Bevel Weight to 1 for selected edges.
It will result in some double vertices, you can use the Weld modifier to get rid of them.


How do I create a proper bevel on narrow, pointy shapes?

There are multiple bevel modes. In 2.79 If you hit "W" then "B" for the bevel tool, you can switch between them by hitting "M"


How to make an animated model jump in BGE

You can add Character type physics to your object.

Go to the Properties panel, and under the Physics tab, change the type from Static to Character and Check collision bounds; Depending on what your character looks like, you may want to change the Bounds type. As your character is rigged, you'll have to check Compound. You also can tweak the settings if you would like to modify the margin between objects, when colliding.


How do you bake ambient occlusion for a model?

First you need to UV unwrap the model so the texture can be baked

You should do this manually if you plan to need to create a real texture and you want a clean unwrapping. If you only need an AO map, Blender can do it for you automatically.

First, split the viewport by clicking and dragging the grip found in the top right corner of the 3D viewport out from the left to the center of the window. Set the new viewport to the UV/Image Editor:

Now Hit Tab to enter Edit Mode.

With your cursor over the 3D Viewport, hit A once or twice so that the whole model is selected (orange).

With your cursor still over the 3D Viewport, hit U and click Lightmap Pack. Enable New Image and set the resolution to a power of two that you want the lightmap's image to be.

You should now have a UV unwrapping in the UV/Image Editor viewport.

Next, set the material to pure white if desired

If you plan to use this ambient occlusion map as an overlay in an actual diffuse texture that you create, you want the flat parts of the surface to appear pure white so that they are pure transparent when overlaid with a multiply blend mode. By default, the ambient occlusion texture bake will include the color of the surface which is the default gray. To fix this, go to the Material tab and drag the color up to pure white and the intensity up to 1.000.

Upper box: drag the circle all the way up to pure white
Lower box: drag the intensity box to the right until it reaches 1.000

Now you can set up the actual texture baking

Under the World tab, enable Ambient Occlusion and then set the Samples under the Gather section to a number that you like. The higher the number, the higher the lightmap quality but consequently the higher the bake time. You may want to set it to something lower such as 20 for test bakes before you create a final bake at a higher setting such as 128.

Next, go to the Render tab and under the Bake section, set the Bake Mode to Ambient Occlusion. Then hit the Bake button and wait as the ambient occlusion map is baked for you.

You can watch the progress as the texture is created in the UV/Image Editor and the progress bar at the top of Blender.

When it is done baking, leave Edit Mode by hitting Tab and setting the Viewport Shading to Texture.

You can now see your model with ambient occlusion!

Note the gray: this will occur if you do not set the material to white prior to baking as described above

You can now export this texture from the UV/Image Editor by clicking Image > Save As Image.

Then just name the file, choose a format, select a file location, and hit Save As Image.


How to cause the texture through the glass?

You mean something like this? The text is engraved into back side of a scaled cube. Make sure to change the blend mode (highlighted on the right):


How to create moving, dynamic/animated fog/clouds?

As Yohello says you could use the Principled Volume and plug it into the Volume socket of the Material Output. Here is a basic way to do it (perhaps not the most realistic solution though, but you'll find other ones on youtube or maybe someone will propose here?):

Create a basic elongated shape, subdivide it a bit, give it a Subdivision Surface modifier.

Create this node chain: Texture Coordinate > Mapping > Noise Texture > ColorRamp.

Plug the Noise Texture into a Vector > Displacement node to give it a bit of 3D relief (don't forget to enable the Displacement > Displacement Only option in the Properties panel > Material > Settings > Surface).

Plug the Noise into the Density socket of the Principled Volume.

Now play with the Location values of the Mapping node in order to make the cloud shape evolve through time.


Sculpting strokes are mirrored according to the local coordinates of the object. From manual about sculpting:

  Mirror
      Mirror the brush strokes across the selected local axes. Note that if you want to alter the directions the axes point in, you must rotate the model in Edit Mode, not Object Mode

Hence if you rotated model in Object mode make sure to apply rotation (same effect as rotating in Edit mode, i.e. making changes to mesh data).

Otherwise the strokes might be mirrored not as expected (mirrored by X axis instead of Y axis or the other way around and so on). It's likely that strokes were mirrored on your mesh, but not where you were searching for them; e.g. if you rotated object 90 degrees by Z axis and enabled mirroring by Y axis, strokes will be mirrored along X axis instead.


How to determine whether a node_tree is a material or a node group?

How it represents itself.
In as much as it aint pretty have had to rely on this before, may be for same can't remember.  Noticed in console that the representation  "knows". (echoing in the console uses repr(ob) printing uses str(ob))
>>> D.materials['Material'].node_tree
bpy.data.materials['Material'].node_tree

>>> D.node_groups['Foo']
bpy.data.node_groups['Foo']

as a string is also of little use
>>> print(D.materials['Material'].node_tree)
<bpy_struct, ShaderNodeTree("Shader Nodetree") at 0x7f6bd0a86e08>

whereas looking at types et al kept coming up as same.  Hence can use this in your method
>>> def from_material(nodetree):
...     return repr(nodetree).startswith("bpy.data.materials")
...
>>> from_material(D.materials['Material'].node_tree)
True

>>> from_material(D.node_groups['Foo'])
False

alternatively endswith("node_tree") is possibly a quicker option.
Extra,

Nice solution. But so how can I get that material into a variable in
this function?

Once we know it's a material, can slice off ".node_tree" and evaluate it.
>>> repr(D.materials['Material'].node_tree)[:-10]
"bpy.data.materials['Material']"

>>> eval(repr(D.materials['Material'].node_tree)[:-10])
bpy.data.materials['Material']

Similarly could slice "bpy.data.materials['" from the start and "'].node_tree" from the end to just keep the name.
>>> matname = repr(D.materials['Material'].node_tree)[20:-12]
>>> matname
'Material'

>>> D.materials.get(matname)
bpy.data.materials['Material']


FOR RETOPOLOGIZED MESHES
- USING SHAPE KEYS
Being in Object Mode create a new shape key and name it. Enter Edit Mode and press the apply shapekeys in edit mode button. Set the value of the key to 1. Now enable the proportional editing and set it's type to Connected. Select some vertices of the lower lip and press G, Z to open the mouth.

If you want to apply the shape key value to the mesh you may use Create duplicate for editing option. It will create a duplicate of your model, but with the applied shape keys as a Basis key.

Optionally you may add a bone to control the shape key's value. Add a Single Bone (Shift+A-->Armature-->Single Bone) and place it in front of mouth of your character. Select your model and add a Driver to your shape key (hover your cursor over shape key's value, press RMB and choose Add Driver option).

Now go to the Graph Editor, change its mode to Drivers and select the shape key's name in the panel on the left. Press N to open the properties shelf and in Drivers panel change the Type to Average Value. In Variable window choose Transform Channel. Now set up things as pictured below- in this case we want the Bone (which belongs to Armature) to control the shape key's value only if it'll be transformed using Local Yaxis

You may now select the bone, then go to Pose Mode and control the shape key's value changing the bone's position.

- USING BONES
Being in Object Mode add a Single Bone and place its base, where your model's jaw hinge is located. Select your model, then a bone and press Ctrl+P-->Parent-->With Automatic Weights.

Now go to Edit Mode, select the whole mesh A and press Remove button to set all weights to 0.

Now select the parts of a mesh you want to follow the bone's movement, change the Weight value to 1 and press Assign.

You may now assign specific weights values to desired vertices to make the deformations smooth. Enable Show Weights option in Mesh Display panel to see the weights in Edit Mode. Now assign desired weights to specific vertices. Remember that the higher the weight is, the more the painted area of the mesh will stick to/follow the bone.

You may also do it in a Weight Paint mode.


Is there a way to get the edges to be a similar distance appart?

You can use vertex snapping for perfect precision.

Enable Vertex Snapping > Center
Select your center vertex and align it (using snapping) if it's not already
Select your ring and snap it to the aligned center vertex.


Best way to cut a groove around circumference of irregularly shaped object

The first thing I would recommend is retopoligizing and cleaning up your mesh. CG Cookie literally released a whole flow on retopoligizing not long ago so I would recommend trying that out (it does cost however). The other thing you could use if you don't mind spending about $70 is retopoflow. Very good resource from the blender market.

It is important to keep topology into consideration because it firstly makes overall editing very easy, and it allows you to properly use the sub-surf modifier for a smooth finish.

Once you have retopologized this, you will have a very nice simple mesh. Creating a grove around it should not be difficult. Just add in some edge loops and extrude inwards.


Here is perhaps how I would try to implement it (please excuse me if this is too simplistic):

Maintain a queue of the packets that allows concurrent access
One thread (process A) continually monitors the queue and processes and removes the packets from it. Since this does not have any timer even, it isn't subject to time constraint; it will have to wait until there are packets available in the queue (maybe feasible with multiprocessing python package)
The timer driven modal function (process B) can simply fetch the network packets and place them in the queue, this can be (I guess) reasonably expected to finish in less than 0.1 sec
I am not sure whether the 'settled' and 'unsettled' distinction for the state of the incoming flow will be of much use in this case, as this information will always be a posteriori (but again I maybe totally wrong).

NB: You may also want to put this question on stackoverflow, since this is more of a algorithm/python question.


Python doesn't like inconsitently mixed tabs and spaces for indentation.
Ctrl-T opens the property panel, check that the Tabs as Spaces is ticked.
You can usually fix this by unindenting the lines in question by Shift-Tab to the first column and re-indent them Tab again.

There is also the menu option available  Format > Convert Whitespace > To Spaces  (or to tabs)
Related:

https://stackoverflow.com/questions/5685406/inconsistent-use-of-tabs-and-spaces-in-indentation


Does the Blender Game Engine support mobile platforms?

Currently out of the box, there is no support. Work has been done to port blender to android, link here, here, and here. You will have to build a mobile version yourself.


Can you repeat a portion of a texture across a face?

You can use some math nodes and keep simple proportions for you texture parts (for instance working with 1/2 or 1/4... easy to multiply or divide).

Here is an example :

Each face is assigned to a material composed of nodes like these ones (this material is for the red triangles) :

Amount of repeats
Shift U as the triangle starts at U = 0.5
Don't shift V as the triangle starts at V = 0
Modulos : here the texture is divided in 2 (so modulo = 1/2)
Shift back U to 0.5
Shift back V (but V starts at 0)

For the blue square, you may invert the roles for U and V.

For the green circle, just don't shift anything.

To reach the upper right quadrant, shift both U and V 0.5.


Solution to this problem:
1.
2.
Select all edges along top and bottom face of an engraved part and bevel those

*.
If you want to avoid strange reflections (on faces within the hole) when applying texture to blender model in keyshot, I recommend to bevel edges of a hole as well.
Model before beveling:

Model after beveling:

Hope this will help someone in the future. Thanks to HISEROD for the right direction.


Is it possible to use vertex paint with symmetry? Mirror modifier not an option

Spoiler alert, this is only a workaround, there's no native way to paint with symmetry on vertex paint mode, :'(

1) Make a vertex group assigned to one half of the symmetrical model

2) Duplicate-link(pressing "alt-D") the object and mirror the duplicate with "Ctrl + m" and then press "x"

3) Add a "Data Transfer" modifier to the original object

4) Set the source object as the duplicated object

5) Tick "Face Corner Data" and select Vcol, tick on Generate Data Layer at the bottom of the modifier

6) Set the vertex group to the previous vertex group created in 1)

7) You must see the original model with the vertex colors symmetrical and live painting with symmetry, you could apply the modifier when you have finished painting.

8) If the results are not as expected you can play with the method of mapping the source, the default method is "Nearest Corner And Best Matching Normal"

Modifier not viewport seen

Modifier viewport seen, live painting symmetrical vertex colors

PD = I have heard that is pretty hard to implement a x-mirror option for vertex paint mode because vertex color is face-corner data, but I don't believe that, :(


Blender is rendering another project, and sequencer/compositing is un-checked under Post Processing. Why?

I forgot I keyframed the Focal Length from very small to big for a zooming in effect in each file, making them look similar. I’ll escort myself out now...


If you want to change the rotation of the bevel, you need to rotate the bevel object in Edit mode.

Enter edit mode for the small oval that is the bevel object.
Select all the curve points and rotate by 90 degrees (I can't tell which axis from the screenshot).


I'm not entirely sure what you're trying to do, but from this... I'd recommend creating a new layout and if you want to publish it save the blender file like that, or save it as the startup file


Blender how to make save game in exact directory?

Blender treats paths beginning with "//" as relative to the blend file directory. You can use bge.logic.expandPath to get the absolute path that you can use in standard python file calls to create data files containing all the variable data you want to store.

bge.logic.expandPath(path) Converts a blender internal path into a proper file system path.
Use / as directory separator in path You can use ‘//’ at the start of the string to define a relative path; Blender replaces that string by the directory of the startup .blend or runtime file to make a full path name (doesn’t change during the game, even if you load other .blend). The function also converts the directory separator to the local file system format.
Parameters:    path (string) – The path string to be converted/expanded.
Returns:    The converted string
Return type:    string


Strange graphics glitch when working with very small units(milimeters)

The issue is that you set the clip range to a very large value:

By setting the end clip to such a large value you are loosing precision. Blender can no longer resolve geometry that is close to each other. The issue is called Z-fighting, the same as when you have geometry that is occupying the same space in the scene (This happens in all 3D software not only in blender). As a rule your start and end clip settings should be so that they encompass your scene, but not a lot more. Why would you need to set the end distance to trillions of Km when you are working with objects are a few centimeters long?


Is it possible to mirror an object across two planes?

Yes, you can model the half of a boot and mirror it at the object's origin (orange dot) with a mirror modifier. Then just add another mirror modifier and specify another object in the modifier's settings that will be the origin for the 2nd mirroring. The object can be the character model or an Empty, for example.


It really depends on your scene. At the Blender Institute we render mostly on CPUs; when a GPU runs out of memory it'll crash, and when a CPU runs out of memory it'll swap. Things will get slow, but at least the render will finish at some point. Of course it also helps that we have a few very nice servers with CPU 40-80 cores each. If the RAM required to render the scene fits the GPU memory, things should be fine and it really depends on what kind of hardware you fit exactly.


procedural texture randomises its position every frame of animation

Your question, directly: would baking the textures fix the issue, is answerable by Yes. I think you need to know why. Any procedural textures have to anchor on to something. They have to know their location and scale. Generated and Object coordinates offer different locations and scales (learn more about those specifics as metaphor_set commented) as inputs. You've chosen one of each on aesthetics alone which is totally fine.

Personally, I'm not in the 'physically correct' camp because I think artistic tools are meant to allow expression and artistic expression isn't always physically correct; but you've proven something by commenting about Window as a coordinate input. You froze the position and scale of the procedural texture to the Window that's viewing the scene along the Z axis. Since you and the Window move together, the geometry is passing through a "cloud" of procedural texture so the movement is easier to mentally track. In a rough way, you've 'baked' the texture to the Window.

Well. The next best thing is to bake the texture to geometry that moves so the gloves or camera or coordinates don't move separate from the view or gloves. (Confusing, I know.)

You've found your happy still-frame that represents the position and scale of "Leather." Stick it! UV unwrap the thing; I see the settings "Leather" provide for Diffuse, Normal and Glossiness information and that would mean Baking/F3 Saving ALL those inputs OR, perhaps take a long, careful time to unwrap the glove along intelligently chosen seams and use UV as the coordinate inputs. This WILL once again alter the scale of your texture.

You might have to sacrifice using different Vector locations and scales (I don't fully understand that without knowing "Leather"). But, you'll get away from a texture that looks really dodgy and is moving about.

Image is identical texture three times changing only the Vector input to alter the scale and behavior.


How to create a procedural galia melon material?

Here is a rough quick attempt.
Use a Voronoi texture set to Distance to Edge as base for the mask between the two colors.
Distort it with another smaller Voronoi texture to give the "cracks" a rougher look, by mixing "clean" texture coordinates with the texture using a Mix RGB node.
Adjust all progressions with color ramps, and you can use a final color ramp through
Use a similar voronoi based texture for bump.


Mesh rigged to skeleton deformed in pose

It matters which bone is weight painted. When I selected the bone closest to the backpack (a spine bone in the person's upper back) and then painted the backpack red, it stayed in position and did not deform anymore.


There is a simple way to create a glow effect in Cycles.

Add a cube.
In the material section, Choose "Transparent BSDF" or "Glass BSDF" as the surface
and the colour of your choice.
Select "Emission" in the volume and choose the colour as white.The
strength can be of your choice

Add a place below the cube
Add another cube and scale it up slightly by pressing S and
dragging the pointer.
Make the colour of the cube black and choose the surface to be
"Emission"
Go to modifiers, chose wireframe, edit the thickness to your liking.

Place the wireframe over the cube and then Render.It should look
similar to the example below:


3D tube with sharp corners and uniform radius?

This method will only work well for angles less than 90°:

Set your curve to 3D and bevel it with circle curve, just as you would normally.
Then add solidify modifier, check Even Thickness and High Quality Normals, set thickness to negative value:

Then select that circle, go to editmode, and scale it down as you can, to a point. Stop when the tube starts displacing - that will be floating point limitations
You should end up with an ok tube with sharp turns and even thickness, it wont be perfect but I can't think of another way.


This can be done quite a number of different ways, I have listed three.

You could make a new UV map, and rotate the uvs 90° (like chebhou said). Then use that uv map just for the length fade.

You could add a Gradient Texture node (or a image of a gradient) and use a mapping node to control which way the gradient is going.

(my favorite) You could add a Texture Coordinate node and then a Separate XYZ node. That will give you a gradient running along the axis specified. In this picture it would be black at the left edge, and running along the X axis white at the right edge.

So your whole setup could look something like this. The X axis from the separate node is used for the "length fade." The Y axis is how I'm creating the beam fading out top to bottom. Then the Multiply node combines the two gradients.


Python: How to Export All the UV Layouts in Blender

To the answer

It won't work if the code in line 17 - "C:\\Users\\Desktop\\UVLayouts\\" doesn't exist on your computer as a Directory (or blender doesn't allowed to modify in that directory). You could change the path of it or create a directory on that location with the same naming.

The mechanism of how bpy.ops.uv.export_layout work on opening a file make this error. It use open, a python built-in function to deal with file.

It requires the parent folder of the filepath exist, as discussion in here.

You should check out the discussion carefully since that is a basic knowledge of python. And for my advise, you could always search the error in google, the answer for your problem is there most of the time. You need to search it with a good key words, in this case FileNotFoundError: [Errno 2] No such file or directory will do the work.

The Script

As Martin Z point out, we should fix this script a little bit to make it more robust (for those not familiar with programming):

import bpy
import os

# You should change this varibale in "here" to match your own directory path
# use '/' or '\\' for hirecacy
target_dir = "C:/some/directory/"

selObj = []

for obj in bpy.context.selected_objects:
 selObj.append(obj.name)

bpy.ops.object.select_all(action='TOGGLE')

i=0
while i < len(selObj):
    bpy.context.scene.objects.active = bpy.context.scene.objects[selObj[i]]
    bpy.ops.object.mode_set(mode="EDIT")
    bpy.ops.mesh.select_all(action='TOGGLE')
    bpy.ops.mesh.select_all(action='TOGGLE')
    bpy.ops.uv.smart_project(angle_limit=66.0, island_margin=0.0, user_area_weight=0.0)
    full_file_name=target_dir + bpy.data.objects[selObj[i]].name

    # This code detected whether target_dir exist, if not, then create it
    dirname = os.path.dirname(full_file_name)
    if not os.path.exists(dirname):
        os.makedirs(dirname)

    bpy.ops.uv.export_layout(filepath=full_file_name, mode='PNG', opacity=0)
    bpy.ops.object.mode_set(mode="OBJECT")
    bpy.ops.object.select_all(action='TOGGLE')
    i+=1

Run this script in blender 2.7x text editor, and change target_dir = "C:/some/directory/" to your desired location. And still, strongly recommend to read the code carefully.


Blender: Scale a group of vertices using python

I prefer a more low level solution. This particular approach requires the object to be in Object Mode, but a small change using Bmesh would let you do it in edit mode. This will give you some insight I hope.

import bpy
from mathutils import Vector

# replace this with reference to your object.
obj = bpy.data.objects['BezierCurve']

def get_average(vert_range):
    med = Vector()
    for vert in vert_range:
        vec = vert.co
        med = med + vec
    return med / len(vert_range)

verts = obj.data.vertices
num_verts = len(verts)
scale = 1 / (num_verts / 4)
j = 0
for i in range(0, num_verts, 4):
    mid = get_average(verts[i:i+4])
    for k in range(i, i+4):
        verts[k].co = verts[k].co.lerp(mid, 1-(j*scale))
    j += 1

For every 4 verts, it finds their average, and scales those verts towards that average by an increasing value every 4 verts. I may have reversed the direction so instead of 1-(j*scale) you might want (j*scale)

for completeness A Bmesh solution, this works in edit mode

import bpy
import bmesh
from mathutils import Vector

def get_average(vert_range):
    med = Vector()
    for vert in vert_range:
        vec = vert.co
        med = med + vec
    return med / len(vert_range)

# Get the active mesh
obj = bpy.context.edit_object
me = obj.data

# Get a BMesh representation
bm = bmesh.from_edit_mesh(me)

verts = bm.verts
num_verts = len(verts)
scale = 1 / (num_verts / 4)
j = 0
for i in range(0, num_verts, 4):
    mid = get_average(verts[i:i+4])
    for k in range(i, i+4):
        verts[k].co = verts[k].co.lerp(mid, 1-(j*scale))
    j += 1

bmesh.update_edit_mesh(me, True)

As you can see you were going in the right direction.


This will do what you want:

The Color Ramp will allow you to control/fine-tune the amount of transparency.


There's a lot of different ways to do this. I suggest using modifiers for a non-destructive workflow. You can get the specific result you're looking for by using a few different modifiers, but perhaps the most straight forward is the Simple Deform Modifier.

Add the mesh for the propellor blade, with the origin centered along the Z-axis, and the mesh offset along the Y-axis. The origin position is key for the modifiers to work right.

2.Add an Empty, and rotate it accordingly (you will likely need to adjust the rotation after Step 3, depending on your configuration).

Add a Simple Deform modifier. This will be used for the bending of the mesh. Set the Origin field to use the Empty you created in step 2. Set the mode to Bend and adjust the Deform Angle as desired.

Add another Simple Deform modifier. This second modifier will control the amount of twist. Set the modifier mode to Twist and once again adjust the Deform Angle as desired.


Separate stl into two stl's based on size of chunks-for 3d printing

In edit mode, separate the spheres by loose parts by pressing P >> Loose Parts. Now you have each sphere as a separate object. Put all of these objects in a group by selecting all of them and pressing Ctrl+G.

Now, in Animation Nodes, we will create a loop that only returns one type of sphere based on the vertices count. We first get the vertices count of any of the objects, lets say the first, then we loop over the objects and only return the ones that have a mesh with the same number of vertices as the vertices count we just computed.

Now, hide those objects we just computed using the Object Visibility Output Node.

Select those objects and export them using the Selection Only option, delete those object, unhide the other objects and export them. You now have two files each have only one type of spheres.

Notice that if the two spheres have the same number of vertices but different scales, then, similarly, the volume of the bounding box can be used to filter the objects.


Editing an android screen capture video in blender

Maybe try to change video format before importing to blender? Idk in which format the app is recording the video file, maybe this may cause issues. :)


How can I import sound for an animation that will be used in a Unity3D game

Go to Editor Type > Video Sequence Editor
Then go to Add > Sound

In this way you can synchronize audio with your animation in Blender.


You could remodel part of the hand so that both hand and wrist meet with 6 vertices.

And or checkout how to use Blenders Data Transfer or Normal Editor Modifiers.
I rememeber trying to get those to work when they were first added a couple of years ago but failed. Way to complicated for me.


How to bend a part of sphere or cylinder the incremental way?

CtrlE Edge Menu > Bridge Edge Loops does more than you might think.

Just the two loops at the ends were selected to be bridged, here. You could also use the tool to join the tube and the surface its rising from.


How to interrupt a rendering which is not displayed in the UI to interact with?

Minor code changes are required to make the code from the linked answer work for objects in selection.

Following modal operator is just some kind of barebone code, a good starting point using the timer though. Edit the render path according to your Operating System, run the script, select the objects in 3d view, press F3 and type Render multi...

import bpy

class Multi_Render(bpy.types.Operator):
    """Docstring"""
    bl_idname = "render.multi"
    bl_label = "Render multiple times"

    # Define some variables to register
    _timer = None
    shots = None
    stop = None
    rendering = None
    path = "/tmp/"       # Linux
    #path = "C:\\tmp\\"  # Windows

    # Define the handler functions. I use pre and
    # post to know if Blender "is rendering"
    def pre(self, dummy):
        self.rendering = True

    def post(self, dummy):
        self.shots.pop(0) # Remove current object from list
                          # Render next Object
        self.rendering = False

    def cancelled(self, dummy):
        self.stop = True

    def execute(self, context):
        # Define the variables during execution. This allows
        # to define when called from a button
        self.stop = False
        self.rendering = False

        # One shot per selected object
        self.shots = [o.name for o in context.selected_objects]

        context.scene.render.filepath = self.path

        bpy.app.handlers.render_pre.append(self.pre)
        bpy.app.handlers.render_post.append(self.post)
        bpy.app.handlers.render_cancel.append(self.cancelled)

        # The timer gets created and the modal handler
        # is added to the window manager
        self._timer = context.window_manager.event_timer_add(0.5, window=context.window)
        context.window_manager.modal_handler_add(self)

        return {"RUNNING_MODAL"}

    def modal(self, context, event):
        if event.type == 'TIMER': # This event is signaled every half a second
                                  # and will start the render if available

            # If cancelled or no more shots to render, finish.
            if True in (not self.shots, self.stop is True):

                # We remove the handlers and the modal timer to clean everything
                bpy.app.handlers.render_pre.remove(self.pre)
                bpy.app.handlers.render_post.remove(self.post)
                bpy.app.handlers.render_cancel.remove(self.cancelled)
                context.window_manager.event_timer_remove(self._timer)

                return {"FINISHED"} # I didn't separate the cancel and finish
                                    # events, because in my case I don't need to,
                                    # but you can create them as you need

            elif self.rendering is False: # Nothing is currently rendering.
                                          # Proceed to render.
                sc = context.scene

                # I'm using cameras named just as the output files,
                # but adapt to your needs
                #sc.camera = bpy.data.objects[self.shots[0]]

                sc.render.filepath = self.path + self.shots[0]
                bpy.ops.render.render("INVOKE_DEFAULT", write_still=True)

        return {"PASS_THROUGH"}
        # This is very important! If we used "RUNNING_MODAL", this new modal function
        # would prevent the use of the X button to cancel rendering, because this
        # button is managed by the modal function of the render operator,
        # not this new operator!

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

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

if __name__ == "__main__":
    register()

    #bpy.ops.render.multi('INVOKE_DEFAULT') # Test call

Note: You don't necessarily have to use a for-loop, the post method removes each item from the list in case the rendering is finished. Also I suggest split up the process into 2 operators, one for rendering only and another one to manage the whole process.

In case you don't want the render window to show up for whatever reason, you can either set the display_mode to 'NONE' temporary:

    elif self.rendering is False: # Nothing is currently rendering.
                                  # Proceed to render.
        sc = context.scene
        sc.render.display_mode = 'NONE'

        sc.render.filepath = self.path + self.shots[0]
        bpy.ops.render.render("INVOKE_DEFAULT", write_still=True)

        # Reset display mode
        sc.render.display_mode = 'WINDOW'

and add a check for the ESC event to remove the timer:

def modal(self, context, event):

    if event.type in {'ESC'}:
        context.window_manager.event_timer_remove(self._timer)
        bpy.app.handlers.render_pre.remove(self.pre)
        bpy.app.handlers.render_post.remove(self.post)
        bpy.app.handlers.render_cancel.remove(self.cancelled)

        self.report({'WARNING'}, 'User interuption')
        return {'FINISHED'}
    ...

Or you can call render.render() without INVOKE_DEFAULT to execute the operator directly (without the UI), e.g. based on a given variable (notice that the progress bar does not show up):

        if render_window:
            bpy.ops.render.render("INVOKE_DEFAULT", write_still=True)
        else:
            bpy.ops.render.render(write_still=True)

Also you can add an invoke() method along with a BoolProperty() to the operator so the user can decide whether or not displaying the render window:

render_window: bpy.props.BoolProperty(
    name="Show Render Window",
    description="A bool property",
    default = False
)

def invoke(self, context, event): # Used for user interaction
    wm = context.window_manager
    return wm.invoke_props_dialog(self)

and add a condition for that within the modal method (before rendering):

    elif self.rendering is False: # Nothing is currently rendering.
                                  # Proceed to render.
        sc = context.scene

        if self.render_window == False:
            sc.render.display_mode = 'NONE'

        sc.render.filepath = self.path + self.shots[0]
        bpy.ops.render.render("INVOKE_DEFAULT", write_still=True)

        # Reset display mode
        sc.render.display_mode = 'WINDOW'

However, it is indeed tricky to make it work properly...


Excluding an image plane from interacting with light

If I understand you correctly, you want the background plane to be unshaded. You could use a material that does not use a shader node, by creating a new material, removing the Principled BSDF node, then connecting a node like RGB or a texture node to the Surface output. Note, this would make it so that it would not interact with any light source. If you want it to interact with a light source, you would have to use Layers (Top Right) and then merge them together using the compositor and nodes. You can choose which things interact in layers using collections, by disabling what you don't want to affect the objects in your scene. Good luck!


Fluid domain stretched to boundary after baked

Your inflow sphere has a negative scale.

Use Ctrl+A to apply the scale,

The scale is applied but we can see the normals have changed (reversed because of the negative scaling).

To fix them, enter edit mode with Tab, select all with A and Ctrl+N

Now you can bake your bath :


How do I fill these holes, fill space without information, and deal with overlapping meshes

Try the remesh modifier. This will generate an entirely new manifold mesh made exclusively of quads.


Why the material showing white (different color)

You've enabled the Shadow Catcher option in the Properties panel > Object > Visibility, disable it.


Basic Interface 2.8: How do I get Shader nodes in view to be centered and large on first click?

Press the Home key to put all the nodes in view, press the period key on the keypad to center on a selected node.

Also, if you're on a mac, you might check this: How do I emulate the Home key on a mac laptop in Blender?


Managed to get rid of the lines by decimating the donut again until the I got a more basic mesh of the donut and then re-applying the subdivide modifier.


Combine 2 Scenes / Volumetric Fog from BI to Cyles

Okay after some tries i found a simple solution.

create a new BI-Material, set diffuse and spec to "0" enable transparency and change to mask and alpha to "0".

This works fine for me!


Calculating 3D world co-ordinates using depth map and camera intrinsics

Several things to take into account to rebuild the rendered mesh.

Camera parameters:

Focal angle, in particular to reconstitute the mesh with the good positions. See here.
Also, camera clipping planes can be used to filter the image.

Camera axis:

Camera's Z is to the opposite to the projection: we need to minus Z from the image.
The rendered image is like a mirror: we need to minus X from the image.

Image size:

If camera is not shifted (common case), it is at the center of the image.
So coordinates should be centered around the half of the image width and height and scaled in consequence.

Compositor node:

Don't normalize the depth. If normalized, the values have no mean: they are just remapped between 0 and 1.

Image format:

Don't use PNG. You can't store the wanted values in a PNG except if normalizing them and we don't want that.
Use openEXR which allows to store the Z values as they are.
Compositor settings
Use openEXR and don't normalize:

Code
Comments below for key elements:
import bpy
import cv2
import numpy as np
from math import tan
from mathutils import Vector

def point_cloud(depth,cam):

    # Distance factor from the cameral focal angle
    factor = 2.0 * tan(cam.data.angle_x/2.0)

    rows, cols = depth.shape
    c, r = np.meshgrid(np.arange(cols), np.arange(rows), sparse=True)
    # Valid depths are defined by the camera clipping planes
    valid = (depth > cam.data.clip_start) & (depth < cam.data.clip_end)

    # Negate Z (the camera Z is at the opposite)
    z = -np.where(valid, depth, np.nan)
    # Mirror X
    # Center c and r relatively to the image size cols and rows
    ratio = max(rows,cols)
    x = -np.where(valid, factor * z * (c - (cols / 2)) / ratio, 0)
    y = np.where(valid, factor * z * (r - (rows / 2)) / ratio, 0)

    return np.dstack((x, y, z))

img = cv2.imread('C:/tmp/depth0001.exr',  cv2.IMREAD_ANYCOLOR | cv2.IMREAD_ANYDEPTH)
img = img[:,:,1]

# Get the camera
cam = bpy.data.objects['Camera']

# Calculate the points
points = point_cloud(img, cam)

# Get the camera matrix for location conversion
cam_mat = cam.matrix_world

# Translate the points
verts = [cam_mat @ Vector(p) for r in points for p in r]

# Create a mesh from the points
mesh_data = bpy.data.meshes.new("result")
mesh_data.from_pydata(verts, [], [])
mesh_data.update()

# Create an object with this mesh
obj = bpy.data.objects.new("result", mesh_data)

# Link it to the scene
scene = bpy.context.scene
scene.collection.objects.link(obj)

Results

Test file (relocate the compositor output before using it, and the file location in the code)

Also note (if useful), it seems that color management has no influence for depth.


Full animation 2D/ How to change colours

You can change the colour under Properties Editor > Material Tab.

In "2D Full Canvas" layout you don't see this editor.

Since you have some material set, you should switch between materials from 3D View > Properties (N) > Brush just press Pin button.


When I turn on cycle render, object turns all white w/ no color, any help? (ver 2.79)

The only thing I can think of is that somehow you probably added a material in the "Override" section inside the "View Layer Properties" tab.


How do I control the origin to my scale?

Just use 3D cursor as pivot point :).

Select the edge loop and put 3D cursor there. Mesh > Snap > Cursor To selected.
Set Pivot point to 3D Cursor.
Use Scale tool gizmo to scale only on X axis.


Note that the two later-mentioned options are not checked because this photo is a cropped version of one that came from the Blender Reference Manual.

You need the Merge option. Clipping, too, would help.

Merge

The Merge option will join two vertices (1 real and 1 generated by the Mirror modifier) into one. The two to be joined are specified by each  being within the Merge Limit: of each other. 0.001 is a good default value, so I would leave it there.

Clipping

This prevents real vertices from breaking the "mirror." This will make joining the vertices a lot easier because you can just grab the top 8 faces (in your case), key G, then Y, then slide your mouse left to bring the sides together and LMB to confirm when the vertices stop moving as they hit the "mirror." The bolded part shows how Clipping factors into merging the vertices.

Last Note

Do keep in mind that once you enable this and merge the vertices, you will not be able to move them away from the mirror for the following reasons.

Think of it like constraints. A "merge" constraint merges the vertices into one; they can no longer be separated.
A "clipping" constraint (for some reason) still treats the vertices as two. Moving either away from the mirror would pull its partner through. That can never happen.

If you want to move a joined vertex away, turn off Clipping.


How to weld two control points of a curve?

Unfortunately there is not.
If it is a Poly type curve composed exclusively of straight linear segments, then you can safely convert it to a mesh object, remove doubles as mesh, then convert back to a curve.
If there are curved segments converting to mesh will be a destructive process, so the only way is to manually go over the duplicate vertex, and erase/fill.
Make sure you place the cursor over the existing handle first, so when you erase one vertex you can fix the handle position for the following one, then erase the vertex and press F to fill the gap or Alt+C to close the curve if it is the last gap. Then you can send the handle to the correct position using the snap menu with Shift + S > Selection to Cursor.

Alternatively you can use Lichtso's Curve CAD Blender addon, which among other features has a builtin Merge Ends feature for Bezier curves, vaguely similar to Remove Doubles for meshes.

Merge Ends
Merges two end control points into one while preserving the relative
positions of their handles.

After installing and activating the addon in User Preferences, you can access the functionality while in Edit Mode in a Bezier curve object, by pressing W > Specials Menu > Bezier CAD > Merge Ends
For Blender 2.8+ Curve CAD addon is shipped by default and has a Remove Doubles operator that works like the mesh counterpart.
You can find it by default under the 3D View Sidebar, Edit Tab, Sanitize > Remove Doubles.


Blender only calls register() and unregister() on the top-level module, i.e. the file that has the bl_info dict in it. You're responsible for calling things on your submodules.

You could be importing a module that handles registration on something wildly different. For example, a register() function in some submodule could register a new user here on Stack Overflow. Blender doesn't know which function does which, and thus only calls that one top-level register() function.


Yes you can do this.
Select deform_belly_b.L And set it to 1 (make sure rest of the shapekeys are at o).
Then press the arrow key below the '-' button , and select duplicate from mix.
Now select the new generated shapekey again press the down arrow key and select Mirror shape key.


Is there any way to get a specific angle using the knife tool?

This is a work around.
For a simple object like your cylinder, simply rotate it in object mode 35°, make the cut, then rotate the object back.

For more complex objects where you can not rotate it. You can align the view to a rotated face. You could duplicate a face out of your mesh and separate it in to a new object, or just add a new object, a plane or an empty; then align the view to it with  with ShiftNumPad 7.

Finally do not forget that you can roll the view, but that is limited to 15° increments.


How to transform world space vertex to camera space position in Cycles OSL

for transforming the position you should use point type because according to the OSL Language Specs :

  Depending on the type of the passed point p, different transformation
  semantics will be used. A point will transform as a position, a vector
  as a direction without regard to positioning

just change the type of the Position variable to point or use the P variable that holds the current position then use the transform function as you did ; even after that the whole objects will be bright white, so i have tried to normalize the Z coordinate  using two variables which act as near and far planes that limits the depth range :

shader depth_shader(
    float minZ = 0,
    float maxZ = 1,
    output closure color Color = emission())
{
    point lP = transform("camera", P);
    float Z = lP[2];
    if( (Z>minZ) && (Z<maxZ))
        Z = (Z-minZ)/(maxZ-minZ);
    else
        Z = 0;
    Color= color(Z, Z, Z) * emission();
}


From user2859's comment:

  It doesn't use normals to determine where the ray is. It just swaps a traversal flag on ray pass.


Can I get an IK constraint w/ stretch to only scale bones on their Y axes?

IK stretch bones do stretch in all 3 axes and can't behave like you want.
The solution and common method is to

duplicate all the bones in the chain (except the control) and un-parent them from each other
for each bone_copy set Copy Location and Copy Rotation constraints targeting the original bone
for each bone_copy set Stretch To constraint targeting the next bone in the chain. This constraint should have Volume set to XZ to maintain reality or to None if you only want to stretch in Y axis
bind the mesh to the copied bones


Custom icons work when example is run in TextEditor, but fail in my add-on code?

in particular this line won't produce the same result when running it as an add-on:

script_path = bpy.context.space_data.text.filepath

because the code isn't located in a text data block inside the .blend any longer, but directly on your file-system/ harddisk

to get the script path as an addon you can do

script_path = os.path.dirname(__file__)

or as a one liner set icons_dir:

icons_dir = os.path.join(os.path.dirname(__file__), "icons")

to complete your script. I reused the template in TextEditor, and some variable names may have changed. (good practice to figure out what's different). There's no need to use global keyword, using a dict for the preview_collections lets you avoid that complication.

bl_info = {
    "name": "FILL ME IN",
    "author": "fauxbar",
    "version": (0, 1),
    "blender": (2, 7, 6),
    "category": "3D View"
}

import os
import bpy

# global variable to store icons in
preview_collections = {}

class ToolsPanel(bpy.types.Panel):
    bl_label = "MyAddon"
    bl_space_type = "VIEW_3D"
    bl_region_type = "TOOLS"

    def draw(self, context):
        this_icon = preview_collections["custom_icons"]["custom_icon"].icon_id
        self.layout.operator("hello.hello", icon_value=this_icon)

class OBJECT_OT_HelloButton(bpy.types.Operator):
    bl_idname = "hello.hello"
    bl_label = "Generate MyMesh"
    # the icon is told to appear by layout.operator(...icon_value=this_icon) (above)

    def execute(self, context):
        print("Hello world, from space")
        return{'FINISHED'}

class Panel(bpy.types.Panel):
    """Creates a Panel in the 3D view Tools panel"""
    bl_label = "Custom Icon Preview Panel"
    bl_space_type = "VIEW_3D"
    bl_region_type = "TOOLS"

    def draw(self, context):
        self.layout.row().label('something')

def register():

    import bpy.utils.previews
    pcoll = bpy.utils.previews.new()
    icons_dir = os.path.join(os.path.dirname(__file__), "icons")
    pcoll.load("custom_icon", os.path.join(icons_dir, "icon.png"), 'IMAGE')
    preview_collections["custom_icons"] = pcoll

    bpy.utils.register_module(__name__)

def unregister():

    for pcoll in preview_collections.values():
        bpy.utils.previews.remove(pcoll)
    preview_collections.clear()

    bpy.utils.unregister_module(__name__)

if __name__ == "__main__":
    register()


It looks like you are using an old copy of the rig, probably the version that was included with the animation course which was made in v2.56. The new version of baker has changed a little.

Go to the CGCookie resource page and download the current version of the baker rig.


Change Text Color in Blender Game Engine?

You need to set the Object color in Properties > Display:

Text objects are made out of polygons in the 3D view, however in the game engine they are rendered straight as text (there are also some issues with picking the resolution to render it at, which is why it sometimes looks pixelated).

If you want to have your text look as it does in the 3D view (3D, with materials/textures), then you'll have to convert it to a mesh (AltC> Convert to mesh). Note that once it's a mesh you can no longer edit it as text.

If you do need to have dynamically editable text, then perhaps the technique mentioned in this comment will help:

  . . . I don't recommend using text objects at all, since they are a
  hack right now. The other problems you get are no depth sorting, does
  not respect materials, Z buffer issues, no alignment. I recommend
  using this method. If anything you could use text objects to render
  text off-screen and combine it with the uv mapping technique.


Change edge information display in Blender 2.80 with python

I found a solution if anybody needs this information:

overlay = context.space_data.overlay

overlay.show_edge_seams  = True
overlay.show_edge_bevel_weight = False
overlay.show_edge_crease = False
overlay.show_edge_sharp = False

Documentation:
https://docs.blender.org/api/blender2.8/bpy.types.View3DOverlay.html


Is it possible to convert displacement node to "baked" geometry (OBJ, FBX, etc)?

Nope, not that I know of if you are referring to the adaptive subdivision with the experimental option enable that displacement only happens at render time.


HDRI Renders in preview but not in final render

So, I was able to solve the problem by cleaning up the model. I deleted a lot of objects and now it renders correctly as usual. I guess it was a problem with my system and nothing with the model itself. Thanks again to everyone for the assistance and help! Have a great day


Auto Merge Editing in Workspace option shelf is gone?

you can find this options in Active Tool and Workspace settings...

and another option is..
you can right click on any icon on header and in header menu you can find Show Tool Settings


Video texture on blender cube displayed all over the cube, not separately on each faces while using it in unity

Well, as i assume many noobs like me will possibly meet the joys of playing with UVs and so will they struggle with this aswell, here is the proper way to achieve this (as i said, i missed something about UVs):

In order to make sure each face is treated as an unique surface, go to blender, switch into edit mode and repeat this process for each and every single face of your cube/object:

Select your face or the ones wich are part of it
Ctrl + E -> make seam
Press "U" -> Unwrap
If you've done that right, the UV editor should show you only the shape of what you've selected.
Redo for the next face until you've done that for each one of them.

Worked for me, spent hours wondering "How" Hopefully that will help peoples out.


How to get index Slot Particle or Delete Slot Particle by Name?

You can find the particle system slot index using:
index = bpy.context.object.particle_systems.find("the name you want")


Transparency animation not working with a plane

I found out the problem. I had to change the setting in the render properties, light paths, to allow more transparency.


Image Isn't Rendering Object When Rendered

The above image shows aligning the camera to the view.

Make sure your camera is pointing at your view. The view is convenient for editing.  The camera determines the final render.

Press Control Alt Numpad Zero.

Please rotate the lights so they are pointing directly at the plane.

For the simple scene and sun lamp the light ray passes directly through the plane.  This placement may be good for you today although it is not strictly necessary.  Direction is the most important.

Such as a bright light in your eyes directly.

If the light direction is parallel to the plane no brightness will occur.

If the plane becomes too bright, reduce the energy setting, which is located with the yellow arrow in the image above.

If you cannot get it to work in 8 minutes,  I suggest the following. Save your current file. Either create a new Blender file or a new Blender [scene] .  Then recreate all the objects, materials and textures, and lamps.  Fresh start often helps for a simple scene .


It seems that your startup file has some issues. You can go back to the factory startup file by doing the following:

Go to File > Defaults > Load Factory Settings. This loads in the startup file that would come with a new installation of Blender.
Go to File > Defaults > Save Startup File. This saves the current .blend file (in this case, the factory one you just loaded) as the startup one.
If 1 and 2 do not solve your problem, you may also have to reset your preferences by going to Edit > Preferences (while in the factory file), click on the menu button in the bottom left corner, and click Save Preferences.
If 1, 2, and 3 still do not solve your problem, you may have to reinstall Blender.


It's a new Cycles only feature, but yes. In material nodes, try using Geometry>Random Per Island. Map and control the output via color ramps.


C3D Importer does not work, Context is incorrect error

Make sure you are in Object Mode before you import!

You could also add a mode switch command to the import script:

bpy.ops.object.mode_set(mode='OBJECT', toggle=False)


This is what the Holdout shader is for:

This shader affects the alpha channel when Transparent is enabled in Render settings > film.

If you really want to create an actual "greenscreen", then see Node for setting render colour, regardless of lighting


Ok i figured it out myself, had snapping to closest face enabled.


How can i create borders to an entire circuit/track?

Select all the edges, extrude them and then you will have flat faces as borders. Select those faces (with face select mode) and extrude them upwards. You can extrude faces just like you can extrude vertices and lines.


How to do texture box mapping with blending in Blender Internal

The key to this is in the node set up in the first image, the image texture node. It uses "box" projection, with the blend is set to 1.000. This was a feature added specifically for the purpose of blending the image being projected from all directions (even if that image is the same texture).
The description provided in the blender 2.79 manual is here:
https://docs.blender.org/manual/en/latest/render/cycles/nodes/types/textures/image.html

Projection
Projection to use for mapping the textures.

Box
Maps the image to the six sides of a virtual box, based on the normal, using XY, YZ and XYZ coordinates depending on the side.

Blend
For Box mapping, the amount to blend between sides of the box, to get rid of sharp transitions between the different sides. Blending is useful to map a procedural-like image texture pattern seamlessly on a model. 0.0 gives no blending; higher values give a smoother transition.


Can't edit beziercurve, handles are not visible

As John Eason and Nathan said in the comments: unhiding in selection mode solves the problem.
In case others have the same problem here is how to solve it:
first select your bezier curve, then go to edit mode and press A to select everything. To unhide press Alt + H


The following should work:

Add the empty to your scene and position it in front of the head, then select your head object and apply rotation by pressing CTRL+A and select "rotation" from the list:

Now with your head still selected, go to the constraints panel and add a "Track To" constraint, and in the Target field select the Empty you want the head to follow:

Note: You may have to change the axis in the Track To constraint, depending on which way your head is looking. Judging by your screenshot, I suspect it will be something like -Y


Exporting Vertices from Blender 2.8 to a .txt-File to import it in ArchiCAD as Terrain

blender uses python

if your terrain is meshable here's a snippet to reveal vertices for a mesh.

import bpy

def reveal_vertices(mesh):
    verts=mesh.data.vertices
    for i in range(0,len(verts)):
       print('vert['+str(i)+']: '+str(verts[i].co))

mesh = bpy.context.active_object
reveal_vertices(mesh)

about the storing-vert-coordinates-in-a-text-file part that would just be a
basic python problem but google is always a friend


Why can't I use Loop Cut on certain parts of my mesh?

You can only loop cut through quadrilateral faces in a line, like a row of rectangles. A loop cut through a triangle would divide one of the vertices, but that can't happen. N-gons also don't work well with it. See Anthony Forwood's comment:

  Quads are ideal, tris when necessary, and ngons only when absolutely necessary.

It has nothing to do with the F function.


Contextual Create operator

For the case given, simply finding all the boundary edges and spitting into contextual create operator ngon fills the edge loops

The edges of the returned faces are the original edge loops Use to  fill other than ngon.

import bpy
import bmesh

context = bpy.context
ob = context.object
me = ob.data
bm = bmesh.from_edit_mesh(me)

ret = bmesh.ops.contextual_create(bm,
        geom=[e for e in bm.edges if e.is_boundary])

# the seperate edge loops
edge_loops = [f.edges[:] for f in ret["faces"]]
# if don't like the ngon fill then do something here
# eg remove face
# grid fill edge loops,
# poke face for tri fan.

bmesh.update_edit_mesh(me)

Similarly with the edge loop fill operator

ret = bmesh.ops.edgeloop_fill(bm,
        edges=[e for e in bm.edges if e.is_boundary])


In edit mode RMB the vertex labeled 1 then Shift-RMB the 2nd vertex.

Alt-M (merge) select At last.


Is there a way to restore the cycles render settings to default?

If I understand your question, I don't think there is.

You can load a .blend file without the saved UI, but this doesn't include settings in the render property panel (which is what I think you are getting at). These cannot (as far as I know) be divorced from the other data in the file.

You would probably need to create a new empty file (which should load default settings for everything), and then use File->Append to import the objects from your other .blend file into that new file.


Creating a face on 2 circles of edge while letting the inside of the small circle without face

The only method I found is to remove the central cylinder, make the faces, create a cylinder and add a boulean to remove the center in the end. It is dirty :/


Your joined meshes probably have separate materials that do not share the same image texture and UV map. You will need to make sure that they all have the same UV Map and Image texture so that you can paint across all of the parts despite them possibly having different materials.


Below are three spheres with drivers indicated in the properties panel. Please notice the selected object named RenderMaster.  It is used in the drivers.

Below is a simple driver.  Please use copy driver, paste driver then modify for each object to which it is applied.  Not the most compact or elegant, and it will suffice for only 10 objects.  Please notice which sphere is selected so that the driver makes sense as you note the driver adjustments.  Please notice the numbers getting bigger in the Scripted Expression.  Modify and Improve to suit your tastes.

10 different Scripting Expressions.  These are intended for driver expressions in the image above one for each object.

Please test and verify

not((xloc <= 1) and (xloc > 0))

not((xloc <= 2) and (xloc > 1))

not((xloc <= 3) and (xloc > 2))

not((xloc <= 4) and (xloc > 3))

not((xloc <= 5) and (xloc > 4))

not((xloc <= 6) and (xloc > 5))

not((xloc <= 7) and (xloc > 6))

not((xloc <= 8) and (xloc > 7))

not((xloc <= 9) and (xloc > 8))

not((xloc <= 10) and (xloc > 9))


If I understand correctly, Please try this:

Select your source faces:

Hit E and S (E for extrude and S for scale) and drag mouse inside to scale

You will get some thing like this:

You also lock the scale to y if you like by hitting Y after S
Final command will be E and S and Y

Best of luck :)


The reason you're having the issue is because there's no face there to subdivide.
 Editing in Solid Shading often makes things like this difficult to see.  Faces will always have a little black dot in the center, though.

Go to edge selection, hold Alt and click one of the edges surrounding the void then press F to fill the face.

After that, the knife tool will work as expected.


How to fix non-utf8 names when loading old blend files?

It's possible to get strings in Python as bytes, which allows to re-encode them into utf-8:

Eg:

import bpy
for m in bpy.data.materials:
    name_as_bytes = m.path_resolve("name", False).as_bytes()
    name_as_utf8 = name_as_bytes.decode('utf8', 'surrogateescape')
    m.name = name_as_utf8

To run this on your entire file:

import bpy

def id_iter():
    type_iter = type(bpy.data.objects)

    for attr in dir(bpy.data):
        data_iter = getattr(bpy.data, attr, None)
        if type(data_iter) == type_iter:
            for id_data in data_iter:
                if id_data.library is None:
                    yield id_data

def wash_name(id_data)
    name_as_bytes = id_data.path_resolve("name", False).as_bytes()
    name_as_utf8 = name_as_bytes.decode('utf8', 'surrogateescape')
    id_data.name = name_as_utf8

for id_data in id_iter():
    wash_name(id_data)

Ideally loading old files will always work. In this case it's not done because its a big change for a relatively rare problem.


Automatically "routing" a tube through a confined space

After giving this some thought, I have come up with another approach that might be a solution for you. It does require that the mesh of your space has quad topology, so that edge rings which flow along the tunnel can be selected and scaled in.

Of course, if you don't have control over the initial topology you will have to retopo first. I believe the RetopoFlow add-on would be the fastest way, if you need to do this.

Select and Scale your Edge Rings

So you have your mesh object of your space:

Press ShiftD to make a duplicate of it, and move (M) it to a different layer.

In Edit Mode, with Edge Selection enabled, select only the edge rings. This can be done from the menu: Select > Edge Rings, or with the shortcut ShiftCtrlAltRClick. Do this until every edge ring is selected.

Set your Pivot Point to Individual Origins. This causes each selected edge loop to shrink toward its individual center when you scale them down, creating a path that passes through the center of the mesh.

Scale your edge rings down to zero. (S,0,Enter)

Press W > Remove Doubles to get rid of extra overlapping geometry.

Smooth it Out

In Object Mode, add a SubSurf Modifier to your object to smooth it, if you want it to be smooth. Adjust the subdivision levels as desired.

Apply the SubSurf Modifier.

Convert your Mesh object to a Curve object. (AltC)

Adjust your Curve Settings as Desired

Above: A wireframe display of the original Mesh object, and the new Curve object, with both layers made visible together.

That's it!


Texture view works, but render is without texture

Go to the setting of render layers. You have selected material that overwrites all materials. Remove this material and it will work.


Very simple, press s to engage scaling mode and then press y to choose the y axis, when you move your mouse it will only scale on the y axis. You can do this with x and z also! Make sure with that character, you choose both the back and front or else if you choose one edge only, it will straighten or curve it depending on how you scale it!


How to illuminate the edges of an object in the bge

There is no build-in option that provides you an outline effect.

But there are other options. E.g. via GLSL shaders.

Additionally you can create an similar outline by

duplicating the mesh,
scaling it up a little,
assigning it green shadeless color

(This will not result in a one pixel outline.)


Help with modeling a turret's arm from Portal 2

This task is quite simple.

Add the torus.
Go to edit mode and cut the half of it (actually more than a half) in "face mode".
Flatten this figure a bit.
Use a preset viewpoint (any dot of navigation "cube" that lets you to see the figure at a whole).
Enable "Snap - Increment", choose tick strict snap to grid, and snap the figure to grid. Add three separate dots (left/right mouse button + Click). Snap them to grid too!

Select all (A button) and use Bisect. Connect dots to slice the figure.
Select  everything that you don't need and delete. Disable snap.

"Extrude along normals" this figure.

Voila! Then you can add other inner parts that are simpler.


Change the brush of a grease pencil object

It's possible but you don't have much control. Here is how you can do it.
First Select your grease pencil object and go into draw mode and select the brush type you want it to be redrawn with. Then go into object mode and select your grease pencil object and right click and select convert to bezier curve from the context menu. Select the generated bezier curve usually named Lines. then right click and select convert to grease pencil object.


How can you make a hole in a wall with archimesh?

You can do this in the same way as Archimesh does with the "Auto Hole" button, with a Boolean modifier.
Add a cube to the scene. This will be the hole, resize it as needed. Then add a Boolean modifier to the wall object and use the cube as object value. Leave operation setting at Difference, it's the default value. Last but not least, you just need to hide the cube in viewport ("eye" icon in the outliner) and for render ("camera" icon).
The camera icon is not shown be default. In Blender 2.9x, an easy way to hide the cube is to move it a collection and close the collection. (Upcoming Blender 2.93 will show the render icon by default. In older versions you need to activate it in the filter settings of the outliner. It's a so called Restriction Toggle.)


Why do I get a hard edge when mixing a Transparent and Glossy node with a Fresnel node?

You can change the alpha blend mode, currently you are in Alpha Clip which rounds the alpha value to 0 for values < 0.5 and to 1 for values > 0.5.

Make sure your render engine is set to Eevee first :

Alpha Clip :

Alpha Blend :

If you want to tweak it further, add a Color ramp between the Fresnel and the mix shader, set to B spline interpolation, and move the white cursor way to the left :

Note you can get the same setup with a principled BSDF, which will be more physically correct :


Align UV map island with axis or other island

Change the snapping from increment to vertex

Select an island with L
Choose one of the vertices on the island and match it to the corresponding one on the other island

If they are not aligned due to rotation, continue with these steps

Select the vertex that matches the island you are aligning to.
Use Shift-S to snap the cursor to the selected vertex
Select the one island with L
Use . to set the pivot point to be the cursor
Rotate the island until R and snap a vertex that isn't lined up with the cursor to the similar one on the other mesh.

If the scale doesn't match proceed further these steps

With the pivot point still at the cursor at the matching vertex, hit S to scale until it snaps into place

If the map is distorted, or something above didn't work right, do these procedures instead of the above steps

Snap each vertex individually to the corresponding vertex using G.

Note: if the snapping doesn't work, try holding down Ctrl


Your LowerLeg.R IK Pole Angle is bad, it should be 0:

Also, move the knees a bit forwards so that Blender knows in what direction they are supposed to bend:

When you'll have done that you'll need to redo the poses.


The blender game engine has a special function for jumping: first, make sure the Physics Type for your character is set to "Character". Then, in the Motion actuator, set Motion Type to "Character Motion", leave all the numbers at zero and set the "Jump" button. As the tooltip says, the settings for that are in the Properties panel, Physics tab (right underneath the Physics Type).

If you can't use the Character type for whatever reason, another way to make it work (the old way) is to add a collision sensor that references the ground, then "and" that with your keyboard sensor.

FYI: this seems to be a duplicate of How to create a realistic jump in bge, but since I don't have enough rep to flag it as such, I answered instead.


Blender Texturing Problem, cant figure it out

You need a texture coordinate node and a mapping node.

It might be wise to use a Principled BDSF also.

I couldn't check if it was correct because the images were not packed into the blend file but this was the first thing I saw.

Also in your Diffuse Shader, there is a normal input where your normal map goes if you still prefer to use a Diffuse Colour node.
Purple coloured slots use vector information.
Gray coloured slots are for black and white images/info. So the displacement slot on the material output is only really good for grayscale Displacement maps.

Let me know if that works for you now :)


I inadvertently created 2 view layers. So it was not "again, and again", but only 2 repeats. I have deleted the layers, which solved the problem.


So, I read this question and try it myself, after lot of trials and errors, I found the settings that I think get close to the video are:

Curve type: 2D, give it extrude value of 0.01m
Remesh modifier with Sharp mode, Octree Depth: 5, Scale: 0.6, and Sharpness: 0.1
Shrinkwrap modifier with Offset of 0.01m
This one is optional, but I think this is what they do in the video: check Wireframe in Object properties > Viewport Display.


I had an object selected, by I guess the program didn't download properly the first, third, or fifth time - by sixth reinstall, physics options returned.

Thanks everyone!


Class already registered as subclass (module structure for addon)

You can replace all calls to bpy.utils.register_class(...) by a single call to

bpy.utils.register_module(__name__)

and all calls to bpy.utils.unregister_class(...) by a single

bpy.utils.unregister_module(__name__)

You won't have to (un-)register single classes ever again and your error should no longer occur. Do it in __init__.py only and import all module files from here (from . import ...).

Note that the order of class definitions may matter, e.g. if you use a custom property group class in an operator (the code of the property group class needs to be above the class definition of the operator).

Example addon to show the file structure and imports: blender-addon.zip


How to hook up Blender Python script with Arduino?

You cannot 'hook Blender up with the Arduino online editor', however you can have a program running on the Arduino that would communicate with a Python script running in Blender over serial connection(USB). Have a look at pyserial. You might probably be interested in application handlers in Blender as well.


There aren't any materials assigned to the objects; thus no textures will be rendered. You can preview textures in 3D Viewport because in Blender Internal it isn't required to have material in order to preview texture on the model; it is enough to select faces in Edit mode and open desired image in UV/Image Editor (no need even to unwrap it and assign texture to UV map):

You still have possibility to render these textures by enabling Face Textures in properties, however you will need to create material for that:

Do keep in mind that this is not a good practice and should be avoided; create textures, assigned to the material and link them to images instead.


How to show the names of each bone on an armature?

With your armature selected you can go to the 'Armature' tab of the properties area and you can enable the 'Names' property in the 'Display' section:


Won't render animation after having already rendered a version

You have added an image file to the VSE (Video Sequence Editor) and as you have not added your scene to the VSE, all Blender tries to do is output that one file for each frame.

You can either delete the Image strip from the VSE or disable the Sequencer under Post Processing in the Render settings.


How to move an object to a different render layer?

With M, i.e. move them between viewport layers:

See my answer here for more detail.

Thanks to this question, I found and reported a regression in blender's handling of view specific and scene specific layers.


Animation Nodes move certain mesh vertices

the "Object Mesh Data" Node has a hidden input called "Vertex Normals". Press n to open the properties panel in the node editor and activate the output by clicking on the little eye icon.

you can then use a vector math node to scale the vertices along their normals. shuffle the vertex list and remove all but the first vertices.

That's it.

Parameters to control the output:

Scaling factor of the first vector math node: there you can control how far away each point is from the base mesh
Node Seed of the shuffle list node: shuffles the list in another order, other vertices get deleted from the end of the vertex list
end of the slice list node: controls the amount of vertices that don't get deleted

Bonus
node setup with splines (like in your reference image):

Let me know if you need anything else or a deeper explanation


This is a scaling artifact that happens when Y-stretch is enabled. The bone scales get applied additively down the chain, because the bones are parented to each other, resulting in an odd shape.

What you need to do is: Copy the SplineIK bone chain, delete the SplineIK constraint in this new chain and unparent all the bones from each other. Than add copy transform constraints to every bone in the chain, targeting the matching bone in the SplineIKchain. Make this new chain deform the mesh, disable deform for all the bones in the original splineIK bone chain and enable only deform bones in export.


I managed to get it working by overriding the context. So if anyone is interested, here it is:
for area in bpy.context.window.screen.areas:
        if area.type == 'VIEW_3D':
            for region in area.regions:
                if region.type == 'WINDOW':
                    override = bpy.context.copy()
                    override['area'] = area
                    override['region'] = region
                    override['scene'] = bpy.context.scene
                    bpy.ops.screen.screen_full_area(override, use_hide_panels=True)

for area in bpy.context.window.screen.areas:
        if area.type == 'VIEW_3D':
            for region in area.regions:
                if region.type == 'WINDOW':
                    override = bpy.context.copy()
                    override['area'] = area
                    override['region'] = region
                    override['scene'] = bpy.context.scene
                    bpy.ops.wm.setup_ui(override)

class MYOPERATOR_OT_setup_ui(bpy.types.Operator):
    bl_idname = "wm.setup_ui"
    bl_label = "Setup UI"

    def execute(self, context):
        context.space_data.show_region_ui = True # Opens sidebar in 3d viewport
        context.space_data.region_3d.view_perspective = 'ORTHO' # 'PERSP', 'CAMERA'. Set 3d viewport to othorgonal

        return {'FINISHED'}

The operator needs to be registred of cause.


There are several solutions, if you only want to show the picture on the top face you can simply give a material to the top face and another one to the other faces... if you want to keep the same material on all the faces, for example because you want to use the same red background, just scale down the UV of these faces in the UV Editor so that you only have red


To remove particles select the particle system by clicking on one of its particles then enter particle edit mode by pressing Tab. In particle edit mode select the unwanted particles and press X to delete them.


From the Blender Manual
on taper objects.

The taper curve is evaluated along the local X axis, using the local Y axis for width control. Note also that: Tapering a curve
causes it to get thinner towards one end. You can also alter the
proportions of the Taper throughout the tapered object by
moving/scaling/rotating the control points of the Taper Object. The
Taper Object can only be another curve. Editing the handles and
control points of the Taper Object will cause the original Object to
change shape.
In order for this to work:

It must be an open curve.

The taper is applied independently to all curves of the extruded object.

Only the first curve in a Taper Object is evaluated, even if you have several separated segments.

The scaling starts at the first control point on the left and moves along the curve to the last control point on the right.

Negative scaling, (e.g. negative local Y on the taper curve) is possible as well. However, rendering artifacts may appear.

Might need to increase the curve resolution to see more detail of the taper.

With closed curves, the taper curve in Taper Object acts along the whole curve (perimeter of the object), not just the length of the
object, and varies the extrusion depth. In these cases, you want the
relative height of the Taper Object Taper curve at both ends to be the
same, so that the cyclic point (the place where the endpoint of the
curve connects to the beginning) is a smooth transition.

In the example below, Suzanne has had a simple hair system converted to curves, then a bezier curve is used as a taper object.

The geometry settings for the converted hair are below:

The hair curve also has a subdivision surface modifier to further smooth the shape after conversion.
The hair system itself is nothing special, all default settings except that the count is changed to be much less than the default 1000 (only 36)and for suzanne is using a density vertex group for emission. Also, in order to prevent the hair from detaching from the emitter due to the forces after being converted, I used emit from volume rather than faces, or vertices.
The shape of the hair is created with two forces, turbulence and vortex
In short, as long as the curve is along the correct axis, as shown in the example you should have no problem reproducing in your own project. Once satisfied with the final shape of the curves, you may convert them to mesh via Object ‣ Convert To ‣ Mesh
I have also included a finished sample file demonstrating the taper on suzanne, hopefully it will get you in the right direction.


Set a white background color for rendering

Yes and yes.

If you change your viewport shading to Render Preview:

Or change the Viewport Shading to show the Scene World, you will see the rendered result of your background selection.


Is it possible to display and image inside the add-on about?

You can show custom icons, see: How to implement custom icons for my script/addon?

However you can't show large images in this space.


Ideal camera settings to approximate human eye?

The default in Blender assumes 1 Blender unit = 1 meter, so you're actually on the right track there.

As for the question regarding a match on the human eye, that's a tough one. Not just because of the monocular/binocular thing, but also because your retina is curved and most cameras and digital approximations assume a flat sensor.

That said, I've done a bit of my own research on this (reading advice from photographers is interesting... not always accurate, but interesting :) recently and landed on the following settings that seem to work reasonably well:

Camera Sensor - 35mm
Camera Focal Length - 45mm

Clipping distances, you'll need to adjust to taste.


my guess is: bad topology of the cloth object...

here's your mesh topology:

And topology is all about good deformations...

I did a quick test of a "square" cloth object (not particularly good topology, but way better than your object...), just to check and, with default cloth / collision settings... is subdived and then also subssurfed...

animation starts like this:

and after 136 frames:

here is my test .blend

update:

here is a simpler test with higher "structural" setting...


Have two lamps blend together to give another color on a face

You more than likely have the default point lamps at the exact middle of these faces, therefore they won't reach the top. Raise it above the top of the cube so they can illumiate the top face. The lamps will blend naturally and give you the third color.


I figured out a way to do it (Not sure if it's the best way).

Having all of the faces of the part selected,

but making sure the snap tool is set to vertex snap mode (NOT face snap):

and pressing G and moving the part to the appropriate position, will work: