How to handle modal operator events in a single loop?

Yes, Python's coroutines can be used make the operators callbacks interact with a generator.

Here's an example of a generic re-usable operator mix-in class, and an example usage.

See modal_iter function for an example of how (invoke, execute, modal, cancel) can be handled from within a single generator.

import bpy
from bpy.types import Operator

# -----------------------------
# Generic Modal Iterator Mix-In

class ModalIterOperator:
    """ Defines Operator callbacks (invoke, execute, modal, cancel).
        Sub-classes only need to define `modal_iter` generator.
    """

    def invoke(self, context, event):
        self._iter = iter(self.modal_iter(context))
        self._iter.send(None)
        result = self._iter.send(event)

        if 'RUNNING_MODAL' in result:
            wm = context.window_manager
            wm.modal_handler_add(self)
        return result

    def execute(self, context):
        return self.invoke(context, None)

    def modal(self, context, event):
        return self._iter.send(event)

    def cancel(self, context):
        self._iter.send(None)

# ----------------------------------
# Example of ModalIterOperator Usage

class MyIterTest(Operator, ModalIterOperator):
    bl_idname = "wm.my_modal_iter_operator"
    bl_label = "My Modal Iter Operator"

    # -------------------------------------------
    # Entire modal operator in a single function!

    def modal_iter(self, context):

        event = yield

        if event is not None:
            # -------------------------------------
            # Section typically handled by invoke()

            print("Operator.invoke(..., event=%r)" % event.type)

            # Check we would typically do inside invoke()
            # to see if we want to exit, or continue and run modal()
            if event.type == 'ESC':
                yield {'CANCELLED'}
                return
        else:
            # --------------------------------------
            # Section typically handled by execute()

            print("Operator.execute()")

            # We may want to cancel the operator here too.
            if 0:
                yield {'CANCELLED'}
                return

        # ------------------------------------
        # Section typically handled by modal()
        event = yield {'RUNNING_MODAL'}

        while event is not None:
            print("Operator.modal(..., event=%r)" % event.type)

            if event.type in {'RIGHTMOUSE', 'ESC'}:
                yield {'CANCELLED'}
                return

            # ------------------------------------
            # Main modal operator logic goes here!
            # ------------------------------------

            event = yield {'RUNNING_MODAL'}

        # cancel may be initiated externally
        if event is None:
            # -------------------------------------
            # Section typically handled by cancel()
            print("Operator.cancel()")
            yield  # --> None, since we're closed externally
            return

        yield {'FINISHED'}

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

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

if __name__ == "__main__":
    register()

    # test call
    bpy.ops.wm.my_modal_iter_operator('INVOKE_DEFAULT')

Notes:

None of the return's in modal_iter are needed, since the way the generator is used these points will never be passed anyway. I've added them in so as to be clear whats happening and so any accidental iteration past yield {'CANCELLED'} will raise a StopIteration exception, which intentionally isn't handled.
This code example may seem overly verbose, this is done for completeness.In practice you may not need all of the callbacks (cancel or execute for eg).
This article was used in writing the example above.


Make sure you have a light source bright enough in your scene.
Check your compositor and make sure that the scene output is wired into the final image (I think it's called composite, I'm not sure, I'm writing this on my phone).
Next, to solve your problem with 60 images instead of 11, go to properties, and click on the camera icon. In the first or second section should be a drop-down menu for the frame rate. Click on custom and type "10" for your frame rate.

Also, make sure your actual animation is only 11 frames long in the timeline. Check your file output settings too. Other than that, I don't know what could be causing those black frames.


How to clip a material and give the illusion that it is 'solid' or 'filled' with Cycles?

One option is to do it manually.

1) Press TAB to go into edit mode.

2) Select all the vertices bordering the hole.

3) Press 'F' to fill the selected area.

I hope this helps! -Galaxy


Using a .step file or other CAD files in blender

There is a free program you can get called CAD exchanger, it's the only option I have found that actually works. You just put in your file and it allows conversion to many useful formats. I've found that collada works best for Blender, as the obj was blank when I tried it.


I can't find a way to make a flashing cursor effect?

In Cycles you may achieve it (if I got you right) animating the Factor value between Emission and Transparent nodes.

Add your text with dash and convert it to mesh with Alt+C-->Mesh from Text. Select the dash and give it a material using material nodes as pictured below (mix Emission and Transparent shaders).

