Make a Blender script run an external program

The way i think to do so, (if you want it to be dynamic) is by doing a socket connection. (But i dont know After Effects). Here you have an example using the fancy async way.
* you'll have to run this somehow from After Effecs [that's what im not sure you'll be able to do]. The idea is to make a server and a client to send data between your programs, blender & A.E. in the case.

import asyncio

async def tcp_echo_client(message, loop):

    reader, writer = await asyncio.open_connection('127.0.0.1', 8888,
                                               loop=loop)

    print('Send: %r' % message)
    writer.write(message.encode())

    data = await reader.read(100)
    print('Received: %r' % data.decode())

    print('Close the socket')
    writer.close()

message = 'Hello World!'

loop = asyncio.get_event_loop()

loop.run_until_complete(tcp_echo_client(message, loop))

loop.close()

this is going to be the server, you have to run it from AE i guess.
then you have to configure your client from Blender side with this other script

import asyncio

async def _send(message, loop):

        reader, writer = await asyncio.open_connection('127.0.0.1', 8888,
                                                   loop=loop)

        print('Send: %r' % message)
        writer.write(message.encode())

        data = await reader.read(100)
        print('Received: %r' % data.decode())

        print('Close the socket')
        writer.close()

def send(data):

        loop = asyncio.get_event_loop()
        loop.run_until_complete(_send(data, loop))

data = "hello world"

send(data)

"""
i dont know if you need all the code or it is redundant, i edited an example from asyncIO site and worked for me. good luck"""


Animation Nodes - Is it possible to add a texture image to a "target" Mesh Object Output node in Animation Nodes?

Thanks goes to OmarEmaraDev
In the Mesh Object Input node, there is a hidden input called Load UVs, enabling it should transfer the UV map and the texture should appear as you might expect.


Rendered image does not show transparency or lighting

For transparency make sure you have "Transparent" checked on:

And for the shadows - it seems you don't have a light source next to the cube, if there's no light there can be no shadows, add a light by pressing SHIFT + A and clicking on light, I'd recommend getting a sun so everything is lit and you can check if there are shadows.


Cannot pickup an object twice (Use child of a second time)

After looking over the file i saw that you used one "Child Of" constraint, animated it with 0 influence until one frame before the time it needs to be activated, then activated it with 1 influence to pick it up and later used the reverse, keyed 1 influence and one frame later the 0 influence to drop the "Child Of", so it could be picked up later again.

All that was working fine, a few too many keyframes were used before the actual action, as you only need to use two keys for activating and deactivating. If not needed, i would suggest to remove unneeded keys though.
Those two times would have been enough, but that did not cause the problem.

What is important though, is that you can not use the same "Child Of" Constraint for a second time without it keeping the relative position after it was used once. (all my tests either caused the later or previous positions relative to the parent to be messed up. Sure you can use the Set Inverse or Clear Inverse buttons, but they pretty much do mess up any previous usage or an already keyed later usage.

Solution:
Use one "Child Of" constraint per pick up -> manipulating -> drop phase.

Here a little visual helper:

I extended the animation a bit, to showcase a second pickup.

Also here the file to examine, as it may help to understand looking at the details:

While i believe it is better to know how it works, i do not want to withhold the fact that there is an addon called Dynamic Parent, that kinda makes it easier to attach items to different parents. Beware though that if you use it, it can become very fast messy with many "Child Of" constraints. So understanding what happens first helps a lot.

Happy Blending


In VSE, is it possible to have keyframes adapt to clip length? (relative position)

Park the play head at the end of the strip. Open the dope sheet view and select the last keyframe, then press the Shift-S key, select Snap type "Current frame".

To move all keyframes by the same amount, select all keyframes then press G key and type the offset value in frames and press enter.


How to create and bake animations in Blender (when you already have created the Rig Skeleton)

To answer your answer , when creating animations i personally do prefer to go to frame 0 press A in view to select all bones and press I & select PosLocScale to get the starting pose and do the same on the last frame of the animation , then i just skip to certain frame and edit bones i need to , before jumping to another frame i select the bones i have edited and press I => Set LocPosScale or u can press A and set it.


LoopTools addon curve option bug? Not working

Thanks to @moonboots for pointing the problem out, for some reason, it only works if you have a symmetrical topolgy, i.e you need to have edges on both axis. Below image is an example of topology on which this feature works :


Texture Painting vs. Materials Assigned to Vertices

In short, texture painting and materials serve different purposes, it's not really an either-or situation.

Basically, texture painting is creating a texture, not a material; materials are different than textures.  A material tells the render engine how the object interacts with light, a texture is simply a set of colors.  Textures are very useful for creating materials, textures can be used to determine the color of an object, be used as a mask, etc.  But in order to have a render you have to have a material, textures are just a part of a material and texture painting is just one way of creating a texture.
To paint a texture onto an object using texture painting the object must be unwrapped.  Then as you paint the texture on the object in the 3D viewport, Blender paints on a 2D image in the UV/Image Editor.  This texture can then be saved as a .png (or other picture format) and used in a material to affect the rendering.
To assign a material to individual faces, select the faces in edit mode and hit the assign button in the material editor (with the proper material selected of course).  This will assign that material to those faces.  You can have the same material applied to many different objects, whereas (unless they share the same UVs) a texture painted on one object almost always won't look right at all on another.


Why is this glass Cycles material casting solid shadows?

You did have Transparent Shadows disabled in the Material Settings.  Once enabled, you can use the Light Path Node's Is Shadow Ray to Select between the Glass and Transparency shaders to achieve this effect.


Creating a twisting cable with multiple parts

Curves are certainly versatile, but for some cables you might try other techniques. An alternative involves rotating an array of cylinders around and empty...

...and adding a simple deform

Update: If you modeled the smallest cables and then joined Ctrl Jthem to the outer tubing, you could array them together. You could color the small cables first, but you probably have to 'Apply Array' to color the few outer cables. Most of the other thicker tubing seems easy to model, the only except being the blue ribbon for which curves might be appropriate.


A restricted view I can't turn off in Solid & Wireframe preview

It looks like you've enabled a Clipping Region. Select it again from the menu or use shortcut ALT + B to clear it:


How can I draw a circle in an image inside the image editor?

Try this (I'm on Blender 2.81a):

import bpy
import math

size = 640, 480

# Calculate distance between two point
def distance(p0, p1):
    return math.sqrt((p0[0] - p1[0])**2 + (p0[1] - p1[1])**2)

# blank image
image = bpy.data.images.new("circle_img", width=size[0], height=size[1])

pixels = [None] * size[0] * size[1]
center = (int(size[0]/2.0), int(size[1]/2.0)) # center of image
radius = 50 # radius of circle in pixels
for x in range(size[0]):
    for y in range(size[1]):
        d = distance((x,y),center)
        if d < radius:
            r = g = b = a = 1.0 # white
        else:
            r = g = b = 0.0 # black
            a = 1.0
        pixels[(y * size[0]) + x] = [r, g, b, a]

# flatten list
pixels = [chan for px in pixels for chan in px]

# assign pixels
image.pixels = pixels

# write image
image.filepath_raw = "/tmp/temp.png"
image.file_format = 'PNG'
image.save()

Circle isn't very pretty though (could use some anti-alias or blur)!


How can I blend different textures on a landscape?

From what I read, i think your asking about how you can have 2 image textures and just smack them onto the same plane/object for landscaping scenes. Now this is some what my specialty and passion as it is what i do nearly everyday. So for example i will use Grass and dirt(soil) to explain. In the real world, grass needs dirt to survive. So in order to have an effective scene which captures the audience you need to have a base plain with 1 texture, (Dirt) and use a particle system to apply the grass patches where you want. To add more effect instead of using a normal map, use a displacement map to show small details like rocks and particles. And apply your grass. It will give you a great effect with lots of control and will also open up opportunities for animation of the grass when wind interferes with it. I hope this helps you with an understanding that some things shouldnt be just textures and that they need their own objects.

https://www.youtube.com/watch?v=eshOzshjt90
Here is a tutorial of what I mean.


Edit: Unchecked the Mask option and it got normal


Quality loss when rendering in H.264 or even AVI RAW

Assuming you didn't miss anything obvious (wrong resolution) I would recommend to render it out with a really high bitrate (24300k) and then use handbrake to compress it in a useful manner. The default bitrate of 6k is just way to low.

Also there may be a blur node hiding in your setup. Looking closely at the ladder on top of the mast it seems like everything is spread out by one pixel.(left original, right encoded)


How to copy extrude/bevel data across multiple curve objects?

I want to thank @Carlo for this handy tip.

This can be used in many different areas of Blender (I will post more scenarios when I have time).

Shift Select all the objects you want to change.
With the last object selected make sure you hold down ALT and change the properties. This should affect all the objects you had selected.


Shift-Ctrl-Alt-C>origin to geometry. You can also use the 3D cursor as a pivot point, by hitting . on your keyboard.


You could try it this way:

Put your picture as a Background image.

Create a plane, rotate it on the X axis to have it in front view, apply the rotation.
In Front Ortho view, use the picture as a model to build your mesh, mirror the mesh to make it easier.

Switch to Right Ortho view and continue to model the mesh. You'll have to shift the mesh from its origin.

Come back to Object mode. Create an empty at the same point as the object origin.

Give your object an Array modifier, give it a Count of 8, deactivate Relative Offset, activate Object Offset, choose the empty as object.

Rotate the empty 45° on the Z axis.

In Edit mode, give some corrections to make the vertices stick approximately with their arrayed copies.

Duplicate the empty + object to keep a copy somewhere on another layer.
Apply the modifiers.
Go in Edit mode, remove doubles.

Dissolve the useless vertical edges.

Make some corrections.

Now you have your basic bowl. Of course you'll probably want it to be a bit more sophisticated, like adding some bevels, etc... in that case you can keep just 1/8 of the bowl and again spin it around the empy with an array, add your bevels on the original mesh, keep only quads, etc...


Not sure how your looks so I dont know if mine is more what you are looking for, but this is how I would set it up.

Use the principled shader with transmission all the way up (for glass).

I used a mix RGB with a noise factor to break up the color a little bit.

I used an emission shader for the volume with a noise texture (to get those light color swirls). I tried using a volume scatter/absorbtion but I wasn't liking the look it gave me plus the render times shot way up (so the emission shader worked for me).

Then I just added a particle system for the bubbles, and I threw in some Ice Cubes.


Ok, I figured it out. Download Autodesk FBX Converter (free). Run the converter. Add FBX Converter. Select Add. Now first select the FBX to be converted, then control select the Texture Directory. You have to do it in the order. Then on the right side, check Embed media. Then convert. You will have your FBX with embedded textures! Amazing how easy.


Increase or decrease vertices in circle after working with it?

For the creation of a primitive

Yes, and no
You can change the settings right after creating any of the primitives, by pressing f6.
After you do anything else, (besides moving around the view) the settings are gone with no way to get back to them.

Editing loop count in a circle

To reduce the number of edges.
In edit mode, select every other loop by Alt RMB  (use shift to add to the selection). Then press X or delete and choose Edge Loop. Do the same for the edges on the other axis.

To increase the number of edges.
Delete the bottom and top vertex (where all the loops meet). Select everything with A, then press W and choose Subdivide Smooth. The loops will get wavy, to fix that select them with Alt RMB  then press S Z 0. Which will flatten them along the Z axis.

To fix the holes in the top of the circle, select the top edge loop, and extrude it along the Z axis. Then scale to 0, and remove doubles. Do the same for the bottom of the circle.


Make an auger, (see below) and scale to suit.

Delete the sections you don't want.

Extrude it's ends to provide entry/exit platforms.

Extrude all vertices down in the Z axis for thickness if necessary.

(the cylinder at center is optional)

Auger Blade -
-========-

Add a Curve path, leave it a, straight line.

Add the "Screw" modifier.  The bezier will turn into a solid disc.

Increase the "Screw" slider to watch the  Auger forming up.

Increase the "steps" to improve the circumference curvature.

Use ATL-C in Object mode to convert it to mesh.


How to make a walking animation for a character in the BGE on a uneven or steep floor?

Ok,

you can change the angle of the step, easy enough with a ray, and parenting the animation
handles to a empty that animate the feet, just use track to another empty on the empty the feet animation handles are parented to, and place the empty via a ray. (so the player will walk up and down hills and change stride angle)

The hardest way (and best way) is this

http://www.youtube.com/watch?v=ZtzQAluEgts

This is a walking ragdoll, that uses the step offset angle code, along with the fact that it really walks.....

http://blenderartists.org/forum/showthread.php?353549-Non-PID-Ragdoll-based-on-Jackii-s-work-made-for-quot-Wrectified-quot

here is the 'base' of that rig.


You have to disable the alpha channel for the normal maps by unchecking the "Use Alpha" boxes.


With some help on twitter, this code is working now.

import bpy

bpy.ops.wm.append(
    filepath="cube.blend",
    directory="/home/lucas/Desktop/cube.blend\\Object\\",
    filename="Cube")

Basically,

filepath= .blend file name

directory= directory of your file and the last part is the folder inside the blend file.

filename= Is the object, material, collection or whatever you want to append.


In your Mapping node, it looks like Texture increases the size of your image texture, instead of reducing it, so decrease it or use Point. Also, if you've unwrapped your object, use Texture Coordinate > UV output instead of Generated.


How can I batch render lots of objects individually?

I've written a very basic AddOn, that does basically what you need.

How to use the AddOn:
The AddOn let's you select your files, puts them one after another in your current scene, and renders them to an outpu-directory.
The AddOn adds a button to the Output-Properties-panel.
By clicking it, you open a file-browser-window.

Select all your files you intend to render and press "Select Files to Render".

Blender then renders all of your selected objects into an "output"-folder, that is created in the same location, that your current .blend-file is located in. The rendered images will be given the objects filename (without the extension). For example "suzanne.obj" may be rendered and saved to "suzanne.png".
All other rendersettings are taken from Blender directly.
Besides the .stl-format, .obj, .fbx and .blend files are supported.
Disclaimer: Since I don't have that much experience in writing AddOns, I can't guarantee you, that it works flawlessly. As far as I've seen, it works for me.
Code-quality is probably a mess and the AddOn lacks some pleasant UX features as,  for example, render-progress. (Blender is not responsive during the rendering!)

How it works / Code-snippets used
This is a more detailed description of what I did, in case you want to create your own script out of it.
An ImportHelper is used to fetch the different files.
I then iterate over each file,
for file in files:
    filename, extension = os.path.splitext(file.name)
    filepath = os.path.join(directory, file.name)

create a temporary collection for each object,
collection = bpy.data.collections.new("tmp-collection")
scene = context.scene
scene.collection.children.link(collection)

and import the object into this collection.
bpy.ops.import_mesh.stl(filepath)

for obj in bpy.context.selected_objects:
    collection.objects.link(obj)
    bpy.context.scene.collection.objects.unlink(obj)

I then render the scene to the output-folder
scene.render.filepath = "//output/"+filename
bpy.ops.render.render(write_still=True)

and delete the temporary-collection with its containing objects.
for c in scene.collection.children:
    if c.name == "tmp-collection":
        scene.collection.children.unlink(c)

for c in bpy.data.collections:
    if not c.users:
        bpy.data.collections.remove(c)


Booleans are meant for volumes, not for flat objects. They generally do not work well with any overlapping geometry and as you see produce unexpected results. You should not use booleans in this situation, but join the planes some other way.

One way would be to use Knife Project to cut geometry from first to second and then from second to first, join them and merge vertices by distance to remove double geometry(vetrices and the extra face):


Please correct me if I am wrong but, it looks like you have 2 objects and only have one of them selected. One being the doughnut, the second being the icing. In order to bake them you must first Join the 2 meshes together, making one object. Do this by selecting both objects in Object Mode. Shift + Right Mouse Button (provided you use default controls). Then with the mouse in the 3D viewport tap the spacebar to access the search function and type "Join". Select the first option. Both meshes are now one object. Then unwrap them. Once that is done, then you can bake the entire doughnut.


Try do a low sample render just to double check? The Viewport preview render is a good indication but not foolproof.


How do I apply a simple armature that I made to a model?

In object mode right click the model than right click the armature with Shift after selecting both the model and the armature set the parent by Ctrl-p and choose the option with automatic weights.

object mode

Finally you can change the armature in pose mode and the model will deform.

object mode

To change the weights (how much a region of the model is influenced by the position of a particular bone) you can enter the weight paint mode and use the brushes to assign different weights.

For rigging a human character you should learn about Rigify which must be enabled in the user preferences / addons section.

weight paint  mode


Rescaling/transform affects 2 objects instead of just the one selected?

Sounds like you added you new object in Edit mode. Press tab to toggle between edit mode and object mode.

If in fact you have one object, then in edit press P then choose loose parts. That will split the object in to multiple pieces.


As @batFINGER mentioned in his comment - the cube on layer 2 is black because there's no light source on that layer. Solved.


How can I model a spherical tesselation such as this one in blender?

Create a cube, in edit mode hit W and subdivide it 4 times. Select the center loops of the main faces:

Then, invert the selection, with Ctrl+I and delete those faces:

After that, select only the faces that are connecting the loops, turn on Proportional Editing, with O, change the pivot point to Individual Origins and set the Transformation Orientation to Normal; hit R, to rotate, then Z twice to limit rotation along the normal, and input 45 as the rotation angle and adjust falloff with the middle mouse wheel; hit Enter when finished.

Select all the faces, hit Shift+Alt+S and enter 1 to make the shape spherical.

Final result with creased edges, then solidify modifier and subdivision surface:


Liquid simulation looks weird. Strange patterns

You should have diffusion turned on with those setting for water, if you have higher base your symulation will look more like honey or katchup, or like jelly in your case. Also material should have 0 roughness and 100% transition, and IOR set to 1.(33)

sett up: https://gyazo.com/aef5a4bec7dbd5baf17834b559ea81da


Both of your lights are very close to the ground. Try moving them up a bit, especially the point light.
You should also add a light on the other side of your object shining on the shadows. This light should be much softer and would soften up the shadows so they don't look so harsh.
There are lots of tutorials to help you with lighting out there. It might seem simple, but good lighting is much more complicated than you would imagine.


Your view is showing $Y$ and $Z$ axis (Green and Blue lines across the screen respectively), but the modifier is set to mirror only on $X$, which would be perpendicular to this view, therefore impossible to see.
You can add mirror in $Y$ on the modifier.

It helps if you use a different view, that clearly shows the axis you  want to work on (like top view)


Instead of creating triangles and trying to fix them later, keep your topology using quads all the time.

It is a common misconception that the topology of an object comes at the end of the process. The topology of the object should always be worked out from the beginning.

A simplified way to do a speaker:

Start with a cube, scale it on the $Z$ axis, and make a loop cut in the middle.

Position the cut to divide the two main sections of the speaker.

Create some vertical loop cuts And subdivide each of the sections with an equal amount of cuts.

select the edges that will become the round part and press ⇧ Shift+⎇ Alt+S (to sphere) and move the mouse to create a circular shape.

Do the same for the top part.

Select the central faces to extrude.

If you select the loop ring in the front you should be able to bevel the holes.


You could try giving it a material like this:

The first thing I did was warp the object vector using a Noise Texture to help give the rest a bit more of a "swirly/smoky" look. Next, I used this as the input vector for another Noise Texture (to make it extra distorted) and ran the result through a colored ColorRamp.

For the "energy bolts", I used the same warped vector as the input for a Voronoi Texture set to Distance To Edge. I inverted the result and clamped it with a ColorRamp to make the "Lightning" stand out I then mixed this with the colors using a MixRGB node set to lighten to have good control over how much lightning is added (too bright looks fake):

If you want to soften the effect overall (looks even less fake), you can mix the final result with fitting, solid color. Finally, I suggest running the result through an Emission Shader with the strength turned up a bit. Don't forget to enable Bloom to make it glow:


Can someone tell me where I've gone wrong?

Some walls are "disappearing" during joining meshes because you have set Backface Culling in 3D view shading options. This makes faces, which normals are not directed towards viewer, not visible. What you need to do is, after joining meshes, Tab into edit mode, choose Face select, select "invisible" faces (you will be able to see black dots in the middle of each, even "invisible" face), Click on Flip Direction in left Shading panel or go to Mesh>Faces>Flip normals or press CTRL+F and choose Flip normals.


How to stop the timer when the ESC key is pressed

You will have to unregister your timer function in the cancel method.

To do so I had to bring printFunction out of the operator class, because otherwise it needs self argument, and I haven't found how to bring it with the function to the timer register operator. So now the idea is to set returnValue not as class's instance's variable (using self.returnValue), but as class's variable (using bpy.types.YOUR_OPERATOR_CLASS instead of self) - in execute, cancel, printFunction and any other method or function.

import bpy

bl_info = {
    "name": "TestPanel",
    "author": "taichi",
    "version": (1, 0),
    "blender": (2, 80, 0),
    "location": "3DView",
    "description": "test",
    "warning": "",
    "support": "COMMUNITY",
    "wiki_url": "",
    "tracker_url": "",
    "category": "Print"
}

class TEST_PT_Panel(bpy.types.Panel):
    blidname = "TEST_PT_Panel"
    bl_label = "Test Panel"
    bl_category = "test"
    bl_space_type = "VIEW_3D"
    bl_region_type = "UI"

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

        row = layout.row()
        row.operator('wm.modal_test_operator',text ='TestButton')

def printFunction():
    print("test")
    return bpy.types.WM_OT_modal_test_operator.returnValue

class Test_OT_Operator(bpy.types.Operator):
    bl_idname = "wm.modal_test_operator"
    bl_label = "Modal test Operator"
    _timer = None
    returnValue = 0.1

    def modal(self, context, event):
        if event.type in {'ESC'}:
            self.cancel(context)
            return{'CANCELLED'}
        return{'PASS_THROUGH'}

    def execute(self, context):
        bpy.types.WM_OT_modal_test_operator.returnValue = 0.1
        wm = context.window_manager
        bpy.app.timers.register(printFunction)
        wm.modal_handler_add(self)

        return {'RUNNING_MODAL'}

    def cancel(self, context):
        bpy.app.timers.unregister(printFunction)
        bpy.types.WM_OT_modal_test_operator.returnValue = 0

classes = (TEST_PT_Panel,Test_OT_Operator)
register,unregister = bpy.utils.register_classes_factory(classes)

if __name__ == "__main__":
    register()

Note that once the variable is changed as class variable it keeps its last meaning even after operator is over. You can for example reset it as class variable in cancel method. You can also add for example set_time: FloatProperty(name="Set Time", default=0.1) to your Operator class and in the execute method set bpy.types.WM_OT_modal_test_operator.returnValue = self.set_time - so you could change it at the begining of every launch of your operator, like this: bpy.ops.wm.modal_test_operator(set_time=0.5) and also to use this property in ui panel.

UPDATE:
Found much easier solution with less changes to your code. Set your printFunction to self._timer variable and register and unregister self._timer

import bpy

class TEST_PT_Panel(bpy.types.Panel):
    blidname = "TEST_PT_Panel"
    bl_label = "Test Panel"
    bl_category = "test"
    bl_space_type = "VIEW_3D"
    bl_region_type = "UI"

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

        row = layout.row()
        row.operator('wm.modal_test_operator',text ='TestButton')

class Test_OT_Operator(bpy.types.Operator):
    bl_idname = "wm.modal_test_operator"
    bl_label = "Modal test Operator"
    _timer = None
    returnValue = 0.1

    def modal(self, context, event):
        if event.type in {'ESC'}:
            self.cancel(context)
            return{'CANCELLED'}
        return{'PASS_THROUGH'}

    def execute(self, context):
        def printFunction():
            print("test")
            return self.returnValue
        self._timer = printFunction
        wm = context.window_manager
        bpy.app.timers.register(self._timer)
        wm.modal_handler_add(self)

        return {'RUNNING_MODAL'}

    def cancel(self, context):
        bpy.app.timers.unregister(self._timer)
        self.returnValue = 0

classes = (TEST_PT_Panel,Test_OT_Operator)
register,unregister = bpy.utils.register_classes_factory(classes)

if __name__ == "__main__":
    register()


FS Distance from Camera settings to maintain constant line thickness

Short Answer: Not really possible right now.

Long Answer: There may be a workround.

First, Let's see what Range Min, Range Max, Value Min and Value Max mean:

As you can see, Range Min and Range Max actually indicate the distance between camera object and the nearest/fartherest point on the mesh bound. The Fill Range by Selection button can calculate those two values based on selected object. Value Min and Value Max are both thickness values in pixel.

However, these four parameters won't dynamically change with the relative distance between camera and extreme points on object. You have to drive them with that distance value:

Before (no driver):  After (with drivers):

NOTE: The method above can be very limited because the distances to nearest and fartherest point can be different, which makes the expression less accurate. Anyway, assuming this is what you are going to make.


Actually it also shows the smoke but it's hidden by your emitter. As explained here, "you can actually just turn off render visibility on the emitter. It’s the domain object that actually renders. " So disable the emitter's visibility.


Children particles not reading "Lifetime" cyclesnode output

This is a known limitation.

I don't see any mention of it on the todo list, but blender's particle system is scheduled for a complete rewrite for 2.8, perhaps it will be fixed then.


a simple cross product solves your problem:

\begin{equation}
\hat{z}: the \space unit \space vector \space along \space z \space axis\\
\vec{e_\perp}:the \space vector \space perpendicular \space to \space edge \space and \space the \space z \space axis\\
\vec{p_1}:position \space of \space first \space vertex \space in \space world \space coordinates\\
\vec{p_2}:position \space of \space second \space vertex \space in \space world \space coordinates\\
\vec{e_1}:vector \space along \space edge\\
\vec{p_2} - \vec{p_1} = \vec{e_1}\\
\hat{z} \times \vec{e_1} = \vec{e_\perp}\\
\vec{e_1} \times \vec{e_\perp} = \vec{desiredDirection}
\end{equation}

you can use mathutils's Vector library to do this.


I'm solidifying a mesh and want to bevel just the cap. How can I avoid that the bevel also rounds the outline of the mesh?

I found how to do it. First, in edit mode, you select the edge of your flat mesh, and go to Edge -> Edge Bevel Weight. Then you press 1 on the numpad or drag your mouse to set the weight. The edge will become blue.

Then, in the Bevel modifier, you change the limit method to "Weight".

And this has the desired effect! I thought that it would work the same as the "Vertex Group" limit, but with the vertex group, you add unnecessary bevels in a lot of places because you're almost selecting all of your vertices.


How to fix inconsistency of mesh into the "body" in 2.80?

The problem seems to be that you have misplaced sharp edges, although I think it was also made worse by duplicate vertices. The first thing I did was merge by distance, which removed 1000+ vertices, then I started selecting the sharpened edges that didn't seem to flow with the rest. I then cleared the sharpened edges. See below:
The result is a much smoother look, with the offending faces "gone". I only did this on a handful of edges to test - there are quite a few of these places where you might want to unsharpen the edges, but probably also some others where you want to add some sharpness. You will have to look over your model and decide for yourself.

Hope this helps


No, you can't as of yet. The image editor is pretty basic at the moment. You could use cloning if you'd like, but that is much more involved (and a waste of time if you just need to copy/paste). Just use an external image editing application such as gimp or photoshop.


When in weight paint, armature is outlined in red rather than selecting a bone?

First check that your armature is in Pose Mode. Switch it to Pose Mode (Ctrl+Tab) and then select your mesh and paint.

If it doesn's help, you probably didn't assign Armature Modifier to your mesh. In this case select your mesh, then holding Shift select your armature and press Ctrl+P and then choose Armature deform.


How to improve Cycles Render times on a model Space Craft?

When using the GPU, blender actually renders fast with larger tile size:

There is an addon called auto tile size that will configure this for you. (It can be found in File > User Pref > Add-ons > Auto Tile Size ). If you would rather tweak it manually you can find the tile size in the performance section in the render tab.

Another thing you can do is turn down the bounces and turn off caustics. (These are found in the light path section in the render tab). I would turn down light bounces a lot especially because there is only one light source.

Happy Rendering!

Sources: BlenderGuru


You could answer the question if you should "just ignore that message" by yourself: Does the simulation / render looks as expected or at least is the result good enough for what you're looking for? Then ignore the message.
Apart from that, the Blender Reference Manual says the following about baking in frame ranges and offsets (this is in the Fluid section, not general), which suggests baking from frame 1 on and use the offset afterwards:


Importing Google Maps Data into Blender with Renderdoc isn't Working

I was able to get around this problem by installing a former stable version of RenderDoc. I had been running 1.10, and now I'm on 1.9 with no issues. I thought the problem was with Blender or my capture technique (eg, not moving the screen enough) but it turned out to be the version of RenderDoc.


Thanks to gandalf3, I found out it was my clipping distance settings for the viewport. The ending distance was set too high. I've set it to 5000 and it's perfect now.


How to prevent triangulation of models when importing models from sketchup to blender?

You can't (at least - not the way you want)

SketchUp very cleverly abstracts away the underlying geometry by rendering all connected faces on the same plane as one surface (unless you tell it not to). With this visual abstraction SketchUp allows surfaces to have gaps.

Blender's geometry model, known as BMesh, treats surfaces differently, it has a model of Tris, Quads and Ngons. BMesh does not allow holes in an Ngon (by design). By extension of this fact, you won't have exactly the same representation in Blender as you would in SketchUp for the same model. Blender won't magically abstract connected faces on the same plane into surfaces the way SketchUp does.

The loaded geometry will be correct, but in edit mode you will see the real geometry the way it exists in the .dae.

Blender is designed to let you edit the underlying geometry. it is a true polygon modeller. Ngon support with BMesh is a relatively recent development -- before that it was quads and tris only.

What you could do is:

enter Edit Mode for each object
select all
Delete -> Limited Dissolve

You will get a mesh that is perhaps more convenient.

Another option is to press Alt+J in edit mode, wich will transform all the triangles into quads.


First thing - you can export textures from blender without a problem using uv/image editor:

Just select the UV/Image editor as show in (1). Then select texture you want to save (2) and finally save as (3).

Second important thing, from what I understood you are trying to export materials including nodes from Blender to Unreal Engine? This won't work as you suspect it would.

MTL files exported together with OBJs have very little material information and are pretty much useless, not to mention the format is old and there seem to be better alternatives available nowadays.

Basically no 3d software allows you to freely move its own materials to other 3d engines, everyone has its own material making system, renderer etc and I don't think I have ever seen any 3d modeling software being compatibile with 3d engine in that field.

What you should do, is export all the textures, including baked ones (by "baked" I mean textures with shadow/colour/light/normal informations baked into them) and then recreate the material inside the engine using those textures.


How do I change to the texture mode in the viewport shading menu

This is not a dumb question :).
Since Blender 2.8, it's called Material Preview.
It's the third icon in the Viewport shading.


To use this with Blender 2.90 or later, it seems that you have to manually add the keymap of the following command.
Settings> Keymap> Screen>
screen.region_flip

As for the name of B's menu, it looks like "Redo Last".
The operator name that calls this menu in a popup is "Redo Last".
screen.redo_last
Apparently it was intentionally deleted.
↓ It's not the task of this problem itself, but it says so.
⚓ T71810 UI: Flipping a Sidebar with more tabs isn't aligned correct


How to disable Background layer rendering?

Have you tried going into the Render Properties > Film and ticked the box which says Transparent?
This will make the background of the render transparent so all you can see if the objects that you've added/created


Hair dynamics sends particles flying when mesh moves

Make sure the armature is above the particle system in the modifier panel
And go back to the frame where you begin caching
Or bake the hair dynamics


Purpose of the Model

Before you start with creating materials you should know the differences between the different purposes of a model. There are three main categories - still renders, animations and RT game engine models/assets.

Still Renders

If you are aiming for rendering a single scene, that one particular scene frozen in time, you definitely want to use procedural material setups. And you definitely want to go crazy with them, because you want to achieve the best possible effect. This concerns not only realistic materials, all the materials of a scene should also match in style.

Since your PC "only" needs to render one image, complicated material setups that put heavy load on CPU/GPU aren't much of a deal, it's the result that matters.

Animation Rendering

If you plan to render animations for movies, you still might want to use procedural materials, but keep in mind that your PC needs to render a ton of images for every minute you have in the end in your movie clip.

The more complex your material setup, the more time it takes to render all the images you'll need for a short movie clip and in the end you might not even see all the details due to moving  characters and cameras.

Real Time Game Engine Models and Assets

Most game engines today still use texture maps for materials, because even the fastest hardware isn't capable of creating a real-time animated game world with procedurally generated materials.

You can still use procedural materials during the creation process of your model but you'll need to bake them to texture maps, before exporting and importing the model into a game engine.

Rendering Engines

Blender offers two render engines "out of the box". The modern one is called Cycles, offers node-based material setups and also an "unbiased" modern approach to lights and shadows. Blender internal render engine takes a
"biased" approach on rendering, which means that it simply ignores the more complicated functions regarding lights and shadows.

While both render engines can produce still images and animations, I highly recommend using Cycles for that purpose. Blender Internal on the other side has the advantage to give a decent preview of game assets.

You can read more about the differences and the technical background in Gandalf's answer

How to proceed

(All the points below come from personal experience. Yours or that of other people might be different. )

The non-Blender related answer is that you will need a lot of patience and determination to achieve good results.

Start small, with basic models, shapes and materials.
Get the materials to look the way you want them to look.
Do not aim for the moon at your fist shot, because landing between the stars early on can be very frustrating.

The Blender-related answer is the above, plus

the recommendation to look for tutorials all over the internet.
Watch Blender related videos on youtube and vimeo and also keep in mind that you want to watch those which are related to your goal (first point - purpose of the model).
There are some "big names" in the Blender community, like Andrew Price and Gleb Alexandrow. But you also find lots of bits and pieces of information from other people, sometimes just by watching them speedmodeling.


I have Blender 2.79 and MHX2, for those figuring this out lately.
I did not access this through the properties menu.

I have found that option from the menu option below: View->Tool Shelf

OR

Pressing T.

After that, a panel will appear on the left.
Under the MHX2 Runtime you will see the submenu FK/IK Switch.


I would like to bake a material into a texture

I decided to use substance painter instead. Thanks for the help anyway. :)


Adding background to the landscape and mixing with mist

The problem is that your clouds should not be in front of the island, but behind!

EDIT: (after messing with this for a while...)
You need one more mix node.
In other words you need one to key the clouds behind the island.
And another one mix node to mix the mist over the island and the background.

I disabled mist again, according with your comment.
The hardest part is controlling how the horizon meets the sky since the mist pass takes care of the island but not of the ocean in the distance, so I added a mask to affect the alpha channel at the horizon line of the render layers node. Then I used that new mask to control the alpha over that mixes the Island and the sky.

The modified file I placed here:
http://www.pasteall.org/blend/28181

It's been a lot of fun playing with your file!


Go to the properties window.
Select the modifiers tab.
Apply the mirror modifier.
Then you can do the skinning.


Armature pose different in modes. Yes, I have reset the positions

It's really hard to see a "slight change" when all you provide is two pictures, one on top of the other.

I see you have two green bones, meaning they have constraints on them. May those be "Child of" or "Stretch to"constraints?
In which case, when you make a change in your rig, you need to go in each of these constraints and click either set inverse button for the "Child of", either Reset button for the "Stretch to".

If you don't wanna bother about going through each bone and clicking buttons everytime you change something, I have some python scripts for you.

EDIT: also check the IK's pole angles.


How to stop modal mode from unregister function?

I would not recommend starting your modal operator in the register() function.  Typically you want to add a button or something to a UI panel, which the user can use to invoke your operator.

But if you're sure you want to start and stop your operator using register() and unregister(), then you could try something like this:

#insert this after your imports:
still_running = True

#insert this in your modal() method:
global still_running
if still_running == False:
    return {'FINISHED'}

#insert this in your unregister() method:
global still_running
still_running = False


The way I like to use to close windows is right click the little border between two, and then press Join. You will know when you can right click as you hover over the border and your mouse becomes a partition. Then click one of the two windows that you want to join and they both become one.

The window you click will turn into part of the one you didn't click, merging into one.

In my opinion, this is much better because it allows you to preserve the state of one window.

If you want to open a window again, just move your mouse to a corner until it becomes a crosshair, and drag it to the correct size. Hope this helps!


2 parallel planes, the front one is rotated, when view is rotated, portions of the plane on the back is visible through the plane on the front

This is called z-fighting, and it's caused by blender not being able to properly decide which one to draw in front of the other.  You need some difference in the z coordinate, and if it's not large enough this can still happen at great distances due to floating point precision funkiness.


Export file format for Blender with Sound track

I found GLTF/GLB is the right format for exporting


There is nothing wrong with the UV map you created. Using Follow active quads gives you good uv islands suitable for trim maps.

You should instead focus on how you built the model. Try to keep your quads as square as possible so that the distortion gets evenly distributed across all faces.

I added a wireframe to the model so that you can see how the quads gets split up into triangles and how the texture stretches over them.


Sorry this is not an answer.

I will delete, just so I can post a pic.

I just opened your file, disconnected all the image textures (because they were not packed)

Then I just hit Render with all your settings and it doesnt have that same error that yours does.

This is what I got.

Maybe someone else can try your file and see if they can replicate it. It seems like a hardware glitch. Change to a GPU (if you can) see if that changes anything.


Is it safe to close the client during a network render while it is rendering?

I found that you can close the client once you send the render job to the master. The master is what needs to keep running.


How to animate rotation of an object in circular array, without the rotation affecting direction of the array itself?

You can simply parent your objects (the empty used for the array modifier and the mesh object) to another empty and rotate this last one.

Doing so will keep the relative location and rotation of the arrayed mesh and the empty used in this array.
That can also be:

In this case, hook the mesh to an empty and rotate it. Concerning the array, make sure that it is set on "constant offset" (not relative offset).


Per definition

Ambient occlusion is an approximation of global illumination that
emulates the complex interactions between the diffuse
inter-reflections of objects. While not physically accurate (for that
use full global illumination)

What is it?:
It is a way to make objects in a scene look more realistic. Ambient occlusion casts shadows where objects are close to each other. Note that it will also cast light where they are not. Ambient Occlusion is a fake light.

Note that in Cycles there is also an Ambient Occlusion Shader:

The ambient occlusion node gives per-material control for the amount
of AO. When AO is enabled in the world, it affects all diffuse BSDFs
in the scene. With this option it's possible to let only some
materials be affected by AO, or to let it influence some materials
more or less than others.

Ambient Occlusion enabled in the world panel.

Ambient Occlusion can make a big difference especially in the Blender Internal Render Engine. In cycles enabling Ambient Occlusion does not make a big difference in terms of realism because Cycles is already rendering with Global Illumination, which is physically correct Ambient Occlusion. So in cycles there often is no need for it whereas in the Blender Internal render engine it is very useful.


How can i make a blade out of plane like in the tutorial?

It looks like you should use the bevel tool. Switch to edge selection mode and select the edge you want to add a smooth edge too. Then click cntrl+B, you can change the size by moving your mouse up and down, you can also make it smoother with the scroll wheel.

Is this what you want?


Why isn't Face Sets painting all the faces under the brush in Sculpt Mode?

Ok I got it. In Brush options of the header bar it is necessary to UNCHECK the Face Sets and Face Sets Boundary checkboxes. It is also recommended to have a not too high Strenght if you want to smooth the Face Sets (when holding Shift with the brush).


I misunderstood how blender python works. Should have used BGE (Blender game engine)


How would I composite my rendered animation

In the node editor, delete the "Render Layers" node and replace it with an "Image" node. Then click "Open" and navigate to folder where your animation images are saved. Hit A to select all the images, and then finally select "Open Images".


Exporting 3D models for dynamic texture changes on web

The most popular format for web atm is GLTF, there is a Blender Addon for that.
Ofc. you cannot unwrap some vertices and ignore the rest, if you want separate UV Maps, you need separate objects (not files). Having an atlassed texture is always more perfomant than using multiple ones, not sure if that's an option in this case though.
It's probably easiest to separate the parts into different objects, use different materials on each part and set their textures individually.  if your UV Layout alone is 5MB, consider decimating your objects either manually or by using the decimate modifier.


It's most likely an issue with the shading mode. There are several ways to preview objects in Blender: wireframe, solid, shaded, textured, etc. Try clicking around on these:

Also, in your screenshot, you're in "World" editor mode (in the Shader editor). Make sure your world background isn't pure black/set to 0. If you don't have any lights in the scene, this is the only thing lighting it, and if it's set to 0 or pure black then there is no lighting at all, hence everything is black.


How to add a face between two faces that connects them?

Also it sounds like you might be hitting 'alt-click' instead of 'shift-click' to select verts/edges.  Alt-click selects a loop of verts/edges, whereas shift-click adds or subtracts single verts/edges from your current selection.


How to convert from high poly to low poly

One way to reduce mesh density is the decimate modifier, however for the workflow you want (creating a game asset) I think you want Retopology.

This is a workflow which gives your more control over the final result, however it will take longer as it is a manual process.

Some helpful addons and built in functionality for retopologizing your mesh:

Surface Snapping (feature)
Shrinkwrap modifier (feature)
Bsurfaces (bundled addon)
RetopoFlow (addon)

Some tutorials and reference material:

Bsurfaces demo
wiki page on retopologizing

After you have a lower topology mesh you can bake normal maps etc. to make it appear more detailed than it really is.


Draw geometry on screen using BGL module

All the available OpenGL calls exposed in the bgl API are: https://www.blender.org/api/blender_python_api_current/bgl.html

(or in https://svn.blender.org/svnroot/bf-blender/trunk/blender/source/blender/python/generic/bgl.c without the gl prefix)

It has a few OpenGL 2.0 calls, but not even all I think.
It's easy to extend it to specific functions, but we are close to the point where it makes more sense to use a full OpenGL wrapper such as PyGL (and that's why the number of functions exposed is a bit stagnated).


If you're able to convert your logo into a curve/mesh outline, you could then use Knife Project to cut it out of your base object. Then you would simply need to extrude the cutout area to the desired depth.


Set the lenses object pass index to a value of 1

Then under the layers panel use the passes dropdown and enable Object Index

Render that out and then head over to the compositor. Create a node setup as illustrated by the image below:

As you can see by this render, I believe it resolves your problem.

Hope this helps.


View -> Camera (or Numpad 0)
Shift + F (enter flight mode)
WASD to control camera and leftmouse to set the view


Import external py script into blender script?

from sys import path
path.append(bpy.path.abspath("//")+'/../Scripts')
from fbx_collection_export import export


Object relationships appear intact for some child objects, non-existent for others

Ok, I figured this out and I feel (kind of) dumb now.

Some objects were positioned in edit mode, while others were positioned in object mode.

The ones that were positioned in edit mode still have their object origin at (0,0,0) with vertices positioned away from the origin.

The ones that were 'misbehaving' were positioned in object mode, and had their origin at some non-zero position.

In both cases, the relationship line was drawn from the origin to the object position, but in the first case, it wasn't visible (since the object position and origin were the same point).


Any good free materials libraries online?

Some resources:

600+ Materials at Open Material Repository
Temporary offline (http://www.blender-materials.org/) backed up by the above.
For textures cgtexures is a good resource.


At the top of your Blender window, select Cycles Render.
In the Screen-layout drop-down, select Compositing.
At the bottom of that panel, put a check next to Use Nodes.

You can now branch the Render Layers Image output to several nodes.
You get to decide which nodes to use.  Just Add whichever ones you need,
then send the output from your nodes to Composite Image.


Strange geometry appears after separating part of mesh

To avoid this, I disconnected the particles, separated the mesh, then reconnected the particles.


If this has not changed in the latest versions an action will be deleted when it is not used (referenced) in the NLA-editor. You can keep currently unused action by adding a fake user (reference) with the 'F' button.


What Are the Differences between Smoke Collision Types?

This is my theory:

"Static" means a non-animated, non-moving object

"Rigid" means a non-animated, (possibly) moving object

"Animated" means an animated (shape keys, armatures, etc.), (possibly) moving object.

Tests won't resolve the issue, since, as the original question points out, they're currently all the same.

Here's my theory: I've heard talk about using volumetrics in the game engine.  When that happens, the interactions between static, rigid, and animated objects is going to be essential - it would be a waste to calculate everything if you weren't having the smoke interact with animated objects, for instance.  My theory is that they are currently "the same" because it does not matter outside of the game engine - it doesn't have to be specified, and resources are not delegated real-time as they are in the game engine.  But in the game engine, you DO need to label an object as static, rigid, or animated - and that goes for smoke as well.  Essentially, the technical difference between all of the above would be the same for any other object in the game engine - a necessary setting that tells physics how to interact with it to optimize resources.


Can I resume retopologizing a mesh in Retopoflow after exiting the tool?

I ran into this problem as well. You have to be in edit mode to re-enter Retopoflow.
With the RetopoFlow mesh selected in edit mode, press the diamond button to start RetopoFlow or open the menu and pick any of the RF options.

So, thankfully there is no need to retopologize all in one go.


Empty animation makes Transform Inspector yellow, model without animation has keyframes

Your still armature has been keyframed. It stays still because all the poses are the same all along the timeline, orange lines between the yellow dots mean that there are no change between all these poses.
In the Transform panel, green value means the armature is animated but is not keyframed at the selected frame, yellow means it is keyframed at the selected frame.
If you zoom in you'll see that the keyframes have been scaled and do not match with the timeline anymore, thus the sometimes green color on the Transform panel, when you're on a frame where there are no keyframe:

If you select and move the keyframes you can easily make them match to the timeline, and you'll see that your Transform panel will be yellow all along the scrub:


What has shut off rendering and display of the world background?

Switch to perspective view mode in the viewport (Numpad 5). When in orthographic view, which is what you are in now, the world background cannot be properly displayed. Instead, you get a single color based on (I think) the color of the pixel that you are facing. If you have a background with more colors, you will see the color change as you rotate around. Since your background is almost all black, you likely won't see any color change as you rotate your view.


If you're like me and wanted to make a rotational spring C between points A and B, such that it can rotate around point B, then you can make this construction with three objects. Two icospheres (for example), one at point B and one at point A. A cylinder is your rotational spring, and goes between the points. You add a spring constraint between icospheres A and B. Affix the cylinder C and icosphere A together with a fixed constraint. Affix the cylinder C and icosphere B together with a generic constraint, with all translation axes limited to 0 - 0. Then attach B to whatever object your rotational spring needs to be attached to.


Cobbled together a test script, that has parts that answer both of your q's.  Scale a sphere on x, y, z to make ellipsoids. (set sphere_only=False in script)

The 'within_touch' method looks at two spheres and if they are closer than the sum of their two radii, they are overlapping.  The distance between the spheres is the length of the vector created by subtracting ones location from the other.

If a pair of spheres are found to be overlapping the method returns the required vector to move to make them touch (with a bit of tol)

While testing added an object color, the bluer the harder to place.

import bpy
context = bpy.context
from random import uniform
from mathutils import Vector

count = 200

# random scale
min_scale = 0.001
max_scale = 1
# scale_factor .. scale down to help fit
scale_factor = 0.1
domain = 1
only_spheres = True

tries_per_sphere = 256

use_context_object = False
obj = context.object

def random_vector(a, b):
    return Vector([uniform(a, b) for c in "xyz"])

def checkbounds(sphere, fix):
    #return True
    loc = sphere.location + fix
    #dm = max(sphere.dimensions) / 2
    dm = max(sphere.scale)
    _min = -domain + dm
    _max =  domain - dm
    for i, v in enumerate(loc):
        if v < _min:
            loc[i] = _min
        if v > _max:
            loc[i] = _max
    return loc

def inbounds(sphere, loc):
    #return True
    dm = max(sphere.scale)
    return -domain + dm < min(loc) and  max(loc) < domain - dm

def random_sphere(sphere):
    # random scale and rotation for sphere based on settings
    if only_spheres:
        scale = uniform(min_scale , max_scale) * Vector((1, 1, 1))
    else:
        scale = random_vector(min_scale, max_scale)
    scale = Vector([min(s, domain) for s in scale])
    dom = domain - max(scale)
    sphere.scale = scale

    sphere.location = random_vector(-dom, dom)

scene = context.scene

mat = bpy.data.materials.get("randobjcol")
if not mat:
    mat = bpy.data.materials.new("randobjcol")
    mat.use_object_color = True

boundbox = bpy.data.objects.get("BoundBOX")
if not boundbox:
    bpy.ops.mesh.primitive_cube_add()
    boundbox = context.scene.objects.active
    boundbox.name = "BoundBOX"
    boundbox.draw_type = 'WIRE'
    boundbox.hide_select = True
    boundbox.location = (0, 0, 0)

if not scene.objects.get("BoundBOX"):
    scene.objects.link(boundbox)

boundbox.scale = domain * Vector((1, 1, 1))

spheres = []
if use_context_object and obj:
    sphere = obj
else:
    bpy.ops.mesh.primitive_uv_sphere_add()
    sphere = context.scene.objects.active
    bpy.ops.object.shade_smooth()
    scene.objects.unlink(sphere)

sphere.active_material = mat

for i in range(count):
    spheres.append(sphere)
    random_sphere(sphere)
    sphere = sphere.copy()
    #context.scene.objects.link(sphere)

# update the spheres dimensions
#context.scene.update()

tries = 0
t_count = 0
r_count = 0
moves = 0
resets = 0
pfix = Vector()

def within_touch(s1, s2):
    def r(s):
        return max(s.scale)
        #return max(s.dimensions) / 2
        #return sum(s.dimensions) / 3 #  average.

    d = (s2.location - s1.location)

    r1, r2 = r(s1), r(s2)

    radsum = r(s1) + r(s2)
    if d.length <= 0.0001:
        print("SAME")
        return Vector((r1, r1, r1))
        # same position
    elif d.length < radsum:
        # return a vector to move away
        d.length = radsum - d.length
        return  -d
    return Vector()

sphere = spheres.pop()
arranged_spheres = [sphere]
sphere = spheres.pop()

while sphere and tries < tries_per_sphere * count:
    if t_count > 5 and abs(min_scale - max_scale) > 0.00001:
        v = scale_factor * sphere.scale
        sphere.scale = Vector([max(s, min_scale) for s in v])
    #scene.update()
    touchers = [s for s in [within_touch(sphere, s) for s in arranged_spheres] if s.length > 0]
    if len(touchers):
        fix = Vector()
        for v in touchers:
            if sphere.color[0]:
                sphere.color[0] -= 0.1
            elif sphere.color[1]:
                sphere.color[1] -= 0.01
            else:
                sphere.color[2] -= 0.001
            fix += v

        #if fix.length < 0.0001 or not inbounds(sphere, loc) or r_count > tries_per_sphere:
        if (fix < 0.0001) or r_count > tries_per_sphere / 2:
            r_count = 0
            random_sphere(sphere)
            resets += 1
            #sphere.color[1] = 0
        else:
            loc = checkbounds(sphere, fix)
            sphere.location = loc
            moves += 1
        t_count += 1
        r_count += 1
        tries += 1
    else:
        print("Arranged ", sphere.name, "moves:", moves, "rand moves", resets, "fixes:", t_count)
        moves = 0
        t_count = 0
        r_count = 0
        resets = 0
        arranged_spheres.append(sphere)
        sphere =  spheres.pop() if len(spheres) else None

for s in arranged_spheres:
    if not scene.objects.get(s.name):
        scene.objects.link(s)

print("Arranged % d of %d" % (len(arranged_spheres), count))
print("TRIES", tries)

Edit

Following shows size 0.142 spheres placed in a domain 1 cube.  Placed 197 of 200 on this run, with settings shown.

Update for 2.8

import bpy
context = bpy.context
from random import uniform
from mathutils import Vector

count = 200

# random scale
min_scale = 0.1
max_scale = 0.1
# scale_factor .. scale down to help fit
scale_factor = 0.1
domain = 1
only_spheres = True

tries_per_sphere = 256

use_context_object = False
obj = context.object

def random_vector(a, b):
    return Vector([uniform(a, b) for c in "xyz"])

def checkbounds(sphere, fix):
    #return True
    loc = sphere.location + fix
    #dm = max(sphere.dimensions) / 2
    dm = max(sphere.scale)
    _min = -domain + dm
    _max =  domain - dm
    for i, v in enumerate(loc):
        if v < _min:
            loc[i] = _min
        if v > _max:
            loc[i] = _max
    return loc

def inbounds(sphere, loc):
    #return True
    dm = max(sphere.scale)
    return -domain + dm < min(loc) and  max(loc) < domain - dm

def random_sphere(sphere):
    # random scale and rotation for sphere based on settings
    if only_spheres:
        scale = uniform(min_scale , max_scale) * Vector((1, 1, 1))
    else:
        scale = random_vector(min_scale, max_scale)
    scale = Vector([min(s, domain) for s in scale])
    dom = domain - max(scale)
    sphere.scale = scale

    sphere.location = random_vector(-dom, dom)

scene = context.scene
view_layer = context.view_layer
mat = bpy.data.materials.get("randobjcol")
if not mat:
    mat = bpy.data.materials.new("randobjcol")
#    mat.use_object_color = True

boundbox = bpy.data.objects.get("BoundBOX")
if not boundbox:
    bpy.ops.mesh.primitive_cube_add()
    boundbox = context.object
    boundbox.name = "BoundBOX"
    boundbox.display_type = 'WIRE'
    boundbox.hide_select = True
    boundbox.location = (0, 0, 0)

if not scene.collection.objects.get("BoundBOX"):
    scene.collection.objects.link(boundbox)

boundbox.scale = domain * Vector((1, 1, 1))

spheres = []
if use_context_object and obj:
    sphere = obj
else:
    bpy.ops.mesh.primitive_uv_sphere_add()
    sphere = context.object
    #bpy.ops.object.shade_smooth()
    context.collection.objects.unlink(sphere)

sphere.active_material = mat

for i in range(count):
    spheres.append(sphere)
    random_sphere(sphere)
    sphere = sphere.copy()
    #context.scene.objects.link(sphere)

# update the spheres dimensions
#context.scene.update()

tries = 0
t_count = 0
r_count = 0
moves = 0
resets = 0
pfix = Vector()

def within_touch(s1, s2):
    def r(s):
        return max(s.scale)
        #return max(s.dimensions) / 2
        #return sum(s.dimensions) / 3 #  average.

    d = (s2.location - s1.location)

    r1, r2 = r(s1), r(s2)

    radsum = r(s1) + r(s2)
    if d.length <= 0.0001:
        print("SAME")
        return Vector((r1, r1, r1))
        # same position
    elif d.length < radsum:
        # return a vector to move away
        d.length = radsum - d.length
        return  -d
    return Vector()

sphere = spheres.pop()
arranged_spheres = [sphere]
sphere = spheres.pop()

while sphere and tries < tries_per_sphere * count:
    if t_count > 5 and abs(min_scale - max_scale) > 0.00001:
        v = scale_factor * sphere.scale
        sphere.scale = Vector([max(s, min_scale) for s in v])
    #scene.update()
    touchers = [s for s in [within_touch(sphere, s) for s in arranged_spheres] if s.length > 0]
    if len(touchers):
        fix = Vector()
        for v in touchers:
            if sphere.color[0]:
                sphere.color[0] -= 0.1
            elif sphere.color[1]:
                sphere.color[1] -= 0.01
            else:
                sphere.color[2] -= 0.001
            fix += v

        #if fix.length < 0.0001 or not inbounds(sphere, loc) or r_count > tries_per_sphere:
        if (fix < 0.0001) or r_count > tries_per_sphere / 2:
            r_count = 0
            random_sphere(sphere)
            resets += 1
            #sphere.color[1] = 0
        else:
            loc = checkbounds(sphere, fix)
            sphere.location = loc
            moves += 1
        t_count += 1
        r_count += 1
        tries += 1
    else:
        print("Arranged ", sphere.name, "moves:", moves, "rand moves", resets, "fixes:", t_count)
        moves = 0
        t_count = 0
        r_count = 0
        resets = 0
        arranged_spheres.append(sphere)
        sphere =  spheres.pop() if len(spheres) else None

for s in arranged_spheres:
    if not context.collection.objects.get(s.name):
        context.collection.objects.link(s)

print("Arranged % d of %d" % (len(arranged_spheres), count))
print("TRIES", tries)


Moving the camera with the Q and E keys is part of the view navigation controls, not part of the pivot point choice.
The effect of the keys is different depending on whether you are using walk or fly mode and the controls are described in more detail here. The default mode can be started with ⇧ ShiftF and either fly and walk mode can be chosen directly from View> Navigation> Fly Navigation or View> Navigation> Walk Navigation.

This navigation mode [walk] behaves similar to the first person navigation system available in most 3d world games nowadays. It works with a combination of keyboard keys (WASD) and mouse movement. By default the navigation is in the 'free' mode, with no gravity influence. You can toggle between gravity and free mode during the navigation (↹ Tab).
You can:
Move the mouse left/right to pan the view left/right or
move the mouse up/down to tilt the view up/down.
Move the camera forward/backward (W/S).
Strafe left/right (A/D).
Jump (V) - only in 'gravity' mode.
Move up and down (Q/E) - only in 'free' mode.
Alternate between 'free' and 'gravity' modes (↹ Tab).


And just as I was typing a few days ago, I thought to try out ctrl and yes, ctrl does the trick. Just hold LMB on a border and then add CTRL.


I accidentally set an object as camera, how do I undo this?

If you accidentally set an Object as Camera (CtrlNumpad 0 will do that)

You have two options to reset the camera back to the "active camera"

In properties windows/scene select your camera as "camera"

Or on the 3D layout select the camera and press
CtrlNumpad 0 (or use the menu: View->Cameras->Select_Active_Object_as_Camera)


Scale object in place keeping its origin

Matrix equivalent of global scale bounding box center.

Note both of these examples use the bounding box center as pivot point.

Could as suggested scale the mesh, akin to edit mode scale.  If scaling the mesh  use local coordinates. Note this alters the mesh coordinates, but keeps the origin and object global translation same.

To scale about a non origin point, first translate such that pivot point is origin, then scale, then move back.

import bpy
from mathutils import Matrix, Vector

context = bpy.context

scale = (2, 2, 1)

ob = context.object

bbox = [Vector(b) for b in ob.bound_box]
o = sum(bbox, Vector()) / 8

T = Matrix.Translation(o)
S = Matrix.Diagonal(scale).to_4x4()
T2 = Matrix.Translation(-o)

M = T @ S @ T2

ob.data.transform(M)
ob.data.update()

And a global version.

Make a scale matrix and two translation matrices, one to make scale origin bounding box global center, the other to move it back.

Note this will not alter the mesh or its origin, but will translate the object to match the scale, to give object appearance of scaling in place.

import bpy
from mathutils import Matrix, Vector

context = bpy.context

scale = (2, 2, 1)

ob = context.object
mw = ob.matrix_world
bbox = [Vector(b) for b in ob.bound_box]
go = mw @ sum(bbox, Vector()) / 8

T = Matrix.Translation(go)
S = Matrix.Diagonal(scale).to_4x4()
T2 = Matrix.Translation(-go)

M = T @ S @ T2

ob.matrix_world = M @ ob.matrix_world


Extend your curve a bit in Edit mode so that its 2 ends go a bit further and instead of creating shapekeys, just move your curve on the Y axis:


How to convert an HDR Image created / rendered on Blender to a format acceptable on social media and websites?

Sorry for the links only answer, but this is too long for comments.

You are mixing two different concepts:
1. HDRi
stands for High Dynamic Range image, that has larger colour values than those that can be displayed by any screen. They are used mostly as environment textures to light scenes.
2. 360 images
concept of environment projection https://wiki.panotools.org/Projections
Watch https://www.coursera.org/lecture/360-vr-video-production/equirectangular-projection-cubemaps-uTv8r
Most HDRi is mapped used in 3D and VR is using equirectangular projection, but is not mandatory.
As to how to do this in blender, it has been asked before:
Blender panoramic render
Is it possible to render a panorama in perspectives other than full 360°x180°?
equirectangular rendering for Blender Internal?
how do I bake an animated sky box using cycles?


The knee is pointing towards the pole target as set in the IK constraint. You need to lift the pole target higher than the knee when you raise the foot.


How to scale the scene relative to an objects metric values?

This is probably a duplicate, but I couldn't find any answer right now.

Scale all objects simultaneously towards a common center (the 3D cursor).

Position the 3D cursor at the common center. This can simply be the origin of the scene. To place the 3D cursor at the scene origin (0, 0, 0), press ⇧ ShiftS and select Cursor to Center.
⇧ ShiftRMB select the objects you wish to rescale.
Note, that the dimension values take all selected objects into account not just the active one.
Set the 3D cursor as the pivot point with the shortcut NumpadPeriod or via the 3D view's menu.

Rescale with S, then enter the desired value (e.g. 0.01) and press ⏎ Enter to confirm.
You will have to calculate this value beforehand by dividing the desired measurement with the current measure. E.g. If you table has a dimension[0] of 1.5 and you want it to be 2, your scaling value will be 2 / 1.5 = 1.333. This can be done during the scaling operation.
Press S 2 * /1.5 and confirm with Enter.
Apply the scale of the objects by pressing ⎈ CtrlA and choose Scale.


Filling pentagon with quads (combinatorics)

Original answer (edit addressing the question clarification below)
If you look at how the Catmull-Clark subdivision algorithm does it, you can see it creates a five-pointed star:
Before:

After:

When you surround it with quad geometry, it still works the same:
Before:

After:

With Catmull-Clark smoothing:

If we look at this, we can see that this redirects the topology very nicely:
It is important to note, though, that in a few cases, you can change the way you divide it up to change the topological flow. Most times though, this is the easiest and most useful subdivision.
Edit:
When I saw your edit and understood better what you were asking, the first thing I thought of was CGCookie's Retopoflow addon. You can purchase it on the Blender Market. This has a few algorithms to fill or "patch" areas like that. I looked at how it did that and came up with a few ideas:
#1: Are all of your subdivisions necessary?
I know that this doesn't answer your question directly, but it seems like the number one thing that the RetopoFlow does is reevaluate whether all of the vertices on each edge are necessary. It will add or remove vertices to adjust and produce cleaner topology.
#2: Treat it like a quad
In some cases, you can treat it like a quadrilateral. For example, if you have a pentagon like this:

You can treat the two right edges as one edge and still fill it like a quad:

It doesn't have to be symmetrical:

In addition, Retopoflow has a open pull request that has more sophisticated N-gon filling methods. You might be able to look through the source code to find what algorithms it uses. Here is a gif from the site of what this produces:


How to round the mesh that has a little complicated form?

You can use Proportional editing for this.

Use you regular Move tool to move the vertices, and check Proportional editing.
Play with the falloff profile and size.

You might also need to check Projected (2D) in your case.


Smooth Shading on specifically-oriented edges

As of this commit (will be in blender 2.71), blender has support for split normals. You can download 2.71 release candidate 2 here.

Set your object to smooth shading.
Enable auto smooth in Properties > object data:

Select every edge loop and mark it as sharp:

Press CtrlAltRMB on one of edge loops you want to make sharp to select that edge ring.
Press Edge Loop in 3D view > Header > Select to select the rest of the loops.
Press Sharp in 3D view > Tool shelf > Shading / UV > Shading > Edges, or press CtrlE> Mark Sharp:

Result:


How to see the python script used for an addon in a .blend file

split the screen and change the 3d viewport to text editor , click on the Open and select your python file , and you should get it , and i think you can also open them in notepad(not sure , try that for future)


Adaptive subdivision modifier causes high memory

It looks like you might be better off not using adaptive subdivision. According to the docs, this property makes muti user objects single user objects, causing increased memory.

This might mean that its separating each iteration of the array (which would make sense as each one needs to be subdivided differently.)

Another solution might be to shorten your array a bit, then manually duplicate the array and lower the subsurf level.

Just out of curiosity, what happens if you move the array below the subsurf? (Other than messing up your seams) Does that help with render times at all?


Unless I missed it, this has not yet been fixed. I actually reported this as bug once and that's how I learned it's considered a "known limitation", not a bug. Viewport transparency on dupligroups just straight up isn't supported.

If you really need to see past an object in a dupligroup, the max draw type on the source object is still respected, so you can set this to wireframe or bounding box. (max draw type is located in the object > display panel too, right next to the transparency checkbox)


How to store area of each quad mesh from a mesh?

To output the areas of each face to a file, you would need to use a python script. It is easy to use python to create and write to a file. You can use str.format() to control how the data looks in the file.

The area is a property of each face in the objects mesh data, faces are called polygons here.

import bpy

with open('face_data.txt','w') as out_file:
    for f in bpy.context.object.data.polygons:
        out_file.write('{}, {}\n'.format(f.index, f.area))


This has interested me I must admit.

I have never really had a use for grease pencil until I saw this post and I took a little look-see in blender 2.79

It seems that if you draw a line with the grease pencil and then select it (under the grease pencil layers section in the right-hand side tab of 3D view), you can click on the convert to geometry dropdown under tools (where you select the grease pencil). The line will stay, but you can then select the line, which is now an object or curve.

And yes, you can hide the line. On the right-hand side tab in 3D view (As used above), there is a checkbox called X-Ray. Uncheck it.

Some Quick Circling to help:

EDIT:

As of Blender 2.8, the method of using grease pencil has changed quite a bit. Firstly, to use grease pencil you must create a grease pencil object in object mode. Change to draw mode and draw your line with the tools. You can change the mode to surface, 3d cursor or origin through the drop-down middle top screen. Then switch to edit mode, and under strokes, there is the option to convert to geometry.

Now in Blender 2.8, there is no more x-ray. It is now called depth ordering. It should be set to 3D space by default, which is like x-ray off, but you can set it to front mode for x-ray on.

Good luck with your project and I hope I helped,

BFB


moving the armature along with the model

Simply move the armature object, or the root bone (in pose mode).

Once you have rigged a character, you no longer need to move the mesh objects themselves (usually characters consist of several mesh objects). That would be very difficult to animate, and could not deform.

This is in fact the purpose of rigging - to allow you to easily control and animate a character using bones rather than the original objects themselves.

Usually a rig will have a Master or Root bone that is used to position, rotate and possibly scale the character. This bone is the final parent of all the bones in the rig (the first bone of each chain, if not parented to something else, is parented to the root)


I don't really understand the problems you have since last december. I also tried to create animations from a control-file therefore I share some thoughts on this topic.

Pointers

First step would be to identifiy the phonems in the audio stream used there is lip-syncing tool Papagayo
In this BA thread someone used the Papagayo output as input for the script posted there, I it basically applies poses from a poselib.
I was able to get it work for the latetest blender release.

Answer

  My question is if anyone knows how i could animate to a voice without
  automating it with the idea of shape keys for certain voice sounds.

I created a script to read a control file with frame#, object and influence to automatically create an animation: Mapping an algorithm to an animation
It is very basic but easy to extend to use multiple shape-keys.


The closest thing blender has to your example is a great add on called molecular.
You can watch the demos on youtube to get a feel for what this add on can do.

molecular download

The documentation for molecular is on the same site.


How to move the keyframes for specified shape keys with Python

This script gives you the ability to list the names of the shapekeys you want to shift, then move only them by the keyframeInterval value you want.

It uses a regular expression pattern to match the shapekey name to the fcurve data path string.

import bpy, re

o = bpy.context.object

sk  = o.data.shape_keys
act = sk.animation_data.action if sk and sk.animation_data else None

keyframeInterval = 10 # Number of frames to move shape keys
keysToShift = ['Key 2', 'Key 3'] # List of shape keys you want to move (names)

# Regular expression pattern to find key in fcurve data path.
# Example: 'key_blocks["Key 1"].value'
pat = '^key_blocks\["(.+)"\]\.value$'

if act:
    for fc in act.fcurves:
        m = re.match( pat, fc.data_path )
        if m and m.groups() and m.groups()[0] in keysToShift:
            for kf in fc.keyframe_points:
                kf.co.x += keyframeInterval


When I join particles they somehow multipy

When you convert a particle system, the new objects all use the same mesh data. This is the same as making a linked duplicate. When you join two of these objects together, every other object using that same mesh will show the same duplication.

Blender seems to recognise this, so that if you select all of the particle objects and Join them in one go they will be joined into one object without the duplication. The original object you used for the particle system will receive the same duplication so you may want to separate it first.

In the mesh data properties there is a number between the mesh name and the 'F' button (only shown if it is greater than 1). This number indicates how many objects are using this mesh data. By selecting the original object used as a particle you can click this number to separate the object from the others preventing it getting the same duplication when you join all of the others.


Creating complicated models using scripts

Scripts (as far as I know) can access almost every part of Blender. There are scripts to create relatively complex objects, but they are usually add-ons instead. For example, there are add-ons to create trees and mountains.

To answer the rest of your question, scripts to generate complex meshes are not usually seen for two primary reasons:

Usually complex meshes require much care and an artist's touch. The artist wants complete control over the creation, and will use scripts only to create the simple pieces that are repetitive, then put them together into a more complex mesh. This is good, because computers aren't creative, but are very good at creating lots of things with simple variations.
Scripts to generate complex objects that are not extremely simple are usually broken out into separate programs. For an artist to relinquish control of their hand in the art to a program to generate, or in many cases, simulate, they still need to have lots of options to control the simulation. They want the program to be complicated and advanced, with lots of options. This is why, usually, scripts to generate mountains, trees, or people are often separate programs, then the meshes are just imported. Some examples are MakeHuman, The Grove, and World Machine. These programs have all had much work put into them as standalone programs that are useful in their own right. The other benefit of this is that now these generated meshes can be used in (mostly) any 3D software.


This is all that is needed, and the way I prefer to access vertex colors. It works in any mode:

import bpy

obj = bpy.context.active_object

for ipoly in range(len(obj.data.polygons)):
    for idx, ivertex in enumerate(obj.data.polygons[ipoly].loop_indices):
        ivert = obj.data.polygons[ipoly].vertices[idx]
        col = obj.data.vertex_colors.active.data[ivertex].color
        obj.data.vertex_colors.active.data[ivertex].color = tuple(1-x for x in col)

If you want UI button add it with this micro addon (save as .py file into addon folder):

bl_info = {
    "name": "Invert Vertex Colors",
    "location": "3D viewport > Header > Paint menu in Vertex Paint mode",
    "version": (0,1,0),
    "blender": (2,7,6),
    "description": "Inverts vertex colors of active paint layer",
    "author": "Jerryno",
    "category": "Paint",
}

import bpy

class InvertVertexColors(bpy.types.Operator):
    bl_idname = "paint.invert_colors"
    bl_label = "Invert Vertex Colors"
    bl_description = "Invert vertex colors of active paint layer"

    @classmethod
    def poll(self, context):
        try:
            return context.active_object is not None
        except (AttributeError, KeyError, TypeError):
            return False

    def execute(self, context):
        active = context.active_object
        for ipoly in range(len(active.data.polygons)):
            for idx, ivertex in enumerate(active.data.polygons[ipoly].loop_indices):
                ivert = active.data.polygons[ipoly].vertices[idx]
                col = active.data.vertex_colors.active.data[ivertex].color
                active.data.vertex_colors.active.data[ivertex].color = tuple(1-x for x in col)
        return{'FINISHED'}

def menu_entry(self, context):
    self.layout.operator("paint.invert_colors", icon='IMAGE_ALPHA')

def register():
    bpy.utils.register_module(__name__)
    bpy.types.VIEW3D_MT_paint_vertex.append(menu_entry)

def unregister():
    bpy.utils.unregister_module(__name__)
    bpy.types.VIEW3D_MT_paint_vertex.remove(menu_entry)

if __name__ == "__main__":
    register()


Can I use images rendered with blender for commercial use?

Short answer Yes.
Just as you own what you draw with a pencil, you own works you make with Blender(no difference).
To quote from blender.org

Your artwork
What you create with Blender is your sole property. All your artwork – images or movie files – including the .blend files and other data files Blender can write, is free for you to use as you like.
That means that Blender can be used commercially by artists, by studios to make animation films or vfx, by game artists to work on commercial games, by scientists for research, and by students in educational institutions.
Blender’s GNU GPL license guarantees you this freedom. Nobody is ever permitted to take it away, in contrast to trial or “educational” versions of commercial software that will forbid your work in commercial situations.

Meaning anything you make in Blender (images, scripts, add-ons, models, entire scenes, materials, textures, and so on) is yours, and you can do anything with it, without any legal notices at all.

A general note about Open-Source, not specific to Blender.
You don't have to get into details of each license.
Any OSI approved License assured you can do what you like with works created from OpenSource software. This is part of the Open-Source, definition as defined by the OSI,
http://opensource.org/osd
Points 5 and 6.

No Discrimination Against Persons or Groups

The license must not discriminate against any person or group of persons.

No Discrimination Against Fields of Endeavor

The license must not restrict anyone from making use of the program in a specific field of endeavor. For example, it may not restrict the program from being used in a business, or from being used for genetic research.


How can I move a child object to a target position using python?

To set the location of an object to a target position specified in world space simply set the translation value of the object's world matrix

child_obj.matrix_world.translation = target


How to create an Empty of type Image and assign a picture with Python?

An Empty is created like a regular Object, but with None for its data:

empty = bpy.data.objects.new("My Empty", None)

It can be linked to the current Scene like any other object:

scene = bpy.context.scene
scene.objects.link(empty)
scene.update()

The origin is set using the standard .location property (you may also use .matrix_world.translation):

empty.location = (1, 2, 3)

To make this Empty an Image-Empty, change its .empty_draw_type property to IMAGE:

empty.empty_draw_type = 'IMAGE'

An Image datablock is then assigned to the Object's .data attribute!

img = bpy.data.images.load("path/to/image.png")
empty.data = img

Other properties available for Image-Empties are (UI / Python):

Transparency / Object.color[3]
Image Offset / Object.empty_image_offset
Image Size / Object.empty_draw_size

BTW: You can change the RGB colors (.color[0:3]) of the object to tint the Image, which is not possible via the interface!


Triangularization problem in symmetric objects

First of all, why do you care? It shouldn't affect the shading at all, since the triangles will still be coplanar.

And I would say it's neither a feature nor a bug, since it probably wasn't planned but doesn't really matter one way or the other. (Of course, if it must be triangulated a certain way, you can always triangulate it yourself.)


For which formats are Cycles materials completely and accurately exported?

OSL materials transfer best, as James pointed out.
As far as I know, Cycles cannot currently export it's own materials. Blender Internal can sure export textured things though.

Anyway if your scene is already built up with Cycles your best chance for going to 3Ds Max is first .fbx and then .dae.

About file formats:
.3ds is old.
.obj is old too, but has worked well for me, especially concerning mesh-only models.
.dae is great with textures, optimized for gaming.
.fbx is great with textures, optimised for autodesk :)
dae and fbx should probably support shaders, but as stated before, Cycles doesn't support exporting them yet anyway.

more on .dae


cycles bake seems to have lost some UV data

Solved..........
Even though I deleted all the sub materials that I baked into the one texture,  the material slots were still there.
Once I deleted all the no longer required sub material slots the face textures appeared as expected.


Cast ray from the cursor and get the index of the hit face

regarding "but getting the feeling that there's more going on there than I need"

This is too vague, you didn't state what you need.

There is Scene.ray_cast - which you can use to ray-cast into the entire scene's visible objects, but this doesn't expose access to the face thats hit. (only the point of intersection & the normal)

In general, no, this can't be further simplified. you need to.

Get the mouse coordinates from an Event.
Get the RegionView3D from the context.
Calculate a point-of-origin from the viewport (not always obvious with orthographic projections)
Convert the mouse coordinates into a view-vector (using view3d_utils).
loop over all objects you want to ray cast.
convert the ray origin and direction into the object's local-space.
run the ray-cast function on a selection of objects.
find the closest result by shortening the ray each time.

Of course you can write your own function to handle all this, and just re-use. But there are many decisions involved in which objects are used, and how far to cast the ray, weather to use the views near-clip to offset the origin or not... etc.

If you don't need dupli-object support the script could be simplified to loop over scene-objects (but not duplicators).


To Redo press Ctrl+⇧ Shift+Z.

You can also press Ctrl+Alt+Z to get a list of your undo history. Handy, if you've gone overboard with Undo.


Can I store text object data in external file?

This is an addon for writing text objects to .xml file and reading them back from the text file.

How to use:

you have a file with text objects in one or multiple scenes
have text objects
export to an xml file (file->export->text to-from xml )
edit text outside blender save the .xml
in the first .blend file (with the objects and scenes ) use the addon to update text objects from the .xml file  ( this time select read_objects in the left side of the file browser )

install: from the addons tab click install from file and select this txt_xml.py file check the check-box to activate

UPDATE
the addon file txt_xml.py

bl_info = {
    "name" : "text objects to-from xml",
    "author" : "chebhou",
    "version" : (1, 0),
    "blender" : (2, 7, 3),
    "location" : "file->export->text to-from xml",
    "discription" : "copys an text objectx from-to xml file",
    "warning" : "this add-on is extremly unusefull",
    "wiki_url" : " chebhou@gmail.com",
    "tracker_url" : "chebhou@gmail.com",
    "category" : "Import-Export"
    }

import bpy
from bpy.types import Operator
from bpy_extras.io_utils import ExportHelper
from bpy.props import EnumProperty, BoolProperty
from xml.dom import minidom
from xml.dom.minidom import Document

def txt_sync(filepath):
    dom = minidom.parse(filepath)
    scenes =dom.getElementsByTagName('scene')
    for scene in scenes:
        scene_name=scene.getAttribute('name')
        print("\n",scene_name)
        bl_scene = bpy.data.scenes[scene_name]
        txt_objs =scene.getElementsByTagName('object')
        for obj in txt_objs:
            obj_name = obj.getAttribute('name')
            obj_body = obj.childNodes[0].nodeValue
            bl_obj = bl_scene.objects[obj_name].data.body = obj_body
            print(obj_name,"  ",obj_body)

def txt_export(filepath):

    doc = Document()
    root = doc.createElement('data')
    doc.appendChild(root)

    for sce in bpy.data.scenes :
        #create a scene
        scene = doc.createElement('scene')
        scene.setAttribute('name', sce.name)
        root.appendChild(scene)

        for obj in sce.objects :
            if obj.type == 'FONT':
                #add object element
                object = doc.createElement('object')
                object.setAttribute('name', obj.name)
                txt_node = doc.createTextNode(obj.data.body)
                object.appendChild(txt_node)
                scene.appendChild(object)

    #write to a file
    file_handle = open(filepath,"wb")

    file_handle.write(bytes(doc.toprettyxml(indent='\t'), 'UTF-8'))
    file_handle.close()

class   text_export(Operator, ExportHelper):

    """write and read text objects to a file"""
    bl_idname = "export_scene.text_xml"
    bl_label = "text from-to xml"
    bl_options = {'REGISTER', 'UNDO'}    #should remove undo ?

    # ExportHelper mixin class uses this
    filename_ext = ".xml"

    #parameters and variables
    convert = EnumProperty(
                name="Convert",
                description="Choose conversion",
                items=(('W', "write objects", "write text objects to xml"),
                       ('R', "read objects", "read text objects from xml")),
                default='W',
                )

    #main function
    def execute(self, context):
        bpy.ops.object.mode_set(mode = 'OBJECT')
        if self.convert == 'W':
            txt_export(self.filepath)
        else:
            txt_sync(self.filepath)

        bpy.context.scene.update()
        self.report({'INFO'},"Conversion is Done")
        return {'FINISHED'}

def menu_func_export(self, context):
    self.layout.operator(text_export.bl_idname, text="Text to-from xml")

def register():
    bpy.utils.register_class(text_export)
    bpy.types.INFO_MT_file_export.append(menu_func_export)

def unregister():
    bpy.utils.unregister_class(text_export)
    bpy.types.INFO_MT_file_export.remove(menu_func_export)
if __name__ == "__main__":
    register()


Size and other attributes can be controlled by percent of life expired with a texture associated with the particle system. Blend texture horizontal and color ramp.  Strand Particle Coordinates. Below size is decreased as particles age.
Please click on images to see them larger.

Materials can use [particle info node] to calculate percent of life expired.

Please experiment and improve the information provided.  You can do a better job.
There is also Bloom.  Highlight Blurring.  Cycles may be preferable for transparency.  There are may videos on the site with the names that rhymes with noonoob and here at BSE.  The Blender compositor can select the highlight and blur.
value = [Current age] / [lifetime] with a math node.
So a material can become transparent or change color for a particular particle over time.  I have chosen to change color for a quick answer which you can improve.
This work with practice will take less than 15 minutes for a rough approximation.
The older particles can be more transparent and smaller and less bright in the four combinations.


Execute Python script between rendering animation frames

You can loop through frames and render each one and do whatever you want before rendering the next one like this:

import bpy

s=bpy.context.scene

s.render.resolution_x = 512 # just for my example
s.render.resolution_y = 512

for i in range(s.frame_start,s.frame_end):
    s.frame_current = i

    s.render.filepath = (
                        "C:\\temp\\" # some path
                        + str(s.frame_current ).zfill(3)
                        )
    bpy.ops.render.render( #{'dict': "override"},
                          #'INVOKE_DEFAULT',
                          False,            # undo support
                          animation=False,
                          write_still=True
                         )

    # Do whatever you want here
    # Changing render resolution is one of the things imposible to do with
    # handlers while rendering an animation so let's do that

    if s.render.resolution_y == 512:
        s.render.resolution_y = 256
    else:
        s.render.resolution_y = 512

The problems start if you want to see the render happening in the UI. If you uncomment 'INVOKE_DEFAULT' it breaks everytihing because the script is unable to know when the started render finishes. People have tried to work around that, but things get ugly from here. See this question if you want to pursue this.


AN: scale a grid in world axis without scaling objects

Use Offset Matrix with scale mode Translation Only. This option is available in advanced node settings.