The sun lamp's position, inside the room, doesn't affect where the sun's light is actually emitted from, it only controls the direction. To quote the blender manual:

  Sun lamps emit light in a given direction. Their position is not taken
  into account; they are always located outside of the scene, infinitely
  far away, and will not result in any distance falloff.

So the light is being cast onto the outside of your room and not getting through the walls to the inside. You can see this by looking at the outside of the room while in 'Rendered' mode of the 3D viewport.

To solve this, you can either disable the 'ceiling' from casting a shadow by changing the 'Ray Visibility' options on the 'Object' tab in the properties space:

Or, change the type of light from sun to something else, like 'Point' or 'Area', whose positions are taken into account. You can also just set any object to emit light, like a plane, by giving it an emission shader.


I would try selecting all the vertex points you want to represent the right hand, and then press Ctrl + i  to invert the selection to the rest of the mesh, and press Remove to remove them from the right-hand vertex group, while the right-hand vertex group is selected and highlighted of course.


Only DirectX applications use DX normal maps. And DirectX run only under Windows mainly due to license. For everything else you need to use OpenGL. For sure is good always check documentation.

On image below you can find simple way how to convert DX to OpenGL (or OpenGL to DX)


How to reduce mesh vertices to obtain homogenous density while maintaining manifoldness

Well, I think I may have found a nice way to solve my own issue using the remesh tool itself:
Using the "QuadriFlow Remesh" with the "Edge Length" mode set to the desired value, or using the "Vertex Remesh" with the "Voxel Size" set to the desired value, produces pretty and homogeneous meshes while maintaining manifoldness.
Example:

Starting with a UV Sphere, which has a vertex density not so homogeneous

Apply a "QuadriFlow Remesh" with the "Edge Length" mode

The mesh gets a more homogeneous vertex density

Using the "Vertex Remesh" with the "Voxel Size" set to the desired value

will result in an also nice mesh:

The other remesh settings, may also produce nice results.
(Anyway, I still think that the merge by distance has some kind of bug, or else it must be used carefully. Edit: it's not a bug, it's expected behavior)


image.new() is not working with parameter "color"

a work around with #bpy.data.images["texture"].generated_color = (1, 1, 1, 1) in the next line would achieve the same.


RightClick "Assign shortcuts" doesnt work in Edit-mode?

While a lot of blender depend on the "context"
Being in Editmode and "Assign shortcut" will not , create a shortcut for edit mode.
Instead the default Behavior is create a shortcut for the category expressed in the bl_idname.
So having named the operator  object.myactions will create a shortcut for the "object category "
If i used the name                      wm.myactions  the shortcut will be placed in "window"
The shortcut for object will be ignored while in editmode,
So, create your operators using the category you want that to be placed
or
Create manually the shortcuts
(for example going in preference keymap , window and add your operator like object.move_x
it will work even with the object. because mapped in window)


There isn't explicit construction history in Blender per se.  If you ever want to know the dimensions of your object for 3d printing, you can always go to the display properties in the viewport, and scroll down until you see the Edge Info buttons under Mesh Display.  Note that you must have fully applied the extrusion operator to see these dimensions.

Move your cursor into the 3d viewport
Press "N" to bring up the Display Properties.
Scroll down the Display Properties until you see Mesh Display
Check off whichever buttons (Edge length, angle, or Face area) applies to what you're interested in.
Select the face/edges that you want to know the dimensions of.


I ended up creating an axis object... Here is the model link in blend swap.
It can create an axis and a few other interesting vectors. To create the axes,
it uses e.g. the input

vectors = [
 [(4,0,0), (0,0,0), 'red'],
 [(0,4,0), (0,0,0), 'green'],
 [(0,0,4), (0,0,0), 'blue'],
]


Why is my rigid body object floating as if there is no gravity?

Finally solved this problem. Here is the link to the successful project file output:  https://www.youtube.com/watch?v=wmTCE0c4SrI

The solution:
1st problem:  the point of origin in the post was too low and needed to be moved up. This required to rework all the animations from scratch.

2nd problem: the gravity settings needed to be adjusted and animated along the time line to get a more realistic result. And the friction and damping settings needed tweaking, as well as animating them with key frames. And voila.


Windshield Wiper Over An Airplane's Curved Windshield

You can try bend Wiper by curve object and curve object shrinkwrap on Glass.
It depence on what wiper vertices you want to bend you can limited it by Vertex Group.

Quick example is not perfect "wiper" rotates on its Z axis. I will have to check it later.

Or Bendi Bones could work in similar way as well.

Add-on Wiper
for 2.79 (Luca Rood) https://gumroad.com/l/wiper


How to make an object "move towards" another object

I'll admit it has been years since I've done any coding with the bge. But I would suggest looking up vectors. Get the vector from your empty to the object Then set the magnitude of that vector. Something like this:

vectTo = empty.getVectTo(object)

vectTo.magnitude = 2.0

empty.position += vectTo`

Like I said its been years and I don't have blender convinent to test (im really not sure that will compile) but something to that effect should work.


The "jump button shaded" suggests that you have selected "character motion", and clicked the "jump" option, but this doesn't mean your man jumps. All the "jump" button does is specifies the way the character moves.
Yours looks like this.

Needs to look like this. (see the z.3?)


Curve to Mesh - Not all faces are not connected

After you convert the curve to a mesh,

Tab into edit mode
A to select all vertices
Hit W and choose "Remove Doubles"


Answering my own question ...

Once it is created, the node names are different. So you create a node using, e.g. ShaderNodeMixShader, but after that it is called 'Mix Shader' (i.e. as it appears in the node panel).


Normally sculpting does not add any vertices or edges, it just moves them around. But when you enable the dynamic topology option in the left toolbar T of your 3d view it adds vertices depending on the given value and your zoom level.

You wrote that you want to create a game character? I recommend that you copy your existing object and add more and more details. Then you can bake the normals and save a lot of memory and rendering time.


Operator is invalid, callback isn't removed
At issue here is the draw callback belonging to the space is persistent when another file is opened, whereas a modal operator is not.  The solution below removes the draw callback if the operator becomes invalid.
Asked
Removing space draw callbacks after losing the handle?
with relation to having issues like in question. If the handle is attached to the operator and the operator is "lost" there is no way to remove the draw callback.  Well no one has answered how to .
If you were to put in the line
print(repr(self))

into your draw call back method,
All going well, and run from text editor (main thread)
<class '__main__.Test_operator'>

if the operator is removed will see
<bpy_struct, Test_operator invalid>

Once this is the case error shown in question will begin. Without going into great details the "rna" is  how blender objects store their properties under the hood.  When the instance of the blender operator is no longer required its rna is trashed.
Using repr avoids using a try catch clause. Would be keen to find out if there is a nicer way to check for this.
As a workaround to resolve issue of lost handle, when using operator as an argument, and owner of properties to draw, could set up a class variable list of operators and handles. When
repr(op).endswith("invalid>")

is true,  remove its callback via handle, remove from handles... and avoid the error message.
Test script.  Have made a class method to check the validity, and validate  the list.
import bpy, blf

class Test_operator(bpy.types.Operator):
    bl_idname = "object.test_operator"
    bl_label = "test"
    handles = []

    @classmethod
    def validate(cls):
        invalids = [(op, handle) for op, handle in cls.handles if  repr(op).endswith("invalid>")]
        valid = not(invalids)

        while invalids:
            op, handle = invalids.pop()
            bpy.types.SpaceView3D.draw_handler_remove(handle, 'WINDOW')
            cls.handles.remove((op, handle))
        return valid

    @staticmethod
    def draw_callback_px(self, context):
        font_id = 0  # XXX, need to find out how best to get this.

        # check handles
        if not Test_operator.validate():
            return

        blf.position(font_id, 15, 30, 0)
        blf.size(font_id, 50, 72)
        blf.draw(font_id, self.s)

    def modal(self, context, event):
        "some code..."
        return {'PASS_THROUGH'}

    def invoke(self, context, event):
        self.s = "hello"

        args = (self, context)
        self.handles.append((self,  bpy.types.SpaceView3D.draw_handler_add(
            Test_operator.draw_callback_px, args, 'WINDOW', 'POST_PIXEL'
        )))
        context.window_manager.modal_handler_add(self)
        return {'RUNNING_MODAL'}

def register():
    bpy.utils.register_class(Test_operator)
def unregister():
    bpy.utils.unregister_class(Test_operator)

if __name__ == "__main__":
    register()

Window Manager
IMO would instead make a drawing class, similarly to link atop answer, or as a mixin class or as a wrapper for the callback.
Adding further to How do you remove a draw handler after it's been added? can leverage the window manager to keep a context reference to the draw handler classes.
Here is a quick cobble together by I think you can see where this is going.  Can communicate with the draw callback via context from your operator when it is run again.
import bpy
from bpy.types import PropertyGroup
from bpy.props import PointerProperty
import blf

class DrawingClass:
    def __init__(self, context, prop):
        self.prop = prop
        self.handle = bpy.types.SpaceView3D.draw_handler_add(
                   self.draw_text_callback,(context,),
                   'WINDOW', 'POST_PIXEL')

    def draw_text_callback(self, context):
        font_id = 0  # XXX, need to find out how best to get this.

        # draw some text
        blf.position(font_id, 15, 50, 0)
        blf.size(font_id, 20, 72)
        blf.draw(font_id, "%s %s" % (context.scene.name, self.prop))

    def remove_handle(self):
         bpy.types.SpaceView3D.draw_handler_remove(self.handle, 'WINDOW')

class DrawCallBacks(PropertyGroup):
    _dc = []
    def add(self, cb):
        self._dc.append(cb)

def register():
    bpy.utils.register_class(DrawCallBacks)
    bpy.types.WindowManager.callbacks = PointerProperty(type=DrawCallBacks)

if __name__ == "__main__":
    register()

    # test
    wm = bpy.context.window_manager
    wm.callbacks.add(DrawingClass(bpy.context, "FoogleDoodle"))

Can open a new file go to console
>>> C.window_manager.callbacks._dc
[<__main__.DrawingClass object at 0x7fed5b609a30>]

>>> for cb in C.window_manager.callbacks._dc:
...     cb.prop
...     cb.prop = "MumbleGrunt"
...
'FoogleDoodle'

and the callback prints "MumbleGrunt" to screen.


Bool Toll fail
In provided file the Bool Tool, brush type Difference, works for me.
But your screen of "helmet" object looks differently. On screen Mirror modifier has unchecked Merge, so if you used it in this condition - Bool Tool failed.

Missing Canvas menu
This menu appears only when a brush is used. Than you can see properties menu when "Canvas" object is selected. BTW you have selected "Brush" object. So when boolean operation is used also here "Brush" properties appears when selected.


How can I set the object origin for an armature?

In the Edit mode, the pose set in an armature is ignored.  Because in your case the object is translated in an unwanted way in the Object mode but not in the Edit mode, it is possible that you have accidentally set a pose which translates the whole object.

To clear the translation of a pose, do the following.

Select the armature and enter the Pose mode.
Select a bone you want to reset the translation of (or select all bones by using shortcut A if you want).
Press Alt+G (the shortcut for Pose > Clear Transform > Location).

In response to your comment, here is how to clear the keyframes for the bone translation (that is, remove the animation data of the bone location from all frames).

Select the armature and enter the Pose mode.
Select the bone, and open the Bone tab in the Properties window.
Right-click any of the three coordinates in Location, and select Clear Keyframes.

After clearing the keyframes, you can use Alt+G to clear the translation.

However, because this works for only one bone, if you want to do this for many bones, you have to repeat steps 2 and 3 many times.  Maybe there is a better way.


How can i import blender 3d model in after effect

No, Currently You Can't (According to me)
Currently There is No Live Link Between After Effects and Blender to Directly Import 3d Model in After Effects But You can Export Tracking Data or Other Data from After Effects to Blender and Vice Versa Using Python Scripts
or You Can Just Import a 3D Model in After Effects Using "Element 3d Plugin For After Effects" But That Needs GPU "Element 3d" Will Not Run On CPU.


Can we modify the code of blender and use it as a analysis software?

What do you mean "Can we"?

"Can we"  as in are we able to legally do it, or "Can we"  as in is it technically feasible?

Either way the answer is probably yes to both.

Blender is Open Source software so you are mostly free to modify it as you see fit, as long as you publish it under a compatible Open Source license if you make it publicly available.

Quoting the license:

  Blender is released under the GNU General Public License (GPL, or
  “free software”).

  This license grants people a number of freedoms:

  You are free to use Blender, for any purpose
  You are free to distribute Blender
  You can study how Blender works and change it
  You can distribute changed versions of Blender

  The GPL strictly aims at protecting these freedoms, requiring everyone
  to share their modifications when they also share the software in
  public. That aspect is commonly referred to as Copyleft.

Technically speaking, I have no clue but Blender codebase is very adaptable, you could probably do it too if you are willing to roll up your sleeves and put some elbow grease in.

Whether it will be easy or hard is another matter, the source code may require substancial changes to support that kind of features, to the point of no longer being worth it to build on top of Blender.

That being said Blender as proved to be very flexible and versatile, and it has been adapted for many different workflows and industries, so it could probably be adapted for that too.


Can you use Cuda from GPUs of different generations?

Cycles will be able to use them both simultaneously with the CUDA backend, each will render separate tiles. For several reasons though, the result will probably be slower than just using the 2060.

Since each card works on a different tile and there's no way for the other card to steal a tile once the first card claims it, you will eventually end up in a situation where all but one tile has finished rendering and the 660Ti is working on the last one while the 2060 sits idle. Because the performance difference between the cards is so great, this wasted time will likely be more than you'd save by having the 660Ti help in the first place.

Both cards need to have the scene copied into VRAM in its entirety. As a result, you're effectively limited to the VRAM of whichever card has less. Which is the 2GB 660Ti instead of the 6GB 2060

The 2060 has RTX hardware units, which Cycles can use via the OptiX backend to speed up ray intersections. However, the 660Ti is too old to use the OptiX backend. And the 660Ti is so slow in general, it is likely to contribute less than the RTX hardware on the 2060 could.

So while it's possible to render on both cards simultaneously, it is more likely to slow down your renders than just using the 2060 alone.


Use foreach_set to set all fcurve data from data

Similarly to this q&a can add our data directly to an fcurve.

fc.keyframe_points.foreach_set("co",
        [x for co in zip(frames, samples) for x in co])

is setting the co, the (frame, value) pair of each keyframe point

for f, s in zip(frames, samples): # zip => (f1, s1), (f2, s2) ...
    fc.keyframe_points.co = (f, s)

note foreach_set requires a "flat (or one dimensional) list"  eg [f1, s1, f2, s2 ...]

flat_list = [x for co in zip(frames, samples) for x in co]

Script below creates a random noise per frame for frames 1 to 250.  The action and fcurve is created for location.y and  assigned to the context object.

import bpy
from random import random

frames = range(1, 250)
samples = (random() for f in frames)
# some action
a = bpy.data.actions.new("SomeAction")
fc = a.fcurves.new("location", 1, "LocY")

fc.keyframe_points.add(count=len(frames))
# populate points

fc.keyframe_points.foreach_set("co",
        [x for co in zip(frames, samples) for x in co])
# update
fc.update()
# assign to context ob
ad = bpy.context.object.animation_data_create()
ad.action = a

To tweak it up a notch, if you are not going to edit the fcurve convert it to sampled points

fc.convert_to_samples(1, 250)


How can I increase the gap between loopcuts?

You can indeed do what you want with Scale, you just need to lock the transformation to the X axis to prevent any transformation on the Y and Z axes. Press S followed immediately by X to lock the transformation to the X axis, and only the spacing between the edges will be modified.


Subdivide Surface Modifier messes up concave shape

I'd try to recreate your mesh, as it's easier to do so as fix your mesh.
Create a rectangular plane and use loop subdivide, using ctrl-R + Mousewheel.

With this basic mesh, consisting only of quads, and the loop subdivide technique, it should be easy for you to use the subsurf modifier.


Works for me in 2.69:

>>> bpy.data.movieclips[0].tracking.plane_tracks.active.markers[0].corners[0][:]
#(0.12633077800273895, 0.4383348524570465)

plane_tracks.active gives me the correct name, even if I rename it in the right sidebar of the movieclip editor. You could try plane_tracks["Plane Track"] or plane_tracks[0] instead.

Do should deselect all in the movieclip editor and re-select the tracking plane and see if plane_track.active changes to the correct name.

clip = bpy.data.movieclips["1100wbdc0000.jpeg"]
print("\nMovie Clip %s" % clip.name)

for i, ob in enumerate(clip.tracking.objects):
    print("\n\tTracking Object %s" % ob.name)

    for j, pt in enumerate(ob.plane_tracks):
        print("\t\tPlane Track %i" % j)

        for k, marker in enumerate(pt.markers):
            print("\t\t\tMarker %i" % k)

            for l, corner in enumerate(marker.corners):
                print("\t\t\t\tCorner %i = %f / %f" % (l, corner[0], corner[1]))


Is there a faster process for converting splines into rigged meshes?

Skin Modifier
Using the Skin Modifier along with a Subdivision Surface Modifier you can do this rather quickly.
The skin modifier has the option to create an armature for you, so convert your curve to mesh first, and use the modifier.

The spiral in the image below is a very basic example, but you can get the point from it.


You could maybe look into "SOFA"
(https://www.sofa-framework.org/)
which is a python based Physics engine for a wide range of things (including your problem i think)
I think there is even a previous version that was connected to blender so that blender uses SOFA as physics engine....

If you should find another solution, in blender or somewhere else, please post it! I'm interested in doing something similar myself!


How do I use CTRL-R to cut all the way through an object, not just one face?

The knife tool will work in this situation. After pressing K, hit Z, which will put it in cut through mode.


Transparent layer rendering in the Blender Render Settings


If you come across a problem like this, the solution might be not to copy&paste from an existing exporter script, but to literally copy the directory of some such exporter into .config/blender/x.xx/scripts/addons and work on it from there. This seems to work, but the root cause was blender getting freaked out by my bl_info line. Specifically:

bl_info = {
...
"support": 'NONE',
...
}

freaked it out and omitting the line solved the issue.


Rerending only freestyle on previous render

You can create two separate render layers and use one for the actual render, and the second one exclusively for the Freestyle strokes.
Combine them in the compositor and then update only the freestyle layer when you tweak settings.

Procedure described in detail here Adjusting Freestyle in the Blender compositor


Error - "should be zero or 1 controller arg"

Do you have at least one controller logic-block setup with Python script? That controller needs to be on a sensor (usually an Always sensor). if that's not the problem, take another look at the API for the functions or objects associated in the script (maybe provide a link?)

I've had trouble running UPBGE, so I've no experience with it.


Shortcuts do not work on the dope sheet. (2.8version)

Try Alt + mouse scroller

PS: I'm trying to fix my screencast keys but I was pressing Alt + mouse scroller


Your Mesh normals are reversed, press ctrl + N to fix them while all faces are selected. You can select the edges you want to bevel and ctrl + B them, or you can set a bevel modifier to work based on edge angle. If neither do the trick, try creasing and subdividing


Glossy BSDF not found in Blender 2.79 Cycles

Try changing "Blender render" to "Cycles render".

click at the region pointed, and select the render engine "Cycles render".


How to rename selected objects using python?

You can access them by iterating and assign the name property:

import bpy

for obj in bpy.context.selected_objects:
    obj.name = "newName"

Blender automatically add .001, .002 and so on to newName if another datablock of same type and name already exists. You may need to check a name pattern within the for-loop.

Another example - rename all Mesh objects in current scene that start with C (e.g. Cube, case insensitive):

for obj in bpy.context.scene.objects:
    if obj.type == 'MESH' and obj.name.lower().startswith("c")
        obj.name = "newName"


Making Vertical Gradient, then make top half transparent

You need two things: texture coordinates and a way to control them. The Vector Mapping will allow you to place the gradient texture where you need it. Then you can use multiple color ramps to mix color and a transparent shader.

Blend File


Good ol' fashion hook modifier.

One way to set up a hook.

Snap 3d cursor to control point of curve in edit mode, then in object mode add an empty.  With the empty selected, shift select the curve return to edit mode,  and "Hook to selected Object" (from space search).

Now you can animate the position of the hook to manipulate your curve.  Adding more hooks will give you more control.

Pretty crappy gif, but you get the idea.  The empty is hooked to the right control point of the default bezier curve. The empty is animated to rotate and follow a circular path.


Problem with Fracture Modifier deleting changes to mesh

In order to update the fractured mesh after making changes in Edit Mode, you either need to press the "Execute Fracture" button again, or check the "Auto Execute" checkbox so the refracture happens automatically after each change in the edit mode.

Note that depending on the mesh complexity and amount of shards the fracturing can take a bit longer, so I would recommend auto execute only on simpler meshes with less shards.


In this specific case you can fake it.
Since small monkey doesn't cast a shade in the shadow of big monkey ... you can just Z-Combine these two renders.
To fake the shadow casted by the big monkey on surface of the small one you can use Mix node > Multiply the Diffuse Indirection pass. It gives you an illusion - it is correct, but it is not, you are just lucky this pass looks like the casted shadow :)

But this will fail in other cases.
You can't get exactly the same result with totally separated files since the geometry of first one affects light bouncing on second one. So both renders needs to know about geometry of others. Some of those data can be saved in EXR (like Depth to be reused in Z-Combine node, or save Normal pass to try relight render), but there will be always parts totally impossible to composite in natural look.
So ... you would have to share object data info across those renders. Like by using Scenes (as suggested by HISEROD in comment) or View Layers ... or something similar that let you render thing separately, but already affected by shadows, indirect light, reflection etc. of other elements used in final composite.
Even with deep-compositing (used in other softwares) you can't mix everything, for the same reason. This deep-data just handles pixels in space in better way for combining, so these data contains also only pixels visible by camera, so back part of big monkey is not there to cast proper shadow with side light onto small monkey.


How do i make the camera in a scene look "low quality"?

There's many ways to achieve a low quality camera look, and as already covered in the comments, the most convenient ways to do so are low quality settings of the render: low resolution, low FPS if it's an animation, low sample amount, high compression of the image, resigning from filmic color space, and choosing many other sub-optimal or outright incorrect settings.
The actual challenge is to simulate a low quality camera realistically.
Motion blur
The easiest aspect to explain is exposure time: when you render an image in Blender, even in an animation, for each frame, all objects stay perfectly still and are rendered as such. Therefore even a flying helicopter's propeller will look still on a single image. Meanwhile, no camera is stopping the time while taking the picture, and most cameras will produce a visible motion blur:

You can enable Motion Blur in Render Properties tab, but contrary to the advises in the first paragraph, it will increase the render time.
Aliasing
Somewhat similarly, a digital camera has a sensor, which doesn't react to every single photon hitting it, but rather has a well for each subpixel, which collects photons, generating electrons inside, and then an electronic circuit calculates the subpixel value based on the charge density. This produces an averaged value of brightness for a given region. Meanwhile Cycles renderer works in an opposite way: not only it shoots a light ray outwards from the camera, but, more importantly, it's a single ray. A real camera recording a checkerboard moving away, will eventually perceive it as gray, as light coming from both black and white squares will hit the same well on the sensor.

I was able to render it with Cycles, because the default number of samples was enough to average the colors. However, watch what happens if I render with just 1 sample for each pixel:

The takeaway here is that the noise in Cycles is not the same as noise in a cheap camera - you won't get some artifacts like fireflies in a real camera. If you want to get a realistic grain effect, you have to use a high sample count and wastefully add the grain in post-processing. As far as I understand, the grain is a result of dithering data into a limited color space and then increasing the contrast, which moves these colors apart.


Set Driver Target Object from the Console

Working with drivers in Python isn't necessarily fun, unless you also create them directly from your script. If you do that, you can catch the driver objects as return values from the creation function, and use that object to create variables, set targets, and whatnot. Here is a quick example for how to do this:

import bpy

# get the objects from the scene
path = bpy.data.objects.get("NurbsCurve")
arm = bpy.data.objects.get("Armature")

# if both exist, create the driver
if path and arm:
    print('Objects exist, continuing by adding driver')

    # create a driver for all location channels
    drv_x, drv_y, drv_z = arm.pose.bones['Bone'].driver_add('location')

    # set the driver type to MAXIMUM_VALUE
    drv_x.driver.type='MAX'

    # create a variable to control something
    var = drv_x.driver.variables.new()

    # set the target object to the NURBS path
    # note that targets is a list, depending on the driver type more than one value
    # could be required
    var.targets[0].id = path

    # set the target property to the x location of that path object
    var.targets[0].data_path='location.x'

Note that I'm also unpacking the list to drv_x, drv_y and drv_z. This is just a way of naming the three driver objects directly at creation time. If you catch the result in one object called drv, you can access the driver for the X location by using an index: drv[0].

Regarding the Python Tooltip, the line above the one you quoted is actually more helpful: It says DriverTarget.id. This tells you that the object needs to be of type DriverTarget, then you'll find an id property on it. var.targets[0] is of such a type.


Try this, go into edit mode (where you can manipulate verts manually), you can try pressing tab to jump over. Tap 'A' should select all verts, then go to the Mesh menu, select symmetrize. Go back to sculpt mode, I think this should fix your issue.


Looks like the texture coordinates are very small, please check the UV space on your object. If it doesn´t have one, then you can also try switching from GPU to CPU render to bake.


How would I add bump mapping on an OSL shader?

Store in a vector/normal variable:

Let's suppose you've got a Normal texture:

OSL Code:

shader Bumped(
    normal NormalMap = 0, //the input (normal map vector starting "empty")
    output closure color Bumped =0 //the output (closure, AKA the final shader)
) {
    N = normal(NormalMap[0], NormalMap[1], NormalMap[2]); // store X, Y, Z component from NormalMap
    Bumped = diffuse_toon(N, 0.5, 0); //define closure
}

The code above creates a closure output named "Bumped" which is based on a "diffuse_toon" shader, whose normal information are stored in the variable "N" that we declared.

"Normal" is a vector-like variable (x, y, z).

To access the respective "i" component of the NormalMap use the syntax NormlaMap[i], as it's stored as an array.

X = NormalMap[0]
Y = NormalMap[1]
Z = NormalMap[2]

That said, you can shorten the code by avoiding the use of the variable N, just use your own like in this example.

shader Bumped(
normal NormalMap=0,
output closure color Bumped = 0
){
Bumped=diffuse_toon(NormalMap,0.5,0);
}

Here's a comparison between the result of the OSL shader and the one coming from Cycles nodes.


If anyone else was having the same trouble, I solved the problem by changing the viewport shading from solid to wireframe and it let me select vertices accurately.


"Add Action Strip" in NL animation panel is introducing mystery motion

The original armature and the problematic one aren't identical: the thigh bones have a different pivot point.
In this kind of rigs (pure FK) only the hip bone has loc infos, all the others bones are driven by rotations, and by parent-child relations.
If you move the pivot point of thoose rotations, the animation will start to be screwed up.
To solve, move in edit mode the heads of the thigh bones up on Z axis until they return to their original location (if this is compatible with your character)
If this is not possible, you have to either manually adjust the animation or (better) create an IK chain to lock the feet movements.


The first thing to check is that the object is visible. The eye icon beside the object name in the collection should be white/open. I'm assuming you checked this, but just in case.

Another possibility is that the object is large enough that it's outside the distance that Blender will display in the viewport. The viewport in Blender by default will only display 1000 meters deep (referenced from wherever you're currently viewing). Select your object in the collection, then open the properties panel with N and look at the dimensions. If they're a lot larger than that 1000 meter limit, Blender just isn't showing the object even though it's there. If that's the case, scale the object down until it's visible.

Blender 2.8 and later also has the ability to filter the viewport display by type. At the top right of the viewport there's a cursor/eye icon. Click that and make sure meshes are set to visible.

EDIT: Another thing that I have seen is some sort of disconnect between the object and it's corresponding mesh data. If you click the little arrow beside the object name in the outliner, does the mesh data appear? It should have the same name as the object, just with a green triangle icon in front of it. If not, it's an issue with the import or the file itself.

You can also try edit mode. If you enter it on the object and select everything with A does it say you have anything selected?

One final option is to add another object, such as a cube, and delete all its vertices in edit mode. Then in object mode, go to the Object Data tab of the Properties Editor and select the mesh data of your imported object.


I'm having trouble putting my windows views back, I tried a few things and they won't go back, they did before

The simple way (that doesn't involve careful dragging of a corner) is to right-click the line between two windows - eg, the horizontal between the two top-right frames - and select 'Join Area'. You can then left-click the panel that you want to close. Note, however, that as mentioned by @Timaroberts, you can only do this on frames that match in width/height - otherwise you have to join other areas until the panels you want to join match in size.


Why is light showing through a solid mesh object?

You need to make the bowl a collision object for the fire. With the bowl active, in the Physics tab click Smoke, then Collision. The collision type should be set according to what you do with the bowl. Static if remains still, Animated if you animate it using keyframes or drivers and Rigid if it has rigid body physics enabled.

You may also need to increase the Subframes setting for the emitter, to get higher accuracy to prevent flames to pass through the bowl between frames.

Here the bowl has collision enabled.

And here is doesn't.


The mesh has 2 vertex groups that deform the exact same area with the exact same weight, causing this weird stretching to happen. Simply fix this by removing the "knob" selected area from the "gunlockerdoor" vertex group (unlocking the vertex groups first, of course.)


Disable symmetry or pull the shape on the Y axis.


Boolean functions removed faces, is there a relatively quick way to fix this?

Blender can select non-manifold edges CtrlAltShiftM. The mesh analysis display options can also be useful for 3D printing.

You will find enabling the 3D Print Toolbox addon will be helpful. Click the Check all button to see how many locations have issues. While there is a Make Manifold button, be careful to check that the automated process doesn't add unwanted faces.

If you are in edit mode each item listed will be a button that will select the relevant areas.


What is the name of the vertex relax algorithm? "slide relax"

One method to do that:

Select all vertices that you want to be smoothed out,
hit CTRL+B to Bevel,
V to bevel vertices instead of edges,
press M until mode Percent is selected,
use the mouse wheel for setting the number of segments you like (an even number let's you keep the original vertices in place, an odd number splits them),
drag the mouse to adjust the bevel,
hit Return or press LMB once you're satisfied with the result.

Of course you can also hit CTRL+B, then Return or LMB to edit the values in the Bevel Properties Menu.
This description applies to the visualization. If that's a top view of e.g. a wall you'd like to smooth, then you don't have to bevel the vertices, but the corresponding, i.e. you can skip step 3.


How do I parent an object to a vertex which is modified by a curve?

Modifiers do affect Vertex parents. (Its in my answer on parenting). So what you are trying to do is completely possible.

Let me start with the setup. I have a curve object (black curved line top left in the image below). The selected object is the one that will be deformed by the curve, lets call it the "bendy bit." The object on the right is the thing I will vertex parent to the bendy bit.

With that out of the way, select the "thing" in your case the buckle, then select the strap (or in my case the bendy bit) that way the bendy bit is the active object. Now Tab into edit mode.

This is how it will look when in edit mode, with another object selected.

Now select three vertices. But not just any three, they have to be near the end with the thing (duh), but they also can not be in a straight line.
See if you select three vertices in a line, that line does not hold enough information to properly convey the orientation to the child object.

So with three vertices selected, like in the image above, press CtrlP > Make Vertex Parent.

Now when you turn on the display of the curve modifier you will see the thing on the end follows properly.  You edit the curve, and everything will update live.

Here is a gif of the whole process, just because people live videos:


How to adjust brightness and contrast on background images?

This isn't possible at the moment, you'll have to edit the images separately before loading them in.

You could use textured planes instead of background images, and edit the texture in a material, however this has the disadvantage of only working in material view.


Join overlapping objects/meshes into one surface in Blender

I would use the boolean modifier to union them together.

Lets say I have 3 overlapping spheres i want to make into one, connected object.

Select one sphere, and create two boolean modifiers, both set to Union, with the other spheres as the objects:

Hit apply, and you can now delete the original two spheres. the third sphere with the boolean modifiers should now be one mesh that makes up all 3 spheres:


Reflections from a EmissiveTexture and ReceivingShadow

Have a look to this node setup:

Try applying this to your Windows.
Hope this may be helpful.


Operator arguments - Identification if object names are not unique?

Operators should never have pointer properties and as far as I know there aren't any that do.

Such pointers would not be valid after deleting objects or after undo/redo steps, which would give problems in the operator history stack when repeating operators for example.

Operators that take datablock names should usually be avoided for python scripting. It's better to edit the data directly than going through operators when possible, there's probably only a handful of cases where you need to do this.


You have to set the falloff type from sphere to projected.


DopeSheet/GraphEditor : How to detect/change, with API, displayed frame range

The frame, value from the region coords can be obtained from view2d.region_to_view

import bpy
from mathutils import Vector
context = bpy.context
c = context.copy()
for i, area in enumerate(context.screen.areas):
    if area.type != 'GRAPH_EDITOR':
        continue
    region = area.regions[-1]
    print("SCREEN:", context.screen.name , "[", i, "]")
    c["space_data"] = area.spaces.active
    c["area"] = area
    c["region"] = region

    # region size
    h = region.height # screen
    w = region.width  #
    bl = region.view2d.region_to_view(0, 0)
    tr = region.view2d.region_to_view(w, h)
    print("region bottom left (frame, value)", bl)
    print("region top right (frame, value)", tr)

    range = Vector(tr) - Vector(bl)

Note from Getting area (region.view2d) pixel coordinates of 2D views (VSE, NLA) how to get the scrollbar width.

As for setting the region to a desired frame value range, I have found using bpy.ops.view2d.anything an absolute nightmare, of finding rhyme or reason, and instead have used the methods outlined here Focusing the graph editor area to a custom [frame, keyframe_value] range using bpy.ops.graph.view* operators in the graph editor, and I expect would work similarly in dope sheet for bpy.ops.action.view*.


Jaggedness in my rendered image in cycles rendering

These are antialiasing artifacts caused by low resolution and high contrast.
Renders in 4K/8K (or with lower contrast) are visibly less jagged.
Why:
A 2K render simply doesn't have enough pixels for antialiasing such a narrow and contrasty area.
8K Render - High Contrast (still a little bit jagged)
8K Render - Low Contrast (perfectly crisp edges)


Shading tab seems incomplete (Blender 2.8)

Go to the shading menu, you probably have the scene World Checkbox selected
If that's not the case, share your file to take a look at it


import bpy

class OBJECT_OT_object_make_proxy(bpy.types.Operator):
    """Tooltip"""
    bl_idname = "object.make_proxy"
    bl_label = "Make Proxy"

    @classmethod
    def poll(cls, context):
        return context.active_object is not None

    def execute(self, context):
        pass # More code here
        return {'FINISHED'}

classes = (
            OBJECT_OT_object_make_proxy,

          )

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

if __name__ == "__main__":
    register()

This works.

I do not understand what they mean to say about the new naming conventions here. Browsing the web it seems I am not the only one.

It says:

  This constraint applies to the bl_idname of each class (or the class
  name which uses it if no bl_idname is defined in the class).

  These are: UPPER_CASE_{SEPARATOR}_mixed_case, in the case of a menu
  the regular expression is:

    [A-Z][A-Z0-9_]*MT[A-Za-z0-9_]+

  The separator for each class is listed below:

    Header -> HT
    Menu -> MT
    Operator -> OT
    Panel -> PT
    UIList -> UL

  Valid Examples:

    OBJECT_OT_fancy_tool
    SOME_HEADER_HT_my_header
    PANEL123_PT_myPanel (lower case is preferred but mixed case is supported).

  At the time of writing this, names that don't conform to this
  convention will produce a warning on startup. Eventually we will make
  this into an error, eg:

  Warning: 'Oscurart Files Tools' doesn't contain 'PT' with prefix &
  suffix Warning: 'Oscurart Overrides' doesn't contain 'PT' with
  prefix & suffix Warning: 'Oscurart Animation Tools' doesn't contain
  'PT' with prefix & suffix

So this might mean that the bl_idname should actually be
something like "object.MY_ADDON_OT_some_object_operator"
It still requires a '.' to be there so object.OBJECT_OT_something_something does not seem to make much sense to me. Let's make this a new question as well, maybe someone else knows.


How to control Global transform orientation with F-curves?

No it's not possible to adjust bones directly in global space with f-curves, because they are always parented to the armature or to themselves into bone chains. Such behavior you want only works on objects which transformation does not depend on other objects.

However by changing the rig design you can control the bones in global space with constraints:

Here the root bone follows global transforms of an empty. To control a bone further down the chain you would need to setup an IK for that bone in chain.

But what you probably want is to have the bone animate locally, then at some point swith to global control and transform it precisely and then back switch to local am I right.. You can do this by animating the constraint's influence - the procedure:

The constraint's influence is 0 and the bone is controlled locally. The Empty is at some random location.
Align the Empty Transforms to the bone with copying the bone's matrix to the Empty's matrix in Python Console:

a.) Select bone: mat = bpy.context.active_pose_bone.matrix

b.) Select Empty: bpy.context.active_object.matrix_world = mat

Now when they are aligned keyframe the influence to 1. The bone is controlled globally with that Empty now.
When you are done with global select the bone and hit Ctrl+A > Apply Visual Transform to Pose. Then keyframe the bone and influence back to 0.


How can I have separated Layers in Texture painting in cycles?

The related comment that cegaton provided shows an answer (via a screenshot of the cycles node editor) in the link that identifies how to add more than one image texture to affect your material.

I think more specifically to you is how to manage this in texture paint mode.
The easy answer is add all of the images you wish to use for all of your different reasons first.

If these images do not exist you need to create them as new images in the UV/Image editor and save them to a file first.
You can do this in the node editor if these images already exist by just adding the Texture >> Image Texture node, and selecting that image in the dropdown selection of the node.

Once you have all of your images in your blend, you just need to make sure that they are present in your material.

They need not be connected to anything yet, it just needs to exist.
Once they exist go into texture paint mode within the 3D viewport, and manage the active image by selecting it via the slots tab on the T menu at left.


How to see the actual commands blender runs

Consult the docs

What you are seeing in this instance is an object property. Blender uses operators as "command" clearly recognizable from bpy.ops. namespace.

For the case shown::

It has ID object of type screen (bpy.types.Screen) an instance bpy.data.screens["Default"] akacontext.screen  and a property name of texture_context

This means we can find it from the screen object following chain of collections or pointers screen.foo.bar[0].blah.texture_context where none of foo, bar, blah will be an ID object. It is this chain that can be abbreviated to "...". Without can produce ridiculously wide tooltips.

(Reminder to self) Before pecking about aimlessly in the python console why not consult the docs.. Using the right click and view docs outlined here will take you directly to the help page.

Searching the old** API manual using just the property name.

we find that texture_context is a member of bpy.types.SpaceProperties as shown in tooltip.  A space belongs to an area, an area belongs to a screen.

You set the space of an area when selecting the editor type, in this case we want the area of type  'PROPERTIES', aka the Properties editor which has an  active space of type SpaceProperties  (tip can toggle an using area.type = 'PROPERTIES')

Scripting

Here is an example using the py console (bpy.types.SpaceConsole).

>>> for i, a in enumerate(C.screen.areas):
...     if a.type == 'PROPERTIES':
...         i, a
...         break
...
(1, bpy.data.screens['Scripting']...Area)
# bpy.data.screens['Scripting'].areas[1]

>>> a.spaces.active.texture_context
'MATERIAL'

>>> space = a.spaces.active
>>> space.texture_context = 'WORLD'

If your script is going to be invoked from a button or menu in the properties area, can use.

space = context.space_data
# or
space = context.area.spaces.active

albeit this may seem convoluted, you'll find blender follows a pretty consistent data structure.

** Note

I believe this property has been removed from 2.80 and searching the new manual will direct you to the API changes page.


Is there a way to make emission shader not looking flat?

As Jachym says, you can get a good result with the Principled BSDF (choose a color for Emission, a Strength value will be implemented in the next Blender):

You could also mix the Emission with a Diffuse, but it looks like it needs some subtle tweakings to keep the bloom and prevent the color to be burnt:


The idea behind your loop works.

The direction should probably be calculated with mathutils.Vector.angle so that you don't have to consider the vector length:
angle = normal.angle(verts[y] - deformed_verts[x], 0)

I used the Animation Nodes setup attached below for the example. The principle behind it translates to code like this:

for outer_vertex in outer_vertices:
    influencing_vectors = []
    for (i, inner_vertex) in enumerate(inner_vertices):
        normal = inner_object.data.vertices[i].normal
        distance = distances[i]  # would be supplied by your script
        angle = normal.angle(outer_vertex - inner_vertex, 0)
        if angle < pi/8:  # or whatever angle you choose
            influencing_vectors.append(normal * distance)
    translation = functools.reduce(operator.add, influencing_vectors, Vector((0, 0, 0)))
    if len(influencing_vectors) > 0:
        translation /= len(influencing_vectors)
    outer_vertex_new = outer_vertex + translation

I didn't include any falloff for the angle which you might want to do.
The performance isn't that good and I expect this to be problematic for larger meshes. My original suggestion would have been to try ray_cast for each of the outer vertices. But the result of the ray_cast method will differ (and look worse when there are large curvatures).


I just rebuilt the mesh for this character. Smooth shading creates odd eye shadows

I think your normals are not facing the same direction as @moonboots said.
You can check them by using two buttons in the viewport overlay panel
The "Face orientations" button and the "face normals" button (at the bottom, see screen)
both of them will allow you to check in which direction your normals are facing.
Don't forget to set an appropriate size when you're using the "face normals" option.
You can also recompute them by going into : (when in edit mode)
Mesh -> Normal -> Recalculate outside


Compositor: obtain facing from normals pass to affect glare?

This works like a dream. ridiculously simple too. the normal node can be found under vector in the add node menu(shift-a).


Animate object along path and deform accordingly

Curve Modifier

As stated in the Blender reference manual about the modifier:

  The Curve Modifier provides a simple but efficient method of deforming
  a mesh along a curve object.

If you are working with a single object, make sure to fill the Deformation Axis field of the modifier with the correct value (X in my case, the object has no trasfomation) and to give your deformed object and path enough subdivions:

Then, you just have to animate the position of your object along the picked axis (X in this case) and optionally the rotation along the same axis to match the motion of the pencil shown in your example.

In my test file a took advantage of the keyframe modifier called Generator to set up a linear function for both:


Examples for "Chain Actions" Node in Animation Nodes

Let say you have two actions, one of which is a Follow Spline Action with a duration of 50 frames, and the other is an action from an  empty's transform. Chaining both actions means combining them such that the second action starts after the first action ends, in this particular example, this means that the object will follow the spline for 50 frames, then the object will start following the empty. You can see this from the following example:

Notice that the object doesn't strictly follow the empty, that's because we enabled the Relative option. This option allows the second action to start from the location where the first action ended.


Pink texture basically means that the texture is missing. I guess this file doesn't contain these textures.
EDIT: I downloaded this model, and there is separate textures folder.


Does subdivision surface modifier and box modeling require retopology?

In general you'd want to retopo and create a low poly game model. That is for two reasons:

You want to animate the character. Since moving the character makes flaws in the topology very apparent retopo is necessary. The topology should allow natural movement of limbs and facial expressions.
For efficiency reasons you don't want to go way overboard with the vertex count. While hero props and characters may be high in details, you should only use real geometry were it's necessary. Everything that doesn't impact the actual shape can be compensated by textures, namely normal maps and PBR materials. This is done by "baking". You create a low poly model and bake the details from the high poly model into the texture.


Let's say your setup on the compositor is like this:

Unplug the input from the mix node and make the colors black and white and render the mask as an image sequence.

And import them as an image sequence node:

And use the sequence instead of the mask node.

Make sure the cyclic and auto refresh options are enabled.

The mask will be used in an endless cycle:

The main disadvantage of this solution is that if you need to make changes on the mask's shape you have to re-export/re-load the images.


Make sure your models are not intersecting.  Your low poly model should be slightly larger than your high poly model and no part of the high poly model can protrude through any part of your low poly model.  Your model is kind of complex to do all at once.  You may trying breaking it down into smaller pieces (selecting parts in Edit mode and hitting P: By Selection) and baking them all to the same map individually(Uncheck CLEAR in the Bake Panel), then when all parts are baked, rejoin them by selecting all and hitting Ctrl J.


Your problem might be:

1) Good position of the roots and good orientation of the bones, so that, when they rotate, they do it in the good axis and in the right direction

2) Proper rigging of the eyelids.

Let's rig 2 demi-spheres that could be your eyelids:

Create an object with 2 distinct demi-spheres.
Create 1 armature with 2 bones with their root approximately at the centre of the sphere. Call these bones "eyelid_top" and "eyelid_bottom".
Parent the object to the armature with a ctrl P > Set Parent To > With Empty Groups. Now you've created 2 vertices groups called "eyelid_top", and "eyelid_bottom" but they haven't been assigned to any vertice of the mesh yet.
Select your object and in Edit mode, select the top demi-sphere and assign it the vertex group called "eyelid_top", then assign "eyelid_bottom" to the bottom demi-sphere. Now these meshes should move if you move the bones.
Now to constraint the bones, add them a Limit Rotation constraint on the axis you want, choose Local Space.
You could only constraint the top bone and choose to assign a Copy Rotation constraint to the bottom bone, so that when you rotate the top eyelid it automatically rotates the bottom eyelid. Don't forget to click on the Invert option of the constraint.
In Object mode rotate the whole armature on the Z axis so that it is oriented the way you want, according to the way they should be on your character's face.

Of course your eyelid meshes and bones should be part of the whole mesh and armature of your character, I'm just showing how to do it as if they were apart

Now let's imagine you've created eyes for a human face, they will be directed in the same direction as the head. If you need sideway eyes for another character, they will be directed sideways, and your bones need to be as well.


The moving objects have a keyframe:when Blender load the file, it replaces the objects at the keyframed position.

Delete the keyframe. Using right click on the location:

And place again these objects where they should be.


Selecting other vertices connected to a selected vertex of a mesh object

What you're looking for is the 'select_more' operator under bpy.ops.mesh:
bpy.ops.mesh.select_more(use_face_step = False)

We're using the use_face_step = False parameter, to ensure it only selects linked vertices, not linked vertices via linked faces.

If you don't want to use operators, you can also use bmesh in a slightly longer script:
import bpy, bmesh

# Assuming active object in edit mode (for bmesh.from_edit_mesh)
mesh = bpy.context.object.data
bm = bmesh.from_edit_mesh(mesh)

# Get active vertex (assuming there is only 1 selected)
last = bm.select_history[-1] # history.active doesn't exist anymore...
                             # and last is a list, of one element

# Select all connected edges
for e in last.link_edges: e.select = True

bm.select_flush(True) # will update face selection

# this line is needed to close bmesh and see the result of the selection
bmesh.update_edit_mesh(mesh)


Global Slow-mo effect - Animating Time scale

You can do it in the graph editor. Select all elements in the scene and place a locrot keyframe where you want the remapping to start. In the graph editor place the cursor on that frame and select all keyframes only to the right of the cursor. Change pivot point to 2d cursor and scale on x by 8 (s-x-8). Go to where you want the mapping to end and place another keyframe on all elements in the scene, place the cursor on that frame, then select all only to the right and scale on x by 0.125 (s-x-0.125). You then only need to finesse the handles on these keyframes to give you the lead in/lead out you're looking for. Much easier if the scene can jump straight to slo-mo because you can just set handle type to vector for those two frame numbers.
edit: video link https://youtu.be/lxdQogx6y40


Particle emitter not displaying during rendering

Go to the particle settings of the icing -> Render -> Check "Show Emitter"


I want the domain of a fluid simulation to abosrb the mesh (stop rendering splashes) as soon as it touches the bottom of that domain. Possible?

Yes, that is what outflow fluid objects are for. Add a plane to the bottom of your simulation and set the fluid type of the plane to "Outflow".


Bending a model with Simple Deform vs Lattice that's Simple Deformed

Different out-of the box outcome
My wild guess would be that you'll simply not get the same deformation. Propotional editing is using a smooth falloff by default, while the Simple Deform modifer is bending linearly...it's a nuance, but if you try, there is a different shape as outcome. Same for the lattice modifier. With the Simple deform modifier you basically get one thing, with the other you have more room, they are more flexible.
At the end I think he is suggesting to use the tool beacause without it you'll not get the exact deformation he was looking for.
You can easily experience the difference by doing the inverse: try to get a perfectly circular deformation using proportional editing. You'll find more challenging than you expect.

Another reason could be that you cannot straight use the Simple deform modifier, but you'll have to rotate your object from the XY plane to get a proper result, while in all the tutorial the shield is right on that plane.


it would be easier if you shared your file, but maybe you should choose another topology at the beginning, i.e. a cube that you subdivide instead of a UV sphere:


Hold down the Shift key and then drag from the top right hand corner of the 3D viewport
as if you were wanting to split the screen, this will result in opening a smaller floating window of the 3D viewport which you can then drag to your second monitor and then set full screen.

Or Open the Window menu at the top left and choose the New Window option.


How do I join two separate objects so I can edit them as one mesh?

How to join two meshes with the Join command

It is very easy to join two meshes together using the Join (CTRLJ) command so that you can add a face between them.

Here is how you do it: Select both meshes at the same time, then press CTRLJ:

Now both meshes are one object and in Edit mode, you can add a face between them.


Is it possible to deselect vertices in Python?

if you want to run it in object mode:

import bpy
vert = bpy.context.object.data.vertices
face = bpy.context.object.data.polygons #not faces!
edge = bpy.context.object.data.edges
#vertices can be selected
#to deselect vertices you need to deselect faces(polygons) and edges at first
for i in face:
    i.select=False
for i in edge:
    i.select=False
for i in vert:
    i.select=False
    if i.co.x > 0:
        i.select = True


Is there a quick way to reset a .blend files windows and settings to default

When you open the file there is an option to load the UI from the file which is about to be opened. By default this is enabled, deselecting this option will keep the current settings. See image below.

Edit - Updated with comment by @Samble

In the user preferences under File there is an option for Load UI - this is the default that is used each time you open a file. If it helps you can turn it off and manually turn it on only when you want to load the UI from a file.

Once the file has been loaded it will use the setting pulled from .blend file and to my knowledge there is no "Reset to Factory UI" or "Reset to Start-Up UI" option like you can do for the start-up .blend.

Should probably be put in as a feature request as I a lot of people share files and doing it by accident is annoying as you lose your current UI and then have to either reload factory setting or your own blend file to get back your UI before re-open the file you want to load.


How do I connect the vertices in the same mesh/shape?

Join them Using Alt+M.

To do this select the Top Left Vert.

While holding Shift, Select the bottom left Vert.

Then Do Alt+M, and select At Center.

Repeat for the Verts at the right.


Distorted mesh when I use a bevel object on Nurbs curve vs. Bezier curve

Your bezier curve based balloon object does not have its scale applied, it scaled 0.25 on all axis, that is why the bevel is not at its true size compared to the bevel object. The NURBS based one is the correct one here.

If you do apply the scale Blender will try to compensate automatically by changing vertex bevel radius to keep the same size so applying scale alone won't fix your issue.

You then have to enter Edit Mode, select all curve vertex and explicitly set the bevel radius back to 1 as described in my answer

A a side note, also have in mind that your NURBS curve made from many points is too dense, and will invariably lead to self intersections and rendering and display artifacts caused by the large bevel section relative to point density.

It will also lead to an unnecessarily heavy geometry which is too dense with no discernible advantage. I'd strongly advise severe cleanup or using a cleaner modelling method. See my answer about cleaning up curves for some tips


How to make dynamic paint work with rigid body interactions during animation playback

I found a workaround that may be acceptable while sacrificing some dynamic behavior.
What I found out is that you can turn a rigid body simulation into a string of keyframes via a built-in function under the object menu in object mode called "rigid body" > "bake to keyframes".
I had realized that the dynamic paint seems to work only with a keyframed brush, but I wanted that authentic, physics feel to the simulation, thus the solution was to bake a rigid body simulation and then turn it into keyframes. Lastly, I removed the rigid body physics from the brush sphere, pressed play, et voila!

Hooray!


How do I draw a circle in a location in my video

In blender's VSE we don't have exact control of timing, we can only align to a frame. To get a timing of half a second you will want to use an even number of frames, at 24 fps 12 frames will be 500ms.

To get the dot in place you want an image of the dot, save it as a png so you have the alpha channel to easily clear out everything but the dot. In the VSE add the image, ensure it is above your video, then in the strip properties N set the blend type to Alpha Over and set the frame length what you want.

To position the spot, under strip input, enable Image Offset and change the X and Y values until it is in place. You could also create an image the same resolution as your video and place the dot where you want it.

Then smile as you see the dot on your video.


copy and paste dynamic effect in graph editor

You can do this by adding two keyframes. One at frame 0 and the other where you want it to stop scaling.
When you've done that, click on the first marker and press T and change the interpolation to bounce.


If you have imported the mesh, then maybe it's just how this UV is supposed to be used.
It looks like the problematic area is where there's supposed to be hairs. My guess is that the texture you're using isn't used on that area.

Then, either it's a matter of different UV sets, in which case you just might check in your object's Data tab if you have several UVs, and unse them accordingly in your material :

Either you just have to select those faces, and assign them to another material :

Or maybe both.


How to bend a sinusoid into a circle in Sverchok?

use simple translate node and x+1 hack to fit vertices


If your computer has proper cooling and therefore doesn't overheat, it won't damage the GPU.

It will have an unfavorable impact on your electricity bill and carbon footprint though.

Whether a sample size that high is actually appropriate is another question. You probably don't need that many samples or there are computationally less expensive solutions to reduce noise, e.g. the denoiser.

The rendered image will take up disk space when you save it. How much it will use depends on the resolution, the image format and its settings. The higher the resolution, the larger the file. For an overview of image formats and their disk space usage, take a look at the last section of this answer.


How to get the end node of a tree in python?

I have experimented with it and this is what i come up with :

The active_output is not a node type so it will not contain the active output node, it is NodeSocketInterface ( i don't know what this is )
as you have found you can set multiple nodes is_active_output to true and this will be misleading, but apparently this is handled automatically by blender like this : the last selected output node (in the UI ) is set to be the active output and all other output nodes get their is_active_output property cleared.
if you set is_active_output to True for multiple nodes the first one in the node_tree.nodes list is the active one.
if you clear the is_active_output of all nodes then the first output node in the list node_tree.nodes is the active one.

to handle this in code i have two functions to get/set the active output :

def set_active(my_node):
        nodes = my_node.id_data.nodes
        for node in nodes :
            if node.type == 'OUTPUT_MATERIAL' :
                node.is_active_output = False
        my_node.is_active_output = True

def get_active(nodes):
        for node in nodes :
            if node.type == 'OUTPUT_MATERIAL' and node.is_active_output :
                    return node
        for node in nodes :
            if node.type == 'OUTPUT_MATERIAL' :
                    return node


Cutting a Notch at the top a Rounded Cylinder

If you choose to go the route of booleans, then here is the method I would use.
Quad cap the cylinder to begin with. Delete the Ngon faces top and bottom, and grid fill them with Ctrl+F > G with the edges selected.

Next you can add modifiers. Order is important, so here is the modifier stack:

Bevel and Weighted Normal are the key ones that help here, they will help eliminate alot of the shading issues that you will run into relying on boolean workflows.
Finally, enable Auto-Smooth in  Properties ‣ Object Data ‣ Normals

This is roughly the result you should end up with:


process of combining 2 meshes into one not in object mode but in edit mode?

What are you trying to do? Deleting the cone, adding it in object mode, and then using ctrl + j just gets you back to where you started. Its the same as adding it in edit mode.

Assuming you want to join them to one flowing mesh.

Select the edge loops with alt + rightclick
Search in the space search menu for bridge edge loops
Select it from the search

Before:

After:


Image is appearing flat in render but fine in camera view

The top picture is fully rendered using cycles I guess while the bottom one is from solid view. You can use the principled shader with
Metallic: ~0,8
 Roughness : ~0.8
Anisotropic ~0.3
To achieve a similar effect. This is just an estimate you need to play around with it

The top picture looks more plastic like. Probably because you didn't use the Metallic. Also the white background is flattening it. You seem to have no light source but the surrounding and this creates no dramatic shadows like in the bottom picture

At least that'd what I could figure out from what you provided


The denoiser options are in the Properties Window > Render settings > Sampling > Denoising.

You can choose what kind of denoiser to use.

NLM is the original denoiser (native non-local denoiser), that runs on any computing device.
OpenImageDenoiser is Intel Open Image Denoiser, that runs on CPU
In this section you can enable the viewport denoising as well.


How to rotate/line up an object to an axis

1. If you rotated your object in Object Mode :
Hit Alt+R to reset rotation
2. If you rotated your object in Edit Mode :
That was a bad idea, cause you can't do .1.
Generally, if you want to rotate/scale your whole object, do it in Object mode.
If you want to rotate/scale a part of your object (some verts/faces), do it in Edit mode.
Ok but it's done now. What can I do ?
You can try box-selecting the vertices that you know should be aligned, and align them manually (s/z/num0 to align them on Z). It's tedious, that's why you should always prefer .1.


Rigify Super Finger: Wrong action center for scaling

This is not a Rigify problem. In the screenshot, I can see that you have set the Pivot Point to 3D Cursor. See image.
Bounding Box, Individual Origins or Active Element will give you the result you're after. Definitely invest some time and learn about the Pivot Point modes.


You're absolutely right for GEs you want to keep the seam count als low as possible
It's a bit hard to tell from that angle, but

The one with the arrow, you can definetly remove. The one with the circle, I guess there you can save yourself some seams. Just think of the jpg as a piece of paper, if it's possible to cut and then wrap the paper around your model, there will be little to none distortion. That means all the vertical ones along the cylinder are crucial.


Why is mirror and subdiving co-acting wierdly?

In order to get smooth surface transition with Mirror and Subdivision modifiers you have to remove the internal faces where the mirrored mesh connects.


Movie clip editor messes up with my colors

Just posting this so I can post the pic. I can't be 100% certain this will solve your problem, but you likely find some success playing around with the color management settings. See below:


What is causing my bones to display irregularly?

I am not sure...
But this happens to me sometimes (quite often) and I eventually realized that the problem isn't always in pose mode - it lies in bone edit mode
In short
See if they look the same in edit mode
This might not be the problem, but give it a shot.


Select the bone you want to stretch and set its amount of stretch. The amount is calculated in relation to other bones which have some, so if only one bone has some stretch, even a little value leads to a total stretch.

If you want a "Squash and stretch" behaviour you can duplicate the lower leg bone, put off the IK constraint, add a copy loc constraint pointing at the IK constrainded bone and then add a stretch to constraint, pointing at the ik controller (foot) bone. Set the IK bone as non deforming, and use the stretch to instead.


How to easily toggle a Boolean property?

This can trivially be done as:

obj.show_name = not obj.show_name

Which basically says: if True, make it not True (i.e. False), else if False, make it not False (i.e. True).


How to check if a PointerProperty has a value?

Value is None if not set.
The value of a pointer property pointing to an ID object, ie one that  is not defined with a type derived from a PropertyGroup  is None if not assigned.
>>> bpy.types.Object.foo = bpy.props.PointerProperty(type=bpy.types.Object)
>>> issubclass(bpy.types.Object, bpy.types.ID)
True

>>> C.object
bpy.data.objects['Text']

>>> C.object.bl_rna.properties['foo'].fixed_type
<bpy_struct, Struct("Object") at 0x5b41620>

>>> C.object.foo is None
True

>>> C.object.foo = C.object
>>> C.object.foo
bpy.data.objects['Text']


Aligning empty object with Bezier curve point using Python

Use the follow path constraint

When it comes to putting an object at either end of a curve, the follow path constraint, with fixed location, follow curve. An offset factor of 0 is one end, 1 the other.

import bpy

context = bpy.context
bez = context.object

bpy.ops.object.empty_add(location=(0, 0, 0))
mt1 = context.object
fpc = mt1.constraints.new(type='FOLLOW_PATH')
fpc.target = bez
fpc.use_curve_follow = True
fpc.use_fixed_location = True
# dupe it
bpy.ops.object.duplicate()
mt2 = context.object
mt2.constraints[0].offset_factor = 1


Although all the above answers are correct they all include unnecessary steps, you don't need to convert your curve to a mesh, nor do you need to extrude or joint anything, you can cut you mesh model directly from a curve using Knife Project operator.

Follow these steps:

Create curve object for cutting
Select Curve object
With curve still selected Shift select the mesh to be cut so it remains the active object
With both still selected press Tab to enter Edit Mode on the mesh object
Adjust the view as necessary, the cut is view dependent.
Use the Space Bar menu to search for the operator Knife Project
Adjust settings if necessary from the redo panel (tool shelf or F6 key)

Take care of the resulting topology afterwards, this will generate NGgons and overall improper topology unsuited for most end uses without further refinement.
Also adjust your viewpoint prior to cutting as the operator is view dependent.


Blender API : pass collection as parameter of python operator

Campbell give me an answer in Blender mailing list.
Here is the proposed solution :

import bpy

class Item(bpy.types.PropertyGroup):
    name = bpy.props.StringProperty(name="Name")

class ExamplePanel(bpy.types.Panel):
    bl_label = "ExamplePanel"
    bl_space_type = 'VIEW_3D'
    bl_region_type = 'TOOLS'
    bl_category = "Example"

    @classmethod
    def poll(self, context):
        return True

    def draw(self, context):
        layout = self.layout
        op = layout.operator("object.example_op", text="Test")
        for src_item in bpy.context.scene.collection:
            dest_item = op.collection.add()
            dest_item.name = src_item.name

class ExampleOperator(bpy.types.Operator):
    bl_idname = "object.example_op"
    bl_label = "Example Operator"
    bl_options = {'REGISTER'}

    collection = bpy.props.CollectionProperty(type=Item)

    @classmethod
    def poll(self, context):
        return True

    def execute(self, context):
        for item in self.collection:
            print(item.name)
        return {'FINISHED'}

def register():
    bpy.utils.register_class(Item)
    bpy.types.Scene.collection = bpy.props.CollectionProperty(type=Item)

    it = bpy.context.scene.collection.add()
    it.name = "item1"
    it = bpy.context.scene.collection.add()
    it.name = "item2"

    bpy.utils.register_class(ExampleOperator)
    bpy.utils.register_class(ExamplePanel)

if __name__ == "__main__":
    register()


What rendering framework does blender use?

Blender, by default, uses its own rendering systems, depending on selection.

The offline renderer is a path tracing engine called Cycles.
The online renderer is a rasterization based engine called Eevee.
Both rendering engines harness CPU and GPU to different degrees, including the OpenGL, OpenCL, and CUDA based GPU libraries.

Blender used portions of Bullet for some physics calculations, with other approaches for its particle system interactions.


From my quick and superficial testing both 3Ds and Obj seem to apply transformations and discard that information. DXF discards it too.

Collada DAE however keeps transformation matrices non applied, and even keeps instancing information. That is if one object were linked to the other using the same object data that relationship is maintained.

FBX also maintains both transformation matrices and instance relationships


I need help organizing and setting up textures and shaders on my mesh, how do I know which texture map is which?

Here, try a setup like this. I think this is closer to what you're looking for (although I don't know what the end result is supposed to look like).

The texture you're using for your "normal map" seems to have most of (if not all) the useful information in the red channel, thus that's what I used. The data contained isn't sufficient for the use of a Normal Map node, but the B&W data can be used for a Bump Node.  I don't think I need the RGB to BW node, but I wanted to be sure for the bump to be as accurate as possible. As you can see, I had to soften it greatly by mixing it with white before it became anywhere close to realistic (unless the person in the model has really bad skin).
I took the same channel and inverted it to form the basis for the roughness, but had to mix it slightly with white to "even it out" - otherwise the face had distinct "oily-looking patches" that didn't quite match the sheen of a real face. Oh, and a face has no need for metallic values (unless there are piercings, glasses frames, chains, earrings, shrapnel, etc...), so I removed the input.
Lastly, I plugged the BaseColor (minus the Ambient Occlusion) into the Subsurface Color, and increased the strength a bit to make the model look less plastic. On the topic of Ambient Occlusion, don't forget you have to turn it on by checking the box in the render properties panel first, for it to have the proper effect.
This may not be perfect, but I hope it at least gets you closer.
NOTE - upon further inspection, the green channel of the second image texture seems to be an Ambient Occlusion map. You can either use it as color the input for the Ambient Occlusion Node, or just use the one we created from the heightmap (they are both very similar). The Blue channel contains pure black, so I assume it was meant for the Metallic input (0 value). You can connect it or just leave the input blank with the value at 0.


How to get dynamic updating of quad views on multi-monitor screen?

You could link the location and distance of your main 3d view to the quad views with Python using scene_update_post handler. The good news is that it updates the quad views every time you navigate, the bad news is that it updates the quad views every time you navigate. :) This does what you need, but also requires some processing power pretty much constantly:

import bpy
from bpy.app.handlers import persistent

for w in bpy.data.window_managers[0].windows: # let's find what's what
    for a in w.screen.areas:
        if a.type == 'VIEW_3D':
            if len(a.spaces[0].region_quadviews) > 0: #if quadviews are active
                quad_views = a.spaces[0].region_quadviews
            else:
                main_view = a.spaces[0].region_3d

@persistent # This makes it stay if another file is opened
def update_handler(dummy):
    for every_view in quad_views:
        every_view.view_location = main_view.view_location
        every_view.view_distance = main_view.view_distance

bpy.app.handlers.scene_update_post.append(update_handler)
#bpy.app.handlers.scene_update_post.remove(update_handler)

You could just use it as an operator assigned to some shortcut so it only does it's thing once when you press a button:

bl_info = {
    "name": "Quad View Updater",
    "author": "Martynas Žiemys",
    "version": (1, 0),
    "blender": (2, 79, 0),
    "location": "shift + num .",
    "description": "...",
    "warning": "",
    "wiki_url": "",
    "category": "3d View",
    }

import bpy

class ViewSelectedPlusQuadViews(bpy.types.Operator):
    """View Selected Plus Quad Views"""
    bl_idname = "3d_view.view_selected_plus"
    bl_label = "View Selected Plus Quad Views"

    @classmethod
    def poll(cls, context):
        return True

    def execute(self, context):
        #bpy.ops.view3d.view_selected() #Maybe center selected before?
        for w in bpy.data.window_managers[0].windows: # let's find what's what
            for a in w.screen.areas:
                if a.type == 'VIEW_3D':
                    if len(a.spaces[0].region_quadviews) > 0: #if quadviews are active
                        quad_views = a.spaces[0].region_quadviews
                    else:
                        main_view = a.spaces[0].region_3d

        for every_view in quad_views:
            every_view.view_location = main_view.view_location
            every_view.view_distance = main_view.view_distance
        return {'FINISHED'}

addon_keymaps = []
def registerKeymaps():
    wm = bpy.context.window_manager
    if wm.keyconfigs.addon:
        km = wm.keyconfigs.addon.keymaps.new(name='3D View Generic', space_type='VIEW_3D')
        kmi = km.keymap_items.new('3d_view.view_selected_plus', 'NUMPAD_PERIOD', 'PRESS', shift=True, alt=False,ctrl=False)
        addon_keymaps.append((km, kmi))

def unregisterKeymaps():
    for km, kmi in addon_keymaps:
        km.keymap_items.remove(kmi)
addon_keymaps.clear()

def register():
    registerKeymaps()
    bpy.utils.register_class(ViewSelectedPlusQuadViews)

def unregister():
    unregisterKeymaps()
    bpy.utils.unregister_class(ViewSelectedPlusQuadViews)

if __name__ == "__main__":
    register()

You could save this to a file with .py extension and install it as an add-on.

I tried to detect changes of the active object with scene_update_post handler and then view selected in the quad views, but it seems there is some bug in Blender and working with bpy.context inside the handler crashes Blender. So if you wanted to center the quad views I can only offer a method using a keyboard shortcut. There should be a way to do it automatically, but the bug prevents it. If someone is interested in this, here is the code that crashes.

You can copy this into a .py file and install it as an addon to be able to view selected in all quad vies with Shift+Numpad .:

bl_info = {
    "name": "View Selected in Quad Views",
    "author": "Martynas Žiemys",
    "version": (1, 0),
    "blender": (2, 79, 0),
    "location": "shift + num .",
    "description": "...",
    "warning": "",
    "wiki_url": "",
    "category": "3d View",
    }

import bpy

class ViewSelectedInQuadViews(bpy.types.Operator):
    """View Selected In Quad Views"""
    bl_idname = "view3d.view_selected_quad"
    bl_label = "View Selected In Quad Views"

    @classmethod
    def poll(cls, context):
        return True

    def execute(self, context):
        context = bpy.context.copy()
        for w in bpy.data.window_managers[0].windows: # let's find what's what
            for a in w.screen.areas:
                if a.type == 'VIEW_3D':
                    if len(a.spaces[0].region_quadviews) > 0: #if quadviews are active
                        for every_region in a.regions[4:]:
                            override = context
                            override['window'] = w
                            override['area'] = a
                            override['region'] = every_region
                            bpy.ops.view3d.view_selected(override)
        return {'FINISHED'}

addon_keymaps = []
def registerKeymaps():
    wm = bpy.context.window_manager
    if wm.keyconfigs.addon:
        km = wm.keyconfigs.addon.keymaps.new(name='3D View Generic', space_type='VIEW_3D')
        kmi = km.keymap_items.new('view3d.view_selected_quad', 'NUMPAD_PERIOD', 'PRESS', shift=True, alt=False,ctrl=False)
        addon_keymaps.append((km, kmi))

def unregisterKeymaps():
    for km, kmi in addon_keymaps:
        km.keymap_items.remove(kmi)
addon_keymaps.clear()

def register():
    bpy.utils.register_class(ViewSelectedInQuadViews)
    registerKeymaps()

def unregister():
    unregisterKeymaps()
    bpy.utils.unregister_class(ViewSelectedInQuadViews)

if __name__ == "__main__":
    register()


How can I clear the weight from outsiders vertex when weight painting?

Let's say we have a nice and happy cube

Oh no they got sick!

The doctor said that this cube needs to lose some weight and eat healthy paint :D

One way the cube decided to lose weight was to select all the vertices, it set the strenght to 0 and presses Shift + K  to apply the strenght to all the vertices

The little cube was surprised how quickly this method was, and so he wondered "is there another method" so he browsed on Google about health diets and found this other method with same results:

Select all the vertices you want to clear their weight, now select the vertex group of the bone that you desire to remove, now click on Remove and it will remove all weight from that bone

The little cube was very happy and decided to live a healthy life, found love, got married, and had children


Moving my camera around an constructing object

I don't know much about Python if that's what you're asking, but if you aren't and want to zoom the camera out through your animation, try moving the timeline cursor to the first frame, keying "I" and choosing LocRotScale. Then move to the end of your animation and repeat.

If you want to rotate the camera around the object, follow these instructions: How can I animate the camera in a perfect circular rotation around a fixed position?

I'm not sure if they work together, but they might. If they don't, look into camera focal length.

Hope this helps and happy Blending!


to multiply Matrix with Vector, order is important:

v2 = matrix * vector

see: mathutils.html#mathutils.Vector


That's the result of Triangulation of NGons in the game engine, it doesn't effect the original geometry.

in game mode

Back out of Game Engine, the geometry is not changed. If it bothers you the solution is to make the geometry without NGons in the first place. This means cutting up the NGon into triangles or quadrangles. A fast way to convert an NGon to the elementary polygon types is:
Ngon to Tris

in edit mode

select the ngon

press Ctrl+t (this creates Triangles)
should generate something like this

Tris to Quads

With a set of Triangles selected press Alt + j , and blender will try to make quads from the geometry.

Sometimes it isn't possible to convert all selected Triangles into a set of Quads. invariably there will be times when the algorithm leaves a few Triangles, even though geometrically it would be possible to neatly Quadify all selected geometry. This is not a bug (really, we could argue about this), but rather a limitation in the algorithm.
this might produce geometry like this:

The algorithms that do this don't have the benefit of our eyes and brains, to make the best decisions. Sometimes you have to do the tessellation yourself


Only break object when colliding with another?

If you're unfamiliar with masking, read up what you can for your particular version of Blender.  See Here for a general description.
The example here is using a 3D mask and rendered in OpenGL but plain ol' vanilla 2D masks work just as well.

As for the cell fracturing, that was simply a cell-fractured cube the same size as the mask and hole.  It was placed inside the wall. A few particles were emitted from the same area for small debris effect.
The hole in the wall can be any shape you wish.  This one came from a subdivided cube.  It was given the 'Randomize' beauty treatment so it ended up jagged on all sides. (Tools panel)
That was then sliced in Edit mode so it ended up like a thick slice of bread, two flat walls (the bread) with it's crusts still jagged.

The flat front face was removed and used for the mask, the back one deleted and the jagged sides left as they were to give the hole it's depth.

The front face (removed) is moved to a separate layer which is designated to be the Masking layer.
Anything placed in there automatically becomes a mask and will cut a hole through the other layers .
This particular hole will obviously need it's walls but the mask is going to take them out.
We get around that by doing two renders to mix in the VSE.  One overlaying the other.
The 1st is called 'Top'.  That is alpha layered so the hole is rendered as transparent.
The 2nd is called 'Bottom' and that doesn't need (or want) an alpha layer, nor does it include the mask layer.  (An extra brick was inserted in the wall for effect)
.
When the two are mixed in the VSE, 'Top' on the upper strip, 'Bottom' underneath, we get the result shown at the top of this answer.
Note - the Top strip has to be set to "Alpha Over" in the VSE at right.  (Press N)


Missing "Shading [Smooth|Flat]" menu on the left of the screen

If you want to shade in Edit Mode, you need to go to the Shading/UVs tab. From there, you can select to smooth the selected Faces, Edges, or Vertices. Or, if you want to change the whole object to Smooth Shading, you can do it from Object Mode how you usually would. Hope this helps]1


Blend files are saved where-ever you chose to save them, opening Blender trying to save again will show the default location.

Blender also has an autosave function that saves backup files to a temporary directory, see Blender autosave


ID mask noisy when using Volume Scatter for World volume

ID masks are generated from sampling as far as I understand. The quality of them depends on the amount of samples set for the render. If it's noisy, you should increase the amount of samples for the render. It is worth noting that ID masks are also 2 bit black and white images so there is no anti-aliasing at all and that makes the usefulness of them very limited (some might even say 'completely useless'). For glare effects they are completely adequate, however, if you want good masks with anti-aliasing  for other purposes you should render them separately with shade-less materials made with emission shaders assigned to objects in the scene or another a lot better option would be to use Blender 2.80 that supports Cryptomatte that is way more convenient and powerful solution for generating masks.


Is it possible to get a camera solve of large camera dolly?

Yes you can track a shot like that, as long as you decide to put some effort into it.
The shot has enough information to create 3d information, as it clearly shows parallax. You should be able to get a pretty accurate reconstruction out of it.
The most important part is that you track the island in the far background (and maybe some clouds that show enough contrast on the edges),  then parts of the middle ground (the metal bars on the beach) and close elements on the street. The elements that are in the foreground close to the camera are going to be the hardest elements to track, since they move too fast, so you will need large search boxes for the tracker. You will need to track a lot of different points in the street, that come in and out of the frame.
Place your trackers manually, don't rely on the autodetect features of blender. You shouldn't track moving elements like the waves.
3d reconstruction works by estimating the placement of points in the 3d world by computing the changes of the objects on the images. Objects that are close to the camera move faster than those far away. Computing the difference in speed, blender can determine if objects are close or far, and where the camera is with respect to the objects.
Blender's 3d tracking capabilities are quite sophisticated, but you need to understand how to make them work for you. The most important aspect is that tracking is done as accurate as possible.
You will need to babysit the trackers and make sure they are not slipping or tracking unwanted features.
The most challenging  aspect of this shot are the elements that are occluded by passing objects (the bicycle, the palm trees will block the island, etc). Those blocked elements need to be tracked in different segments when the elements are visible, and then have the trackers joined, so that blender understand that it is dealing with the same element. Other elements can be tracked using offset.

confused?
Read very carefully trough the following links (yes, all of the text), all the information you need is there:
How can I get better results when doing camera motion tracking?
and Joining 2D tracking markers with an offset


I don't think that is an option, but here are some general tips.
In Rendered View, there's a button in the top right to pause rendering.

In Render Properties there's a Simplify section you can use to cut down several of the most taxing effects without having to make any changes to the objects in the scene.

If the problem is not the scene geometry, but rather the amount of time it takes to run individual samples, then I suggest a render region with Ctrl + B.  You could also use Local View with / to focus on your selection.


You're rightly looking in File > User Preferences > Input - it is indeed there, just obscured:

Just set Rotate View and Move View as you like.


Whenever I use the particle system to emit from volume, it just ends up emitting from the faces. Is this a bug?

The end frame for your simulation is the same as your start frame. That means that your particle simulation will run for one frame (in which it will emit the particles), and then stop playing.

Simply change it from 1 to the desired number of frames you want your simulation to run for (if you don't know what this is, then just set this to the number of total frames your project is set to render, which I can see is 250).

Simply put, set the Frame End to 250 in the Particle System Properties tab.


The Problem is that the camera is too far away for the default camera to see.

To fix this, change the clipping under the camera settings to something higher until you can see the object you are looking for. Depending on how far away the object is, you might have to set it quite high.


If I understand it right.

Make path, edit it as you need.
Make Bezier Circle.
Select Path and under Object data tab select Bezier Circle as Bevel Object.

Now you can resize Bezier Circle as you need.


You can separate into loose parts like @gandalf3 said P > Separate By Loose Parts then have multiple flames in one domain, like this:


Since 2.82 my computer completely crash on random occasions

For me this sounds like your graphic card uses more power than the power adaptor can deliver. And then the system becomes unstable. This would fit to your new graphics card and the kernel power error, even when it started with Blender 2.82 first. Have you checked if your power adaptor can deliver enough power to the system?

To calculate how strong a power adaptor needs to be, calculate the maximum watt values for all of your components in your pc together, and add 10% to 20% on top to have some reserve. There are some small users that are usually not worth a mentioning. A ssd usually uses around 2 watt. Same goes for ram. But a motherboard comsumes easily around 50 watt nowadays.


Align viewport view to object/Move object to viewport view

Viewport to object
To align the viewport to the object, select your desired object and hit CtrlNumpad0. This sets the selected object as the active viewport camera. Hit Numpad0 to return to your normal view, and return back to the object view again with the same key. Repeat this procedure on the camera when you are done in order to use the camera as normal.

Object to viewport
To align the object to the viewport, first set the desired object as your active camera and return to your view (steps above), then hit CtrlAltNumpad0 to snap the object set as your active camera to your current viewport view. You can also fly the view with ShiftF to move the object around with the view. You may need to enter wireframe mode by hitting Z (while not in fly mode) in order to see.

This is the same process you may already be familiar with when aligning the camera, but it also works on other objects.


Problem solved with global variable and function which registered as blender timer.
status = {'prev': None, 'new': None}

def set_status(text):
    try:
        status.update({'prev': status['new'],
                       'new': text})
    except:
        pass

def status_timer():
    try:
        if status['new'] != status['prev']:
            bpy.context.workspace.status_text_set(text=status['new'])
        return 1
    except Exception as e:
        return None

and add to register() function
bpy.app.timers.register(status_timer)


Install animation nodes addon, there's a text > object separate node that works as an operator...

more info:

you just need one node, that acts as an operator, press separate or update...
the algorithm counts the number of splines on each glyph to do it correctly;
node also allows you to have text / curve or mesh output


Please make sure you have installed the CUDA driver for your mac:
http://www.nvidia.com/object/mac-driver-archive.html

I have a 750M in my MacBook Pro (2.8 GHz Intel Core i7) and it renders about as fast as the CPU as long as the render job's RAM requirement doesn't exceed the RAM on the video card. In fact, I often render overnight with both CPU and GPU concurrently as separate command lines.


You will want to modify certain parameters of the cell fracture tool. To change the numbers of fractures increase the Source Limit. To avoid all fractures looking like squares increase the noise. I would increase is all the way to 1, this will look the most natural.