Go to frame 1 on a Timeline and press I while hovering the cursor over the Fac slider of the Mix shader (set it's value to 0.000 before). It'll add a keyframe to it.

Go to the frame 10 (or any further one), change the Fac value to 1.000 and insert the keyframe again.

Now go to frame 20, change the Mix value to 0.000 and repeat the keyframing process.

To extend the animation go to the NLA Editor and press the 'double down arrows' symbol there.

Finally open the properties panel there (N) and set the Scale and Repeat values. Scale'll increase the blinking lenght and Repeat'll extend the whole animation.


How to model a burger package with beveled edges?

In reality, the paper bends to hold the box closed.
In 3D no bending occurs, the paper clips through instead.

Some pointers for modeling:

Model only one half and use Mirror Modifier to generate the other
Use Solidify Modifier to add thickness
Make use of Pivot points when rotating (Active element works well)
Use Custom orientations to rotate angled parts

Using Pivot Point > Active Element to rotate around selected vertex.

Using a Custom orientation to rotate an angled flap.


With the Fast Carve Addon it is simple to use.

Download the addon here

Just weight paint one side. In the object mode -> Tool shelf -> Fast carve -> symmetrize. Click on the axis need. (If you have painted on X axis click on the X axis. It will symmetrize on the negative X axis).


You've enabled the Proportional Editing option (blue sphere icon on the horizontal bottom menu bar)


You have to use a particle system inside a particle system.
Just add the particle system you want to appear on the object you use for the first system, tweak the time and that should do it.


Sometimes, while modeling, you get normals that are inverted. This can happen especially when working with the boolean modifier and other functions, where Blender isn't sure that you want to have the normals recalculated.

By going into edit mode, selecting all your vertices with a, and pressing ctrl + n, Blender attempts to make all of your normals point "outward" from what it thinks the inside of your model is. You can also go to through the menus: Mesh -> Normals -> Recalculate Outside.

I'm pretty sure that the texture will only appear on the "outside" of the mesh, which is why after you baked it, some parts where black and not rendering correctly.


Make intersection between plane and mesh more realistic

I looked at some reference pictures and i think the area around your plank could use some adjustments to make it more believeable.
For example:

raise the ground a bit where the plank goes into the floor
reduce the amount of moss directly around the plank (the moss in your render kinda looks like it's going into the plank)


Cycles texture on sphere to follow sun rotation

I would do this by parenting an empty in line with the sun, then using the empty's coordinates as a vector in the node editor to get the sun's rotation.

First create an empty and parent it to the sun lamp.  The empty should be directly in line with the sun lamp, but not exactly on top of it.  To do this it helps to reset the sun's rotation (Alt+R) and put the empty somewhere directly underneath the lamp before parenting it, then re-position the lamp how you want it.

Next go to the node editor and add the following nodes.  The output on the right will be the desired gradient from facing sun's direction 1.0 to facing directly away from the sun 0.0.  The three Value nodes on the left are driven by the empty's X, Y, and Z positions respectively.

The position of the empty is converted to a vector using the Converter > Combine XYZ node, then normalized so that you don't have to worry about the distance from the lamp to the empty and scene units conversion to the node editor etc.  The desired output is created by taking the dot product of this value and the geometry's normals.

Note that since I am using the dot product, this output will be a quadratic gradient.  To get a linear gradient you will have to compute the vector similarity manually, or just use a color ramp or RGB curve node to create a satisfactory gradient.


The job API is a C API, and not exposed to Python. For parallel processing of data in Python, use the regular tools Python gives you for this, like multiprocessing or concurrent.futures.


You cannot get a Z-depth of a volumetric shader. You would have to somehow turn the volume into a mesh - and get a depth of those polygons.

An idea would be to give the smoke a color based on distance from camera - you can shade the volume almost solid with high density scatter shader - but that relies on external lighting. With emission shader the volume behaves additively resulting in incorrect depth-values (it's brighter than mesh at same depth). So there's no way to get the smoke's Z-depth other than meshifying it.


VSE: How to crop specific segment of a video?

The VSE_Transform_Tools addon does just what you're looking for.

The in-house method is to enable "Image Offset" and adjust the values in the "Image Crop" section, then reposition the cropped image using the values in the image offset area:


Blender will not import my svg in version 2.73

The SVG format can contain three types of graphic objects: vector graphics, raster graphics (bitmap images), and text. Blender's SVG importer can only deal with vectors (paths). So make sure you've traced your images as paths otherwise they will not load in Blender.
In Inkscape use main menu -> path -> trace bitmap or press shift+alt+b

Read: Why can't I import a SVG file from Adobe Illustrator or Inkscape? and Imported .svg files does not show up and Why won't Blender let me import .svg files?


Is HD7670 4GB DDR5 128 Bit compatible with Blender

The AMD Radeon HD 7670 is from the Radeon HD 7000 series and has the TeraScale 2 architecture.

Blender 2.79:

The minimum requirements for AMD GPUs, in order to run Blender, are:

  Blender 2.79 runs on all systems that support OpenGL 2.1 and above, with recent graphics drivers. For macOS, version 10.9 and later are supported.

The minimum requirements for GPU rendering with OpenCL are:

  OpenCL

  OpenCL is supported for GPU rendering with AMD graphics cards. (We only support graphics cards with GCN architecture 2.0 and above). To make sure your GPU is supported checkout this Wikipedia page.

Conclusion for Blender 2.79:

It would be possible to run Blender 2.79 with the AMD Radeon HD 7670 graphics card, however you already have an integrated GPU in the Intel i5-2400 that satisfies this requirement as well. The AMD Radeon HD 7670 does not meet the requirements for GPU rendering.

Blender 2.8x:

The minimum requirements for AMD GPUs, in order to run Blender, are:

  AMD: GCN 1st gen and newer

The minimum requirements for GPU rendering with OpenCL are:

  AMD

  OpenCL is supported for GPU rendering with AMD graphics cards. Blender supports graphics cards with GCN generation 2 and above. To make sure your GPU is supported, see the list of GCN generations with the GCN generation and supported graphics cards.

  AMD OpenCL GPU rendering is supported on Windows and Linux, but not on macOS.

Conclusion for Blender 2.8x:

The AMD Radeon HD 7670 graphics card is not supported for Blender 2.8x.

I wouldn't recommend buying the AMD Radeon HD 7670.


Under Particle Settings -> Source enable the check mark Use Modifier Stack


How to apply a bevel modifier, so that it affects only specific edges?

You can use bevel weights, which lets you specify a value between 0 (no bevel) and 1 (full bevel).


Well, I finally found what goes wrong. It's simply due to the particle settings: I checked "B-spline" in the "render" section, which interpolate hairs shape using B-spline, and induce a shift between the root vertice of hair and its actual rendered root.

I thought using this setting be useful to have smooth shaped hairs, but in fact using "Curve segment primitive" (Cycles Hair Rendering panel) is sufficient and works great !


Final:

You can achieve pretty good effect with Soft Body. I don't know exactly what you want to achieve, but as for deforming skin in general this should be ok.

Mesh:

Default Sphere for Soft Body and Collision. Subdivision Surface is added after (!) Soft Body.

Soft Body:

For Goal you should select Vertex Group marked in previous screenshot or you can even paint Weight for this to mark which part should be affected.

Most important thing is to select Stiff Quads and set Bending > 0.5


Why is my 2D animation grey in video editing tab?

In the Properties panel of the strip, under the View tab > Scene Strip Display, you can select Shading: Material Preview or Rendered. That will show you the original colors.


2.8: How to texture paint some elements of mesh only?

You can make use of the Face Select Mask setting to limit the effect of your texture paint to selected faces in Texture paint mode.
First image is the basic setup in Texture Paint.

Second image is turning on the Face Select Mask and making a selection on the model.

Third image shows a result with two areas painted, one selection active.


Do I need to save the file so that I could edit my video sequence again?

Yes, you need to save your blend file through the file menu, then save. Blender has asked you to do so at least when you want to quit the program. When you didn't save that as well, your cutting work is lost and you have to start all over again...

The blend file contains all the sequences you put in the VSE. And the video footage itself needs to stay on your file system as well (at least relatively to your blend file, there are options to use no absolute paths).

So when you want to keep working on your cuts just open the blend file again and then switch to the VSE view if needed.

You will have everything explained in detail in the very helpful tutorial from Mikeycal Meyers on YouTube btw...


How to make plane tracked video start compositing from a certain frame?

I found it out:
I fixed it by looking at this post (How can I make a "Movie Clip" node start at a certain frame of the scene?). I replaced the "movie clip' nodes for "image" nodes, and put the background video at "Start from 1910, and Offset 1910". Then I offset the composited video to 1910 frames. Voila!
I had to scrub through the timeline to check that it was precisely matched. I rendered a smaller sequence once to check through it, and then returned to the project to "finely" adjust it down to each frame.
Stackexchange is a wonder, really :O


python - How to color accurately convert from rgb 0-255 format to values in 0.0f-1.0f

Hex colors are in sRGB. You need linear colors. The conversion is (from here)
def color_srgb_to_scene_linear(c):
    if c < 0.04045:
        return 0.0 if c < 0.0 else c * (1.0 / 12.92)
    else:
        return ((c + 0.055) * (1.0 / 1.055)) ** 2.4

print(color_srgb_to_scene_linear(13/255))  # => 0.00402
print(color_srgb_to_scene_linear(105/255)) # => 0.14126
print(color_srgb_to_scene_linear(171/255)) # => 0.40724


Often I find that view camera affects my painting as well. – Craig D Jones

It's my problem, I have disabled the "Norm" option  and now I can paint everywhere. This option is located in the left panel of 3D View in texture paint mode (show with T) > Option tab > Paint by projection > Normal

Uncheck it and  nowyou can paint on faces at 180° of the view...


Can't find the "Reassign loop parameter" node in animation nodes addon

This is not a node you can directly invoke with the SHIFT + A submenu. Here is how to do it :

Create your loop and click it to select it
Assign a parameter
Go to the right-side panel (shortcut N, or click on the arrow on the right side of the animation nodes node tree)
Go to the "Node" subpanel
Click on the "Reassign" button next to the parameter socket
Click in the node tree window where you want to place the "reassign" node

If you want to have the "Condition" boolean operator in the node, you should :

Select the "Reassign" node
Go to the "Item" subpanel on the right
Turn on the computer screen icon next to the "Condition" input socket.

This works for all the animation nodes which may have hidden input/output sockets


One way is to select bottom most and top most rim (edge loop) and make them seams. Then switch to face select, select one of external faces on the body and CTRL+L to select linked (it won't work in edge or vertex select modes). This way you will have selected only external geometry. Then you can press CTRL+I to reverse selection and delete faces.
It won't work though if inner geometry is linked somewhere else then on top and bottom with external geometry. If that's the case, the best way would be select face loops one by one with ALT+SHIFT+right click.  After all external faces would be selected, CTRL+I and delete.


Prevent particles from intersecting with a mesh used as a container

Particles are probably not gonna cut it alone, I'm afraid. I'd go with a rigid body simulation to make it work.

Add a temporary mesh roughly shaped as the final distribution of the stones, but add it some walls to confine falling stones as below.

Turn you stones placed above said object into Rigid Body Active, and the container as Rigid Body Passive.

Adjust details as necessary, in the end remove or hide the container mesh.


Render animation zooms in rendered video?

Checking the rendering was the same resolution size as the original footage and adding 'Frame All Fit' (on the Render page under 'view') dealt with this issue. Hope this helps :D


How to merge two bones into one with preserved weights in Blender 2.9

I managed to fix my skeleton by using Vertex Weight Mix modifier.
Simply:
A=bone which should stay |
B=the other one |
Vertex set=All |
Mix mode=Add
+2nd modif for other leg and apply both
Now disconnect bones to prevent its shifting during dissolving (simply uncheck connected checkbox in edit mode)
And finally dissolve additional bone with Ctrl + X


In the second comment to my answer to the question you refer to, I mentioned having to update dependencies for the driver. This seems to be a manual step we need to perform when adding drivers to nodes.

You can find the driver details in the graph editor in driver display mode. With the driven value selected you need to click the Update Dependencies button and you should then find the node value will be updated properly.

Also ensure that you have enabled auto-run python scripts.

While work is being done on the new dependency graph it may be a good time to report this as a bug so that the developers can look into improving this.


No Sound for separate audio file Blender Video Editor

m.ardito hinted that the audio files might be corrupted, and apparently they were. Don't know how on a simple copy paste but it happened. So deleting the audio files and replacing them solved the issue.


how do I copy fluid physics from one object to several

An option that is available for many settings, not just fluid settings, is to right click  on the value and choose Copy To Selected. This will copy the value from the active object to all selected objects.


Can I reuse a character to multiple characters in one scene with the link feature?

AFAIK it's a limitation of Blender. And it will be fixed for 2.8 if I'm not mistaking.

EDIT: and I'm not.


Insert keyframe on an object's custom property with Python

Keyframes on custom properties use Python's getitem/setitem syntax rather then getattr/setattr.

This matches python api, where you would access object.location as an attribute and object["prop"] for a custom property.

So you would need to write it like this:

object.keyframe_insert(data_path='["prop"]')

Note that you have to use " quotes, not ','["prop"]' can be written as "[\"prop\"]" too of course.

I think we have this documented, I'll have to double check though.


Using python to create cuboid with a hole in the centre

Using from_pydata

Make  an inner and outer square of vertices for top and bottom.  Fill top  with  4 trapezium faces.   All other face indexes can be calculated from the top faces by adding appropriate index offset to them.

import bpy
from mathutils import Vector
context = bpy.context

scene = context.scene
mesh = bpy.data.meshes.new("mesh")
# 2d square
def xysquare2d(z=0, scale=1):
    r = [-scale, scale]
    return [Vector((x, y, z)) for x in r for y in r]

verts = []
# top verts
verts.extend(xysquare2d(z=2, scale=2))
verts.extend(xysquare2d(z=2))
# bottom verts
verts.extend(xysquare2d(z=-2))
verts.extend(xysquare2d(z=-2, scale=2))
top_faces = [(0, 1, 5, 4),
         (1, 3, 7, 5),
         (3, 2, 6, 7),
         (2, 0, 4, 6)]
# make all the other faces from top faces
bottom_faces = [(i + 8, j + 8, k + 8, l + 8) for i, j, k, l in top_faces]
outer_faces =  [(i, j, k + 8, l + 8) for i, j, k, l in top_faces]
inner_faces =  [(i + 8, j + 8, k, l) for i, j, k, l in top_faces]
# add them
faces = top_faces  + bottom_faces + outer_faces + inner_faces

mesh.from_pydata(verts, [], faces)
obj = bpy.data.objects.new("obj", mesh)
scene.objects.link(obj)

Can create pydata from a mesh.
Make the model, then run this script on the mesh.

print("verts = [")
for v in mesh.vertices:
    print("\t", [axis for axis in v.co], ",")
print("\t]")
print("faces = [")
for f in mesh.polygons:
    print("\t", [i for i in f.vertices], ",")
print("\t]")

Which when run on mesh created above results in

verts = [
     [-2.0, -2.0, 2.0] ,
     [-2.0, 2.0, 2.0] ,
     [2.0, -2.0, 2.0] ,
     ....
     [2.0, 2.0, -2.0] ,
    ]
faces = [
     [0, 1, 5, 4] ,
     [1, 3, 7, 5] ,
     ....
     [10, 8, 4, 6] ,
    ]

Using boolean modifier

If you don't mind ngons, can use boolean difference, append this script to your original

# copy the mesh
grat2obj = grat1obj.copy()
grat2obj.data = grat1mesh.copy()
scene.objects.link(grat2obj)
# move it up 1, 1
grat2obj.location += Vector((-0.5, 1.25, 1.25))
# scale it
grat2obj.scale = (2, 0.5, 0.5)

# add a boolean modifier
bm = grat1obj.modifiers.new("Chop", 'BOOLEAN')
bm.object = grat2obj
bm.operation = 'DIFFERENCE'
# apply the modifier
scene.objects.active = grat1obj
bpy.ops.object.modifier_apply(modifier=bm.name)
# remove chopper
scene.objects.unlink(grat2obj)

Using bmesh

Add a plane, inset it, remove middle face, solidify.

import bpy
import bmesh
mesh = bpy.context.object.data
bm = bmesh.new()
bmesh.ops.create_grid(bm,
                      x_segments=2,
                      y_segments=2,
                      size=1)

bmesh.ops.inset_individual(bm, faces=bm.faces, thickness=0.3)
# take out middle
[bm.faces.remove(f) for f in bm.faces if all(not e.is_boundary for e in f.edges)]
# extrude
bmesh.ops.solidify(bm, geom=bm.faces, thickness=1)
bm.to_mesh(mesh)
mesh.update()


How to align two curved surfaces of the same object?

The Shrinkwrap modifier has an 'Offset' setting. If you make one of the surfaces the Shrinkwrap target of the other, projected along target surface normals, with an offset, would that do the trick?


Why my exported UV map is different in size?

Don't use EPS to transfer UV maps - it only exports the occupied area.
Use SVG instead, it exports the whole UV canvas.


You can get access to the file browser in Blender by using the StringProperty with the subtype "FILE_PATH". As documented here. And example of using this would be

file_path = StringProperty(name = "File", subtype = "FILE_PATH")

Then you can just use file_path like this:

bpy.data.images.load(file_path) #most of the time you will have to do self.file_path

If you need to use that image elsewhere just set all that equal to a variable.


Confused about requirements for rendering

Im not 100% sure on this but you can try CUDA and check only your GPU (or both if you want). As far as I know, blender requires GCN generation 2 and up. Im not sure if that is the number you're referencing, but I would try CUDA first.


I guess you mean the way to change parent of a bone:


Add a panoramic background to scene in Cycles

If your image is an equirectangular projection, you can use the Environment texture node within the World space node editor (see red markup), with Equirectangular projection type (second setting) :

The yellowed area in this image correspond to optional nodes you can add to control the position of the background if you have already set the objects and camera's position, and don't want to move them again.


How to grab individual vertex in UV editor?

You can disable “Sticky Selection” mode in the dropdown menu to the right of the vertex/edge/face select boxes


In Blender is a default setting that 3D cursor keybind is LMB. In that case, you can select objects by RMB. You can easily switch these two in the settings.


i to inset then B for boundary (option also available in the bottom of the Tools panel on the left of the 3D View). By the way, is it not a Penfinity video?   ;)


How to place and merge meshes upon another one (and then delete them)

You could do it with some cuttings, duplicate and snaps, but maybe the simplest ways is to use the Knife Project tool:

Separate your 3 faces with P (Separate) > Selection. Now your 3 faces are a separate object.
Select this object, then the main object, and go in Edit mode
Switch to Ortho Front View.
In the Tools panel, click on the Knife Project button. You've created 3 faces. You can delete the faces in order to create doors.
You may want to use the knife with Z (cut through) and C (cut orthogonally) options activated to create additional edge loops.


Many thanks to Rich for helping me solve this!

I created a single edge at the length I wanted my string/rope. I then subdivided it till I saw fit (will not look choppy).

Create three vertex groups:
  One for one end, one for another, and one with both (in my case
  pin_Float, pin_Floor and pin_Ends)

In turn, click on each control object and hook to the specified ends (not the double ended one ;) )

Add a soft body to your string and set 'default' and 'stiffness' under the 'Soft Body Goal' to max. Then underneath assign the vertex group with both ends to 'Vertex Group'

Play and adjust the settings under 'Soft Body Edges' until the rope moves as required

I also applied 'Soft Body Self Collision' and a Skin modifier

The Rigidbody and Collision physics can also be applied making it very easy to use.

Again, thanks to @Rich Sedman for his help.


The reason meshes are different is that darker mesh doesn't have Material assigned to it and brighter one has.


Character bone not bending after adding pole target

Make sure your knee joint is not straight like this.

Instead, make it bent a little and all will be well. Just like in the image below.


This may be a naive answer, I'm no coder, but is there anything wrong with letting BMLoop.is_convex do this for you?
(Starting from Edit Mode):
import bpy
import bmesh

obj = bpy.context.edit_object
me = obj.data

bm = bmesh.from_edit_mesh(me)
bm.faces.active = None

for face in bm.faces:
    face.select_set(False)
    for loop in face.loops:
        if not loop.is_convex:
            face.select_set(True)
            break

bmesh.update_edit_mesh(me, False)


Blender is not displaying anything when startup

Have you just moved the blender App folder to the new PC. Some settings might be needed in registry, so if you just moved the folder I would suggest a install of 2.79 from https://www.blender.org/download/previous-versions/


Can't get procedural displacement to work at all

The property you need to change is rather hidden in the UI unfortunately. Blender allows you to change the behavior of Displacement vector inputs per material. So as a result, there is a dropdown box in the Materials tab in the Properties Editor, under Settings -> Surface -> Displacement:

By default that will be set to Bump Only. Change it either to Displacement - which will displace the geometry - or Displacement and Bump, which will first displace the geometry and then apply the same texture as a bump map on top of that. Result looks like this in your file:

Second, in case you want to go really high with the level of detail, you'll need to enable the Experiental feature set to get Adaptive tessellation. Adaptive tessellation (sometimes called Microdisplacement) will give you more geometric details in areas when needed. Here's where to enable it first:

And here is the checkbox that needs to be enabled in each SubSurf modifier where you want adaptive displacement to kick in:

If you now render, you can see that the detail is a lot smoother, simply because now there are far more triangles in the mesh than before to capture the displacement detail:


Proportionally increasing the width of a curved line

There are many ways to do this, but one that springs to mind is to construct your curve with a Curve modifier deformation, either of a long, thin plane subdivided along its length, or an array of smaller face-planes, merged in the Array modifier.

Then the curve's 'Radius' becomes available for adjustment. With Proprtional Editing, set to 'Connected Only', you can select one end or the other of the curve, with an appropriate falloff profile and size,  AltS scale the radius of the curve progressively from one end to the other.


Join two parts of object faces to match shadow

Try set shading flat and set it back to smooth.


Animating the development of an organic structure

Q: How to morph mesh shapes with different amount of vertices?

A: There is not an efficient way in Blender to animate mesh with varying topology (from what I know).

Blender is able to generate this kind of data as export of fluid sim or metaballs into Alembic (.abc) format. This format can be also imported back into Blender. A bit of setup can be found under Modifier tab - Mesh Sequence Cache (see Manual). But in general - you can transform only on object level (Loc/Rot/Scale or use modifiers on top of this format).

Like a hack of your proposal I tried to animate sculpted object with shapekey. When topology become to its limit I duplicate the object and continue to sculpting with dyntopo on specific part. It worked in kind of, but its was so painfull with pour result.

Q: How to animate growing an organic structure

A: You can try - Particles with Metaballs growing by gradient texture.
In this sample I used just a tree structure (addon Sapling), but you can model gland by your self (or some cool script probably exists for this kind of structure).

add MetaBall object (for later use)
create some gland structure (edges only)
subdivide edges evenly into dense vertex mesh

Particle System

add Particle System to this object with option Render as Object
as object select MetaBall
set a number of particles the same as amount of gland vertices
(it can be found in edit mode in bottom row)
you would have to set particles Velocity to zero and disable Gravity under Scene properties to stop particles to move

Animation

animation is done by illusion - particles scaled in time
particle scale is controlled by Particles > Texture
add new Texture and go to Texture properties
set Blend > Spherical, Influence > Size > enable, Mapping > Object
(You can animate size directly in this panel, but its more flexible use another object. I added Empty into scene.)
additionaly you can enable Colors > Color Ramp to adjust appearence of size in time, so it will looks like growing thickness

It has its limits to animate by texture, but you can probably get some more variations by adding another Particle Texture to "break" spherical growing shape (I didnt try that).


Using CHIP cluster to make a render farm?

Short answer: If you can get Blender to compile on it, you might be able to get CPU rendering. GPU rendering is not going to happen (the Mali 400 doesn't have a compute pipeline to support OpenCL or CUDA).

Will it be a cost effective alternative to a "real" render farm? Not likely.


In object mode select the object with RMB and Ctrl A to apply (object/apply/scale)..then go to edit mode press u to unwrap..i have same issue before and this tips solve mine..i wish it helps you as well..


eye target controller is not visible in CG Cookie Flex Rig

Mine is visible, try to check the "hide" button or download the file from another site.


How to randomize window lighting on skyscrapers without separating each window into a separate object?

Assuming your windows are fairly regularly spaced you can separate the individual 'windows' in the window material by using a Modulo function to convert each of the X,Y,Z Object coordinates into a 'stepped' function. This separates the surface into individual 'cells'. By carefully setting the spacing of the 'cells' (the Modulo functions) to match the positions of the windows you can ensure each 'window' has a consistent solid illumination.

The 'stepped' coordinates are then randomized via a Noise texture and Greater Than used to illuminate only those above a threshold (higher threshold results in fewer 'lit' windows).

Further combine the Object Info 'Random' property into the coordinates (multiplied by a suitable amount so as to make the different objects wildly different) and you have random 'cells' per "building".

This produces the following material :

With the following result (this is showing the 'lights' only - obviously the surrounding building needs to also be included in your final mesh) :

Note : Don't forget to Apply Scale so that the lighting 'cells' are the same dimensions over each object.

For less regularly spaced 'windows' you will need to adjust the Maths nodes to produce the required arrangement of 'window cells'.

There is another way, borrowing a technique used in Per face vertex coloring - essentially to create a UV map where each face is represented by only one pixel in the image. This UV map can then be used as coordinates in the noise texture used to determine whether each 'window' is illuminated.

There are two ways of achieving this :

Using a script

Paste the following script into a Text Editor window :

# Run this script to generate a UV map and Image with 1 pixel per face so each face has a single colour.

import bpy
import bmesh
import math

# Get selected/active object
obj = bpy.context.object
obj.update_from_editmode()
bpy.ops.object.mode_set(mode='EDIT')
bm = bmesh.from_edit_mesh(obj.data)

# Get count of faces
num_faces = len(bm.faces)

# Create UV map
obj.data.uv_textures.new("facepixels_"+str(num_faces))
uv_layer = bm.loops.layers.uv[0]
bm.faces.layers.tex.verify()

# Process each face and position each loop vertex around the centre point
faceidx = -1
for f in bm.faces:
    faceidx = faceidx + 1
    loopidx = -1
    numverts = len(f.loops)
    for l in f.loops:
        loopidx = loopidx + 1
        luv = l[uv_layer]
        luv.uv[0] = float(faceidx)
        luv.uv[1] = 0.5

Select your 'windows' object (with one face per window) and click 'Run Script'. This will generate a new UV map with 1 pixel per face.

Manually

Unwrap the 'windows' mesh using 'Lightmap pack'.

Then in the UV Editor select all the faces, ensure 'Individual Origins' transformation mode is set and scale to zero (Select all (A) then scale to zero with S0Enter). This should produce the following result :

Note how each face has become a single point in the UV.

You can now use the UV Map (whether created manually or via the above unwrapping method) in the following material :

The Add and Multiply adjust the 'Random' object info value to adjust the noise for each separate mesh (building) - you can adjust those to get different random patterns. Adjust the Greater Than node to affect the threshold for which windows are illuminated for more/fewer lights.


Joining the meshes of two previously separated objects

The problem is the precision. If the meshes don't align perfectly you need to increase the Merge Distance for the Remove Doubles tool. Also make sure you select everything before you use it.


Copy rotation does not always rotates correctly

It always works correctly.  It does not always work like you'd expect.  The differences are basically down to how Euler angles operate, especially in conjunction with constraints.
So when you copy rotation, here's what it does:

It decomposes your target bone's orientation into XYZ Euler triplets.  These are not necessarily or even likely to be the same XYZ triplets you keyframed for that bone.  That is because Euler angles are aliased: there is more than one set of Euler angles that corresponds to any particular orientation.  But in order to accommodate space-switching, we have to get only a single set of numbers out, so there's some information that's lost.

If you want to see what these anti-aliased (not a good thing in this case) numbers are, you can duplicate the control bone, give it a copy transforms constraint targeting the original, and then apply visual transform (or bake animation.)  You will see that the transforms you get are probably not the ones you expected.

We multiply the components of that triplet by the influence of the constraint, and then rotate the constrained bone with it.  Changing influence does not give you rotation along a plane-- rotation in a single axis.  That is, there's torque.  That's because Euler angle rotation doesn't interpolate in a straight line.

Those two things combined mean that copy rotation, particularly at influence <1.0, particularly for 2-axis copy rotation, doesn't work like people intuit it ought to.  Copy rotation is part of a set (with limit rotation) of the least intuitive constraints, because of how people think about 3D angles working, and the differences between that and how they actually work.
If only the first thing is a problem, you could consider using a driver instead of a constraint.  If you don't need space switching, drivers can let you work on raw, no-lost-data f-curve numbers.
However, what I'd generally say is, try to find a different way to do what you want.  Copying rotation of 3 axes, at influence 1.0, is perfectly safe.  Damped tracking and locked tracking with influence less than 1.0 is safe, and operates in the "swing angle" (smallest rotation) rather than with any torque.  One way that should get you what you want is to copy all rotation fully, and then restore a part of it by damped and locked tracking non-deforming marker bones.  That may be more complicated than what you actually need though.


Texture Rendering Black, but shows up in textured view

Your issue is that you don't have any lamps in your scene.

To add a lamp, you can press SHIFTA to go to the add menu. Then go to lamp drop down, and select point. This will add a point light which casts light in all directions. After you add your light, just position it until it lights your sword well.


After importing image as plane the image is not shown, it is just a gray plane

Image as Plane doesn't work like Reference or Background images, if you want to see it in Solid mode you need to activate the Texture option:


In short, start from a cube. (in the gif I have a mirror modifier to save time)
Delete the bottom face.
Add loop cuts for the rounded top.
Position the top correctly, by simply G grabing, and R rotating and S sclaing the top geometry.
Use proportional editing O to create the dip in the top.
CtrlB to bevel the vertical sides.
(optional) Remove the Ngons in the top, that beveling the sides created.
Bevel the top ridge to make it smother and more realistic.


The denoising controls for the Cycles render engine are in the Scene Panel:

Denoising is not available for blender internal

Just in case, for 2.8 the denoiser is in the view layer section of the dat properties editor:


Does Cycles' GPU support Intel HD Graphics 3000?

It will most certainly not work (ever). Refer to this page: https://wiki.blender.org/index.php/OpenCL
GPU on Apple products is a huge issue. Not even the extremely expensive mac pros come equipped with decent GPUs. So if you want to use CUDA etc... you're better off buying a laptop with a good nvidia GPU (You can run linux on it if you don't like windows (that's what I do)).


How do you transfer weight paint in blender 2.8

As of the stable release of 2.80, Transfer Weight option is consolidated into Transfer Mesh Data, and now located under Object > Relations > Transfer Mesh Data. This option is already available in Object Mode, no need to enter Weight Mode and accidentally paint a weight data in the process.

However, the selection order for the Transfer Weight is somehow reversed. So, instead of transferring weight from the first selection to second selection, it's actually vice versa in 2.80 - the tool transfers weight from the second selection to the first selection.


Why are there dotted lines in wireframe in 2.8?

Perhaps this is will help :

Object mode > Overlays > change the Wireframe value from the default 0.5 to 1.0.

and toggle the Show whole scene transparent button:


An object is not showing in the rendered result

You need to check Show Emitter through
Particle settings > Render > Show Emitter


Weird geometry when using Mirror + skin modifiers

Skin Modifier is generating the geometry from the root vertex (marked with dashed circle around it), and if its not on the mirror axis that will generate mesh errors.

To fix that select the vertex of the groin area and in Skin Modifier click Mark Root.


Select the object in the 3D window ; key in r,x,30    to rotate 30 deg about the x-axis ; Visit the info window to see and copy/paste the equivalent python code.
I forgot which is local and which is global, i.e. experiment with r,x,30 or r,x,x,30
Note also the use of degrees with the keyboard, but radians in the script:
bpy.ops.transform.rotate(value=pi/6, orient_axis='Z',\ orient_type='LOCAL') verified with Blender 2.8
We have left off the numerous optional arguments in this example


Figured it out! None of the answers I found on SE worked for me. Here are the links I looked at:

How to rotate object along path path
Mesh gets deformed when an array of spheres deformed along a curve :(
How do I prevent object distortion when applying a curve modifier?

Here are the instructions that worked for me:

https://www.blender.org/manual/editors/3dview/object/properties/duplication/dupliframes.html

Dupliframes to the rescue!


Why does one object cut through and show in another object?

I don't see a huge problem, but I can understand that you want to get rid of it. When you have proportional editing enabled,, snapping only has an effect on the selected vertices, not on the ones being dragged along. Also snapping only works if you use g or the widget to move your vertices. If you want your freshly extruded faces to snap to your topology, release them from extrude move mode and use the tools to move them.


Moving an object along two axes instead of one

If you press G > Shift+Z you can move bi-directional in x-y direction.

You can do that also using manipulator - click on the white circle around manipulator's origin and press Shift+Z as in the first case.


How to import uv animation from blender to unity?

I don’t think this is possible at all on Unity, not in the way Blender allows it with AnimAll (very quick search brings solutions based on scripting, in Unity).

In any case, there is for sure absolutely no standard way to directly export UVMap animation from Blender, FBX does not support such feature afaik, and it’s one of the most advanced and best supported exchange format (Collada does not support this either, see this post…).


Here is a direct download link for the script. It was in the description of the demo… there is also a small youtube playlist dedicated to it and the rig used is available on BlendSwap.


Checkered texture layer after applying boolean modifier to join 2 meshes

When you use a boolean, and then apply it, it's actually changing the geometry to join the two shapes. There's no way to change geometry that already has UV maps without also altering the UVs. So you've altered the UVs when joining the shapes. Also, Blender decides which of two shapes will inherit altered properties from the other based on selection order. The most recent item added to a selection of more than one object is always the active object, which will always be the one that property transfers are made from, with all the remaining items in the selection being the recipients of the transfer.

Two separate cubes, each with a different material. Their UV maps are shown to the left. While each UV map has exactly the same layout for both cubes in this scene, those UV maps don't exist in the same UV space because the cubes are currently separate objects. What is shown here is for illustration purposes, but not normally how the maps appear for objects, as neither of these objects are currently in Edit Mode. Normally, an object must have its parts selected in Edit Mode before its UV map will be shown in the UV Editor window.

This is the same two cubes after applying a boolean join operation in which the original red cube was added to the selection last. That is why the new cube is now red, because it inherits its material properties from the active object. If the white cube had been selected last, both cubes would be white instead. Notice that the old UV arrangement is now destroyed. This would be the case after performing this operation regardless of selection order. This is a consequence of applying the boolean modifier, which moves the modified result from a non-destructive outcome to a destructive one.

As a good workflow practice, it isn't recommended that you do booleans after getting your materials and UVs set up the way you want. Boolean operations are a part of the modeling phase, and should probably be kept there.


Is it possible to create a path from an existing object animation?

Would the BTracer Addon work for you?

It creates a bezier curve object from any animation by tracing an object, mesh vertex or particle motion path through the scene space for every frame.

Have in mind that it doesn't convert the animation for you it only traces and creates a curve object from it. You may then manually rebuild your animation to use this path, although some transformations may be lost or not translate completely as expected, like rotations.

EDIT

Select your animated object, and in 3D View > Tool Shelf > Misc Tab > BTrace Panel you will find all the settings you need.

Choose the Mesh Follow option
Expand the Settings button
Choose Object option to trace the object center.
You can also set the step size so there is less than a vertex per frame, although it probably comes at the cost of accuracy
Press the Curve Settings button bellow
Choose the desired Bezier curve interpolation (you can change here the type of handle from vector to aligned or auto)

In the end if there are too may vertex maybe you can clean up a bit with the Simplify Curves addon (in Blender by default), though again probably at the cost of accuracy.

Now I am not much into animation so I am not sure how this may go, maybe someone else more experienced as a better workflow but:

You can then either clear the animation of your object and parent it to the curve and use the Properties Window > Object Data > Path Animation for the curve object;
Or clear the animation of your object and use a Properties Window > Constraints > Relationship > Follow Path and pick your curve.

Not sure which one is best.


How can I reassign or move vertexes of a vertex group

tuples are read only you cant reasign its value.
try to use to_list() instead... i think.
[list(vert) for vert in  vertstarg]
then seems like you are doing nothing to your verts but selecting

grab the header bar down (the file menu) to see some info from operators. or go to de scripting window, there is on the top also.
almost every thing you do inside blender is shown on that "console"
see https://www.youtube.com/watch?v=2j75AM1Mttc


You could make 2 planes. One with a displace texture and subsurf modifiers applied.

On the other plane add subsurf and a boolean modifiers to receive the displace mesh as a hole cutter.

Boolean modifier will need a large amount of subsurf to get clean holes, but you could use a decimate modifier and smooth modifier to relax the mesh and reduce the vertices count.

Here I have also added a solidify modifier to make the plane thick.


Nontransparent patches rendered transparent in Cycles?

Your planes are touching, Cycles can't figure out which is in front of what.

You have overlapping planes with or coinciding geometry in your scene.

Organize your blend file, be thorough move them apart in Z direction a consistent amount of units.


It can be achieved by baking the height of a mesh.

Before you start, make sure that the origin of the object is beneath or at the lowest point of the mesh, preferably the latter. Negative values do not go well with images.
Go to the UV/Image Editor and create a new image

Go to the 3D view, select your mesh, go to edit mode, select all vertices with A, go to orthographic view by pressing numpad 5 and top view by pressing numpad 7.
Press U and click Project From View (Bounds)

Go back to Object Mode, go to the node editor add a new material for the mesh. Add a Texture Coordinate node, a Separate XYZ node and a Math node. Connect the Object output from the Texture Coordinate node to the Vector input of the Separate XYZ node, the Z output of the Separate XYZ node to the upper input of the Math node and the output of the Math node to the Color input of the Diffuse node. Change the operation mode of the Math node to Power and the bottom value to 2.

Add an Image Texture node, select the just created image in it, but do not connect it to any other node.

The Node Editor should look like this:

Make sure you have the Image Texture node selected, go in the Properties Panel to the Render tab. Go to the Bake options, change Bake Type to Diffuse Color and click Bake.

You can now find the height map in the UV/Image Editor by selecting the image you created at the start. Do not forget to save the height map by pressing F3.

Note that this method is not perfect, a mesh created using this height map will not be completely identical to the original mesh.


Most efficient way to create these hairs

Just a thought, but could you model one bunch of strands with maybe a cluster of image planes, get that bunch to look correct, and then apply it as the render object for a particle hair system?


How to make 3D LUTs and use them in Blender?

Given that Cegaton has dropped 500 on this, it would seem the right place to give a little more fleshing out than a typical post. What follows is a (hopefully) exhaustive and explanatory answer to the question. While it might look daunting, brevity has been sacrificed to clarity. The actual process is much simpler than it appears here, but it is hoped that the explanation that follows will help more imagers explore creative colour transformations in their work, as well as enable some to extend this well beyond 3D LUTs.
What is a LUT?
LUT is merely an acronym for Look Up Table. The term is also used colloquially to refer to a technique to apply creative looks to footage, as well as the more scientific / mathematical needs of transforming colour spaces. LUTs can be generated off of mathematical functions that are sampled at intervals, or by using tools to extract changes in images.
What is the difference between a 1D LUT and a 3D LUT?
A 1D LUT at its most basic level is a pure single input to single output transform. Transfer functions such as sRGB's OETF / EOTF and other such decodes / encodes are delivered almost exclusively via 1D LUTs. There are also multi-channel 1D LUTs, where each channel can get back a unique value based on its input, or generic single channel 1D LUTs where all channels receive the same output value given identical input values.
In the following simple single channel 1D LUT, the input value is incremented by 0.1:
# Below is a simple 1D LUT, where a single input value is
# mapped to a single output value. In the case of an RGB
# triplet, each R, G, and B value would be mapped individually
# via the lookup table.
# IN    OUT
  0.0   0.1
  0.1   0.2
  0.2   0.3
...

In the following simple 1D triple channel LUT, the single input value determines the output based on whatever channel is fed. In this case, it increments the assumed red channel by 0.1, the green channel by 0.2, and the blue channel by 0.3:
# Below is a simple 1D by 3 LUT, where a single input value is
# mapped to a single output value. In the case of an RGB
# triplet, each R, G, and B value would be looked up identically
# via the first column, but return a different value based on the
# output column.
# IN    OUT_R OUT_G OUT_B
  0.0   0.1   0.2   0.3
  0.1   0.2   0.3   0.4
  0.2   0.3   0.4   0.5
...

A 3D LUT on the other hand is a much more complex creature. Under a 3D LUT, the unique fingerprint of the three input channels forms a triplet that delivers a unique set of three values back. How is this different than a 1D single or multi-channel LUT? Given that the fingerprint of the input channels is unique, and that you receive three unique values back, a 3D LUT can be used to allow a single channel to adjust the other two channels, where 1D LUTs only change the input value given. This unique characteristic of 3D LUTs, the ability for a single channel to adjust other channels, is the reason that only a 3D LUT can adjust the saturation intents of a given image.
The following 3D LUT raises up all three channels as the green channel value reaches the peak of the cube. Here, the first three values represent the input combination, and the following three represent the output combination:
# Below is a simple 3D LUT exerpt, where a unique combination
# of three input values is mapped to a unique combination of
# three output values as a whole set. Input three values, get back
# three values. The numbers on the input side represent values that
# are scaled from zero to the cube size minus one. Being scaled in
# this fashion, care must be taken to make sure that the input values
# are properly mapped to the 0.0 to 1.0 range that the LUT operates
# on.
# IN_R IN_G IN_B OUT_R    OUT_G    OUT_B
...
  0    0    60   0.544367 0.544367 0.9375
  0    0    61   0.635998 0.635998 0.953125
  0    0    62   0.74127  0.74127  0.96875
  0    0    63   0.86195  0.86195  0.984375
  0    0    64   1        1        1
...

How large are the range of values in a LUT?
LUTs operate on an arbitrary range of values that are typically defined within the LUT format itself. In the case of a 1D LUT, it holds one line for each input and output, and as a result can be quite large. Typically 1D LUTs of 4096 values will deliver very accurate results using a simple linear interpolation assuming the “direction” of the transform is technically feasible. Some “directions” suffer breakage when the LUT resolution is not large enough to express the shape properly.
3D LUTs on the other hand, because they represent a combination of three values, are defined using what is known as a cube size. A cube size determines how many steps there are in the combinations. Cube sizes vary from older 17x17x17 cubes to more contemporary 65x65x65 cubes.
The cube size is the number of values that the range will increment before incrementing the next value in the entire series. This means that a cube size of 3 would iterate three times for each channel, until each channel went through the cycle. Note how the first three columns increment, while the following three columns represent the output values. In the case of this example, the 3D LUT is an identity LUT, which simply passes the exact same input values to output:
# Below is a simple 3D LUT exerpt, where a unique combination
# of three input values is mapped to a unique combination of
# three output values as a whole set. Input three values, get back
# three values.
# IN_R IN_G IN_B OUT_R OUT_G OUT_B
  0    0    0    0     0     0
  0    0    1    0     0     1
  0    0    2    0     0     2
  0    1    0    0     1     0
  0    1    1    0     1     1
  0    1    2    0     1     2
  0    2    0    0     2     0
  0    2    1    0     2     1
  0    2    2    0     2     2
...

This means that your final number of entries is equal to the dimensions cubed. In the case of a 65 sized cube, that would be 65^3, or 274625 entries.
If a LUT operates on a bounded range, how are the other values determined?
Given that both 1D and 3D LUTs operate on bounded ranges, interpolation, or sampling, is used to determine the quality and accuracy of the values between values. In the case of a 3D LUT, the interpolation technique can be extremely important for visual quality.
How do colour transforms factor into LUTs?
Standard 1D LUTs are commonly used to perform colour transforms along intensity, also known as transfer curves. This can take many forms such as sRGB's OETF / EOTF, REC.709's OETF / EOTF, BT.1886's viewing EOTF, one of the many logarithmic transfer curve encodings, ACES encodings, etc. A 1D LUT is well suited for such application given that many of the transfer curves are piecewise functions and no simple power law will accurately describe them.
3D LUTs require special attention given their uniquely bounded constraints. Given that a 3D LUT represents an arbitrary range, care must be taken to make sure that the range maps the range within our image. This is especially important given visual effects, motion picture, or animation work, as the data is almost exclusively scene referred. Scene referred imagery from cameras or CGI represents a very large range that is mapped to the much smaller gamut of an output device domain, extending from an extremely low value to a theoretically infinitely large value. As a result, there is no one-size-fits-all approach for 3D LUT application, and care must be taken on input and output.
3D LUTs are used in some cases to change the actual colour space primaries of a given encode. Here again, it is critical that the inputs fed to such a LUT are carefully crafted.
The bottom line is that one should never use a transform unless they are absolutely certain that the LUT in question was designed for the input imagery fed. The same caveat applies to output, as a transformed image is applicable only to a single set of output contexts.
Be aware and be careful.
How are 1D or 3D LUTs created?
How a 1D or 3D LUT is created depends on the context of usage. A 1D LUT representing a transfer function can be created using a spreadsheet or scripting language, properly formatting a function or algorithm to a specific LUT format.
3D LUTs frequently are used to take a crafted look from one series of images or a shot, and apply it equally across to other images in another series or set of shots. To achieve this, we will use a reference image that our tool will understand, apply our look to it, and calculate the 3D LUT based on the differences between the two image states.
What will you need?
To generate a 3D LUT for use in Blender, you will require:

OpenColorIO . OpenColorIO has several tools that are built when you have OpenImageIO present on your system. In particular, we will be requiring ociolutimage and ocioconvert.
Given that the original question pertains to wide dynamic range filmic LUTs, you will also require the OpenColorIO configuration package that implements them. They can be found in my answer to Cegaton's original question here. If you have arrived here and are reading this without a familiarity of the concepts, it is heavily advised you read the original question and the ridiculously long answer I gave there. With that background, you should be much more well equipped to deal with the information provided in this solution.

Can you summarize the steps involved?
Loosely, we will be doing the following steps to implement custom LUTs in Blender. Note this specifically pertains to LUTs, but a similar technique can be used to apply canned ASC CDL values in your own configuration.

We will muck creatively with a sample image and arrive at a look that we are happy with.
We will generate a unique all-in-one image that is used as our reference baseline, and plug that into our look compositing chain.
We will use OpenColorIO's tools to generate the 3D LUT from the modifications.
We will plug the newly crafted 3D LUT into our configuration and make it accessible from within Blender for reuse.

1.0 Mucking
Consider the following image. Not terribly impressive, but it has been chosen because it is a scene referred image which is a smaller region of Maxime Roz's HDRI pack. Again, scene referred imagery is a range of values that extends from zero to infinity, with no notion of black nor white, and no special meaning to values such as 1.0. Cycles, being a ray tracing engine, always generates scene referred imagery, and as such, our techniques must take this into consideration. The following attached image is of course display referred, and does not have the original scene referred values. It was created using the Filmic Blender LUT set.

After countless hours of toil and sweat, the wonderfully creative output of our grading is the following. Again, because this was generated in Blender, which as a scene referred internal model, the values extend from zero to extremely high ratios such as 50.0+ outside the window. The image attached below has been manipulated in Blender while using the views and looks present in the Filmic Blender LUT set, as above.

The work is done. Assuming we have other shots we would like to apply this look to, or build up our library of sample looks for this particular set of constraints, we need to forge ahead and craft a LUT. As we can see, there has been both a slight contrast tweak added, as well as some saturation adjustments. Knowing that only a 3D LUT can do both, we will need to create a 3D LUT for this work.
2.0 Generate the all-in-one
LUTs can be generated both via algorithm or, more commonly, from source imagery. The way to generate a look based off of a tweak one has given to source footage is to generate a known constant image and use it to compare against an identical constant, tweaked to the same tuning as the desired creative output.
There are demons hidden away here though. 3D LUTs, given that they operate on a specifically designed range of values, must be properly mapped in order to both meet the range, but to optimise their application. In this case, since the question pertains to the Filmic LUT set, we need to make sure that our 3D LUT is going to sufficiently match what we saw when we were grading the image. Some 3D LUT formats include the "shaper" compression component inside their actual LUT formats.
Given that the default Blender sRGB OETF / EOTF was never designed for any sort of creative work such as raytracing, it is sub-optimal on a number of levels. As a replacement, the Filmic LUT set consists primarily of two transformations that make work appear more photographic. First, it uses a much wider dynamic range from the scene referred values than the default sRGB EOTF uses. This means your work includes and requires light that more closely matches physical, real-world levels. As a result you'll notice much better radiosity, caustics, indirect bouncing, etc. Second, it uses a 3D LUT to desaturate the values as they ascend to the higher dynamic range, attempting to emulate what happens on colour film or DSLRs, and prevent the broken, wonky saturations that happen as colours get very intense under the default view.
When making a 3D LUT, care must be taken to match the exact same contexts that we are developing our work under. An all-in-one image covers a fully normalised range of values, at a cube size you choose. However, given that it covers a normalised range, and that our work was crafted on a scene referred range, we have to transform our all-in-one accordingly, so that the reference spaces match.
To prepare our environment, we must tell the OpenColorIO applications where our OpenColorIO configuration is. It should be noted that if we do this in the CLI and run Blender from that same CLI, Blender too will honour the location of the configuration, and ignore the internal configuration located in your installation, at datafiles/colormanagement/config.ocio.
Setting the environment variable might look like:
export OCIO=/path/to/local/configuration/config.ocio

That command looks as follows:
ociolutimage --generate --cubesize 65 --maxwidth 4225 --colorconvert "Desat Log Encoding" Linear --output /path/to/scenereferred_allinone.exr

What does it do?

--generate instructs ociolutimage that we want to create an all-in-one image.
--cubesize 65 instructs ociolutimage to use a cube size of 65, which is a very high quality 3D LUT.
--maxwidth 4225 is a somewhat optional feature to make the resulting image legible to a human. This keeps the image such that the individual cubes are small blocks of colours ascending, and is easily understandable in an imaging application. If we leave this out, the values end up unaligned and can be tricky to understand in an image viewer.
--colorconvert "Desat Log Encoding" Linear instructs ociolutimage to transform the all-in-one for us, from the normalized range which we interpret here as the "Desat Log Encoding" transform, to the scene referred "Linear" encoding we are feeding in our reference space. This will transform the values from 0.0 to 1.0 to the scene referred range of the desaturation shaper, which extends up to 184.32 scene referred. This is also why we need to specify our OCIO configuration above. It should point to the Filmic LUT set.
--output /path/to/logencoded_allinone.exr specifies where we want the output EXR file to be stored on our drive.

Using the above output file scenereferred_allinone.exr, we simply add it into our node chain right where our source enters. In the viewer, we can use the Save Image As... function to save the adjusted all-in-one as a modified version EXR. Save this file as ````scenereferred_modified.exr``` at 32 bit depth.
3.0 Generate the 3D LUT
Now we have a modified all-in-one that is precisely identical to the modifications in our original grading node chain. We will use this as the blueprint to create the 3D LUT.
First we must be certain that we establish the OCIO environment variable so the following transforms are understood:
export OCIO=/path/to/local/configuration/config.ocio

Next, we have a quick hop to return the image from the scene referred domain that it currently exists in, to the log-encoded nonlinear range that the transforms in the Filmic LUT set expect. Why? Because if simply scale our cube size, our 3D LUT would be biased to a range that isn't terribly perceptually uniform. This would potentially lead to posterization or poor quality. To make our 3D LUT useful, we need the reduced range to reference a more perceptually uniform set of values with our modifications.
That transform looks like this:
ocioconvert scenereferred_modified.exr Linear logencoded_modified.exr "Desat Log Encoding"

The above transforms our all-in-one image into the log encoded range our LUT set expects. Both "Linear" and "Desat Log Encoding" are transforms listed in the Filmic LUT set, and again why we have to specify the environment variable above.
Now that we have the EXR file primed for generation with our modifications, we will again lean on ociolutimage to do the heavy lifting.
ociolutimage --extract --cubesize 65 --maxwidth 4225 --input /path/to/logencoded_modified.exr --output /path/to/3dLUTdemo-LUT.spi3d

Breaking this down:

--extract instructs ociolutimage to extract the 3D LUT from the input file, which is assumed to be an all-in-one created with the options provided.
--cubesize 65 instructs ociolutimage that the image contains a cube size of 65. If we leave this out, ociolutimage will complain that the file doesn't match the default expectation.
--maxwidth 4225 instructs ociolutimage that the image is of the specified width. If we leave this out, ociolutimage will complain that the file doesn't match the default expectation.
--input /path/to/logencoded_modified.exr simply specifies the path to our input all-in-one modified image. Remember, it should be perceptually uniform if you want your 3D LUT to not look whack.
--output /path/to/3dLUTdemo-LUT.spi3d is the path to the solution to the question; the 3D LUT, in Sony Pictures Imageworks format.

4.0 Integrate the thing
As for the final step, we will be using the look section of the Filmic LUT set, and adding in our own. This again will require a few extra entries because of the slightly complex method that the views and looks are implemented to generate the desaturation.
First, make a backup copy of your Filmic LUT set just in case you mangle something up beyond recognition.
Next, copy the 3dLUTdemo-LUT.spi3d into the looks directory of the Filmic LUT set.
Now, find the config.ocio file for the set at the root of the directory and open it with a standard text editor. We are going to do the following:

Add a new desaturation log encoding base view to base our looks off of.
Add our new look to the list of looks.

To accomplish the first thing, we need to simply enable the preexisting transform for the "Desat Log Encoding" into a view. To do that, locate the section that looks like the following:
[...]
displays:
  Filmlike:
    - !<View> {name: sRGB EOTF, colorspace: sRGB EOTF}
    - !<View> {name: Data, colorspace: Raw}
    - !<View> {name: Scene Linear, colorspace: Linear}
    - !<View> {name: Filmic Log Encoding Base, colorspace: Filmic Log Encoding}
    - !<View> {name: Filmic High Contrast, colorspace: Filmic Log Encoding, look: +High Contrast}
    - !<View> {name: Filmic Medium High Contrast, colorspace: Filmic Log Encoding, look: +Medium High Contrast}
    - !<View> {name: Filmic Medium Low Contrast, colorspace: Filmic Log Encoding, look: +Medium Low Contrast}
    - !<View> {name: Filmic Low Contrast, colorspace: Filmic Log Encoding, look: +Low Contrast}
    - !<View> {name: Filmic Base Contrast, colorspace: Filmic Log Encoding, look: +Base Contrast}
#    - !<View> {name: Debug, colorspace: Debug}
[...]

We add the preexisting transform to the list of views as follows. We will tuck it in just after the Filmic Log Encoding Base. Again, the reasons for this additional step is the way in which the desaturation is crafted for the transform set, and therefore we require a very specific view for our LUTs:
[...]
displays:
  Filmlike:
    - !<View> {name: sRGB EOTF, colorspace: sRGB EOTF}
    - !<View> {name: Data, colorspace: Raw}
    - !<View> {name: Scene Linear, colorspace: Linear}
    - !<View> {name: Filmic Log Encoding Base, colorspace: Filmic Log Encoding}
    - !<View> {name: Desat Log Encoding Base, colorspace: Desat Log Encoding}
    - !<View> {name: Filmic High Contrast, colorspace: Filmic Log Encoding, look: +High Contrast}
    - !<View> {name: Filmic Medium High Contrast, colorspace: Filmic Log Encoding, look: +Medium High Contrast}
    - !<View> {name: Filmic Medium Low Contrast, colorspace: Filmic Log Encoding, look: +Medium Low Contrast}
    - !<View> {name: Filmic Low Contrast, colorspace: Filmic Log Encoding, look: +Low Contrast}
    - !<View> {name: Filmic Base Contrast, colorspace: Filmic Log Encoding, look: +Base Contrast}
#    - !<View> {name: Debug, colorspace: Debug}
[...]

Finally, we add the look itself down near the bottom of the file. Looks are added in a first in, last listed fashion. We can add the look to the top of the looks section as follows:
[...]
looks:
  - !<Look>
    name: My Demo Look
    process_space: Desat Log Encoding
    transform: !<GroupTransform>
      children:
        - !<FileTransform> {src: 3dLUTdemo-LUT.spi3d, interpolation: best}
        - !<FileTransform> {src: Base_DesatCrosstalk_DesatLog.spi3d, interpolation: best}
        - !<FileTransform> {src: DesatLog_to_EncodeLog.spi1d, interpolation: best, direction: inverse}
        - !<FileTransform> {src: Linear_to_0-7_1-05_Tonemap.spi1d, interpolation: best}

  - !<Look>
    name: Greyscale
    process_space: Filmic Log Encoding
    transform: !<MatrixTransform> {matrix: [0.2126729, 0.7151521, 0.0721750, 0, 0.2126729, 0.7151521, 0.0721750, 0, 0.2126729, 0.7151521, 0.0721750, 0, 0, 0, 0, 1]}

  - !<Look>
    name: False Colour
    process_space: Filmic Log Encoding
    transform: !<FileTransform> {src: Filmic_False_Colour.spi3d, interpolation: best}
[...]

Note that there are four transforms listed in our witch's brew. Why? In order:

- !<FileTransform> {src: 3dLUTdemo-LUT.spi3d, interpolation: best} is our LUT that we created. The process space takes care of taking us to the "Desat Log Encoding" range of values, and the 3D LUT applies our creative transform to those values.
- !<FileTransform> {src: Base_DesatCrosstalk_DesatLog.spi3d, interpolation: best} is the basic desaturation for the Filmic Set. This is required to match the desaturation look when we were generating the grade.
- !<FileTransform> {src: DesatLog_to_EncodeLog.spi1d, interpolation: best, direction: inverse} is the reduced range from the desaturation range shaper. This stores the encoded image with a display referred white that is lower than the desaturation range. The reasons for this are beyond the scope of this document.
- !<FileTransform> {src: Linear_to_0-7_1-05_Tonemap.spi1d, interpolation: best} applies the "Base Contrast" tonemap look to the reduced range, as they were designed. This final transform should match the tonemap transform you graded under, if you happened to have. If you didn't, you can leave this out. Pay attention to you views and looks when grading, as you must match the chain perfectly in order to get 1:1.

Test it out
If all went well, you can now load Blender and find your newly created My Demo Look listed in your looks. To apply it to any scene referred EXR that you have lit / modified under the Filmic Set, you now must use the newly created Desat Log Encoding Base view we created, with our My Demo Look. It will be a 1:1 match with your original grade, now nicely canned way for application against other shots or used as a base entry point.
The adventurous types can further their efforts by exploring canning ASC-CDL values into pre-baked looks, using the OCIO environment variables to set up grading sessions based on shot names and numbers, or other such powerful tricks. If anyone is interested in these sorts of drek and the further applications listed, feel free to ask them as a question. This will keep already lengthy solutions from sprawling out of control, as this one already has.
Hope this helps...


Been trying this on and off for some time. For this particular mesh, if the shape is that simple, you can just copy the mesh, and flip it the other way, whichever axis it goes across, scale it to -1


When use remesh mesh does not follow bones

Instead of Remesh, Decimate doesn't save vertex weights. So you can try to recreate weights using data transfer modifier.

So here is base setup. I have simple mesh, deformed by armature. But when I add Remesh, armature doesn't work:

Here how to solve this problem:

Copy mesh to other layer and remove Remesh and Armature modifiers on them. It will be a "Source". By the way, you can do a link instead a copy, by using Alt + D
Add a Data Transfer Modifier after Remesh but before Armature. In modifier settings set "Source" object, click Vertex data and vertex Group(s)


I have no particle systems in my menu options

As far as I know, you can't add particle systems to curves. Try another mesh. Cube for example.


Tissue addon

You can start by using the Screw modifier on a Curve profile in order to build the main shape.

Then build a "component" for the Tissue add-on made of 3 ridges like the one shown below:

Run the Tessellate operator chossing the component ad the surface. Activate the merge option.


Blender API: Return value of bpy.data.objects(ID).show_bounds and .bound_box

Object.bound_box does not contain mathutils-types like Matrix or Vector, it's a plain property array of float[3] which has no representation format like other types do.

You need to iterate over all elements and print them, e.g.:

for b in bpy.context.object.bound_box:
    print(b[:])

# (-1.0, -1.0, -1.0)
# (-1.0, -1.0, 1.0)
# (-1.0, 1.0, 1.0)
# (-1.0, 1.0, -1.0)
# (1.0, -1.0, -1.0)
# (1.0, -1.0, 1.0)
# (1.0, 1.0, 1.0)
# (1.0, 1.0, -1.0)

Or make a list of Vector objects:

[Vector(b) for b in bpy.context.object.bound_box]


These weird shapes are likely due to Wireframe modifier on the "net" object. When you join them Wireframe modifier applies to spheres too. If you are not going to change settings on Wireframe modifier later, then you can apply it before joining with spheres.


Go to Properties panel > Render tab > Dimensions and increase the percentage slider.


Export blender rendered image as numpy array

Numpy array isn't a native output option.
Notice up at the top of the screen, when you click Render,
it specifies Render Image

If you want it to directly output to a non-standard container,
you'll have to modify the source code to accomplish that.
http://download.blender.org/source/
...
You can convert standard arrays into a numpy array like this:
https://stackoverflow.com/a/4562455/3342050
So if you don't mind running render, then using a script to export:
# path2numpy = '/home/me/.local/lib/python3/dist-packages/numpy/'   ##  linux
# path2numpy = 'C:\\Users\\me\\AppData\\Local\\Python\\Lib\\site-packages\\numpy\\'   ##  win

import sys
sys.path.append(path2numpy)

import numpy as np
array = []

# render = bpy.ops.render.render(layer="RenderLayer", scene="Scene")
# render = bpy.data.node_groups['Compositing Nodetree'].nodes['Render Layers'].layer

array.append(render)

np_array = np.array(array)

The render output data is most likely going to be found in one of those commented render lines.
You'll have to decide which one suits your needs.
You may have to iterate through the data to get it into the necessary format.
Something along the lines of:
for h in range(height):
  for w in range(width):
    R = render[h][w * bpp]
    G = render[h][w * bpp + 1]
    B = render[h][w * bpp + 2]
    data.append((R,G,B))
  ''.join(data)
  array.append(data)

Then convert regular array to numpy array, as above.
That's all dependent upon how you want that array set up though...


Strength of bump depends of object scale?

I think, it's a limitation of bump method. You can noted, that strength of bump effect not depends of scale, it depends of how big current face in world space...

So, use normal map. Normal map uses angles instead of depth, that's why objects, textured with normal map will looks the same in all scales.

Related: https://blenderartists.org/forum/showthread.php?359453-Cycles-displacement-corruption-when-scaling-an-object


How to make displacement working on imported objects?

Three things for this to work

Proper UV maps (main reason)
- your imported objects have broken or even missing UV maps, so the displacement doesn't work
- to solve this, select all faces of the mesh and go UV > Smart UV Project

Connect Displacement texture
- your node setup is very... unusual :)
- you need to connect your Displacement Texture directly into the Displacement node

Apply scale
- some of your objects have very small scale (0.01) which also affects final displacement
- apply the scale through Object > Apply > Scale  so it 1.

Apply scale to parented objects
- some object's are parented - you need to clear the parent before applying scale
- select parented object and go RMB > Clear and Keep Transformation

How to create a simple UV map.
This is just a quick and dirty way. Learn to unwrap objects manually

How to connect Displacement texture

How to clear parent and apply scale
Do this for all imported objects, just to be sure


how to make one object not pass through another in blender

in your case I would try to deal with that by using physics.
On the right side of your blender window is the menue, select physics in the bar.

Click on your crater that will later contain the fruits and add Rigid Body. You will have to make it a Passiv Object, that means that it won't fall into the abyss (like when it is active), and that active objects don't pass through it.

As soon as you have created your fruits, position them for example over your crater. Under physics add again Rigid Body, but this time make them Active (which should be automatically be selected).

Now when you play your animation the fruits should fall into the crater and maybe bounce a little bit, neither will they go through the Passive object and nor through the other fruits that are Active Rigid Bodys as well.

I hope that answers your question. If you can't find those options in blender, I'll post some pictures to describe it better.

Greetings W.Zayde


How to get smoke to pour out object holes?

It looks like the resolution you are using for the smoke domain is too coarse. This makes the size of a smoke voxel possibly comparable or bigger than the apertures, preventing the smoke to "see" that they are there. By increasing it to 64 I've managed to see the smoke escape from both eyes.

To make sure that the smoke would come out within the time frame (I've done a test bake of 170 frames), I've also increased the time scaling factor, and I've added a starting normal velocity to the Flow object.

I'm not sure whether it counts, but I've also changed the obstacle type to "Animated" (doing this alone isn't enough, you'll still need to increase the resolution)


Objects missing in render, light has no effect

Object added in Local view don't update till you go out of it

I never notice, but looks like the object you build while you are in the Local view, despite being added to the outiner, (and so to the scene as well) they don't appear in the Global view till you go out from the local View.

At least this is what happens in 2.78 version.

If you open another window, you can examine the scene that is being rendered:

Eyes are missing, and maybe the planes that are providing light to the scene...all objects that you have probably built while you was in Local view without ever going out.

Those are not rendered because they are in a limbo, trapped in the Local view waiting to be released. That's where the difference cames from.

You can see how the cube added in the image sequence below is not in the Global till I go out from Local view.

I don't kown if this is a feature or a little bug.


Animation render creating black image files

Thanks but I realised what I had done. I had created a video file with what I had and then forgot to delete it from video editor. Once I did that it works fine.


How to make a smooth surface for OBJ files?

While the model you want to decimate is selectet, go to modifiers > add modifier > decimate. now you can play around with the settings until you are happy with the resolution.


Ok. I figured it out. I didn't actually recreate the object properly. I had closed the edge using the 'F' key so the Face wasn't actually subdivided, so one side has 6 vertices and one side has 4.
I deleted the edge and used the knife tool to recreate the line in the middle and it all works properly now.


This is a standard task:

add to your scene (domain and flow) one FLUID of type "EFFECTOR"
simulate and check if the result is ok

Please keep in mind that a plane as "EFFECTOR" could not be correctly read by the simulation engine. Go with a cube or similar to be sure the simulation works.


The Subsurf Modifier Did Something Weird to a Part of My Mesh

I think if you rework it into all quads with the knife tool (pressing K) and then dissolve the unneeded edges it will work. Also: remove doubles. If it still doesn't look right: Sometimes you might think you hit the spot with the knife tool but you missed it. Zoom in to all the verts you connected and recheck. Make sure you cut all the way around to the back also.

Before

After

Edit: Actually it is even easier. you only need to turn the top tris into a quad by dissolving its bottom edge and then add in two new edges with the knife tool.


Liquid inside a cup is being Transparent

IOR is how mutch a volume deforms the light rays going through, 1 being no refraction.

It has nothing to do with whether or not you can see through your volume.
That would be the Transmission value you've set to 1, meaning it 100% transmits light through. If you don't want that, set it to zero.


Import Numpy = attributeError: module 'numpy' has no attribute 'core'

Blender installation issue

Blender comes with numpy installed. Maybe something got wrong in your blender installation, if so you should not be able to import numpy directly from the python console:  (deactivate AN first)

If these simple commands do work, this means AN is the problem and you should create an issue thread on the github repo or contact Jacques Luke directly.
If they don't work, it means Blender wasn't installed correctly, and you should try:

to copy directly the site-packages folder at %version%\python\lib\site-packages directory. (Download the blender zip and copy the directory).
As I have not tried it myself, maybe the last method will create conflicts, so if it doesn't work, make a new installation of blender.


After improving my animation, render time has increased drastically

here you can find a way to check what area of the screen takes more to render:
https://blenderartists.org/t/any-way-to-generate-a-render-time-heatmap/1161497

Render layers node is used in combination with Color ramp to show the longer pixels to render.

Another way to check what is slowing down your render is to disable all objects and re-enable one by one and check render time (and eventually crashed too).


Knowing where the addon should be found is the first thing to sort out. You can either look at the addon source and see where it attaches to, or investigate by hand. Generally you'll find it in the bl_idname of the Operator.

For example I have an addon called autoVTX for which the Operator code has these lines at the top:

class AutoVTX(bpy.types.Operator):
    bl_idname = 'view3d.autovtx'
    bl_label = 'autoVTX'

    # ...

This Operator can be accessed from bpy.ops.view3d.autovtx()

The try/except route is fine btw, as CoDEmanX rightfully points out in the comment. If you know where an addon or operator should be when installed then this should work.

def doCoolThing():
   try:
       bpy.ops.view3d.coolAddon.foo()
   except AttributeError:
       print("COOL ADDON NOT INSTALLED!")


Blender does not scale or rotate in object mode?

Stab in the dark, you might have 'Manipulate Center Points' selected, which prevents you from scaling and rotating an object in Object Mode.


Need to export animations into FBX without interpolations (need just keys solely )

I seem to find out this time values order - while exporting constantly interpolated animation every framekey is presented as a pair, the first one's tick is -1 by number then the actual frame's tick in dope sheet and it contains the translation and rotation BEFORE the actual frame tick value, while the second data in this framekyes pair shows actual trnslation and rotation at the actual time in dope shit, to clarify:
3 actual framekeys with constant interpolation:
Assimp gives 6 stored keys, first couple is, lets say, 8th tick first  and 9th tick second, this first keys means BEFORE 8th time value all previous ticks the model has translation and rotation it contains. The second one, that shows 9th tick is actual framekey change...Following this the next pair will contain, lets say, 18th and 19th time ticks, and that means that between 9th and 18th tick the bone had stable translation and rotation while at the 19th tick its going to change again. Every second framekey data will repeat every first framekey data in the next couple - this is just an interval where bones were not transfromed because of constant interpolation. Every second is actual translation/rotation of the bone. Just in case someone faces the same strange at first sight Assimp FBX loader behavior :)


How to add an object to the scene through python

I figured it out:

bpy.context.scene.objects.link(object)


Why does my Properties panel cover my whole active 3D Viewport when I press P?

What you are seeing is not the properties panel. The keyboard shortcut P start the blender game engine, "P" for play. If you were to add in some object and hit P this would be very apparent that it is not the properties panel.

Pressing P at the default scene.


Can I use blender as a photo and video viewer?

Blender can be a useful image viewer for some formats like multilayer OpenEXR. I just expanded a bit on Chebhou's answer by creating a python script that calls blender, I expect this can be used on any *nix platform included OSX and possibly even windows.

The script that gets called or set as the application to open image files is -

#!/usr/bin/env python3

from subprocess import call
from sys import argv
import os

sdir = os.path.abspath(os.path.dirname(argv[0]))

calllist = [
    'blender',
    '--factory-startup',
    os.path.join(sdir, 'blend_image_view.blend'),
    '--python',
    os.path.join(sdir, 'blend_open_image_file.py'),
    '--',
    ]

# add the args we get as filenames
calllist.extend(argv)

call(calllist)

The factory-startup and blend file can be removed from the list of options sent to blender. I have blender setup to start with a window that fills two monitors, that doesn't work as well when used as a simple image viewer. I also setup a start file that has two simple layouts for image and movie viewing, leaving a window clear of any excess.

The main working script I adjusted a bit to handle multiple files. When multiple movies are opened I have them in separate channels, with all but the first video muted. I really don't think blender is a good choice for video viewing, this could be improved by adding a way to extract frame rates and resolutions to setup blender to match, which doesn't work well if you open multiple videos with different frame rates and sizes.

import bpy
from sys import argv
import os

# change these two values to match screens names available
# UV Editing
blenderImageScreenName = 'ImageViewer'
# Video Editing
blenderMovieScreenName = 'MovieViewer'

acceptedImgFiles = ['.bmp', '.cin', '.dpx',  '.exr',
                    '.hdr', '.jpg', '.jpeg', '.jp2',
                    '.j2k', '.png', '.rgb',  '.tga',
                    '.tif'
                    ]
acceptedMovFiles = ['.avi',  '.flv', '.h264', '.mov',
                    '.mpeg', '.mpg', '.mp2',  '.mp3',
                    '.mp4',  '.mkv', '.ogg',  '.xvid'
                    ]

fileStartIdx = argv.index('--') + 2
numFilesToOpen = len(argv) - fileStartIdx
showAreaType = 'image'
curChann = 1

for i in range(numFilesToOpen):
    filename = os.path.abspath(argv[fileStartIdx + i])
    ext = os.path.splitext(filename)[1].lower()

    if ext in acceptedImgFiles:
        bpy.ops.image.open(filepath=argv[fileStartIdx + i])
    elif ext in acceptedMovFiles:
        # while we will open video files, blender isn't the best option here
        # When opening multiple videos, each video is imported into a new track
        # tracks after the first will be muted to prevent a terrifying
        # mess of multiple audio tracks
        # end frame is set to the longest video track imported
        # frame rate is left default and will need to be adjusted for each video
        nc = bpy.context.scene.sequence_editor.sequences.new_movie(name=argv[fileStartIdx + i],
                filepath=os.path.abspath(argv[fileStartIdx + i]), frame_start=1, channel=curChann)
        if bpy.context.scene.frame_end < nc.frame_duration:
            bpy.context.scene.frame_end = nc.frame_duration
        # I expected new_movie() to import video and sound
        # but that doesn't happen so we also add sound from the same file
        nca = bpy.context.scene.sequence_editor.sequences.new_sound(name=argv[fileStartIdx + i],
                filepath=os.path.abspath(argv[fileStartIdx + i]), frame_start=1, channel=curChann+1)
        if curChann > 1:
            nc.mute = True
            nca.mute = True
        curChann += 2
        showAreaType = 'video'
    else:
        print("Don't know what type of file this is -",filename)

if showAreaType == 'image':
    bpy.context.window.screen = bpy.data.screens[blenderImageScreenName]
    # make first image active
    for area in bpy.data.screens[blenderImageScreenName].areas:
        if area.type == 'IMAGE_EDITOR':
            area.spaces.active.image = bpy.data.images[0]
else:
    bpy.context.window.screen = bpy.data.screens[blenderMovieScreenName]

Save this as blend_open_image_file.py to match the filename set in the first script.

The list of extensions can easily be extended.

I thought I would keep a copy of this on github which also has the blend file mentioned above if anyone thinks it can be improved.


Use a sphere and scale it on the Z axis.

SZ

Else you can use the scale manipulator and scale on a single axis:


Python: How do I export a single object as a .dae file?

To do it manually :

In Object mode with the object(s) selected

File > Export > Collada (.dae)

On the lower left hand side of the Collada export window you will find the export options, check the Selection Only option before exporting

Hope this helps a little.


Multiresolution subdivide modifier on a mirrored surface causes a visible seam

First I presumed that you did mirroring by negative scale around YZ-plane, then you have flipped normals at second half. But then I noticed modifier, so I was wrong.

I noticed similar result if Subdivision modifier placed higher than Mirror. Also Blender prevents from moving Multiresolution with subdivisions under Mirror, saying "Cannot move beyond non-deforming modifier" or "Cannot move above modifier requiring original data" for moving Mirror up.

I think it's a way Blender modifiers works with mesh data. I took a peek in official docs and found this: https://www.blender.org/manual/modifiers/the_stack.html - according to official info modifiers applied in order from highest to lowest. When I tried to apply them in this order, I also get seam in final mesh with both modifiers, but it was just crease in geometry, vertices are wielded, normals are outside, just little wrong geometry. Old edge at section at half-mesh left unsmoothed by modifier, because it processed differently areas where edges belong to just one face.


Basically No

No, it's not possible and never will be (in all likelihood).

Blender is basically just one OpenGL Canvas, that uses OpenGL to draw all of its UI using it's own library called GHOST, see Is the Blender GUI package available for other programs?.

Maybe it will be more clear by comparing Blender to a video game using OpenGL (which is essentially the same thing, a pure OpenGL application):
You are asking to put GNOME's menus into Counter Strike/WoW/you name it.

It just won't work because OpenGL is not operating with the normal windowing system of your OS.
Other 3D software like Maya / 3ds max use the native windowing system and only use DirectX/OpenGL to render the 3D Views. Blender as a whole is just one (or more) big OpenGL window(s).

Alternatives

Create additional GNOME windows via python

You could use python to create additional windows using GNOME's native menus, which could then interact with Blender. But that would just be a bad idea, because you'd get into a lot of cross-platform trouble, plus it's inconsistent with the rest of Blender and I don't even know a single project that does something like that.

Use Blender as a python module

If you just want use some functionality of Blender (maybe to modify a lot of blend files in a specific way) and want a GNOME UI then you could use Blender as a python module. That's a bit more involved though. For more info have a look at the Blender Wiki page on using Blender as a python module


How can I write (draw) notes or just drawings, with a 2d stroke but on the 3d viewport

There are two tools to do what you want: the grease pencil and annotations.

The grease pencil can be rendered,

https://www.blender.org/features/grease-pencil/

annotations are just for reference.

https://www.youtube.com/watch?v=-IJ7THnd2ZM


Undesired sharp edges with smooth shading

A big thank to @lemon, you saved me a whole bunch of hours. idk why this was checked, but now it works as before.

You can see by yourself.

The option is located there: