Difference between make local object and make proxy

Make Proxy adds a new object and sets it as the parent of the linked data. This allows you to transform the empty while still retaining the link to the original blendfile.

Make Local Object copies the object data from the original blendfile to the new file, severing the link.

It is probably better to use Make Proxy because:

It keeps the link to the original file. If you change the original file, the linked object will be changed as well.
It keeps your filesize small. Instead of having to copy the mesh data (all the verts, etc.), the only data that's stored is a sign saying "look over there."
Otherwise, you're basically just Appending (ShiftF1).

A slight correction to your edit: you can edit the object. You cannot, however, edit the mesh. Here's why:

When you first Link an object, you are linking the Object datablock (cube icon). Linking the object also causes it to bring along the Mesh datablock (triangle icon), because it relies on the Mesh datablock. If you have any materials, textures, etc., those will be *Link*ed as well.

When you Make Proxy, the Object datablock is cloned, but the Mesh datablock is not. This is why you cannot edit the mesh: the Mesh datablock is still linked.

You can edit anything that is a property of the object datablock, such as the position, rotation, scale, material slots (but not any linked materials themselves), modifiers, constraints, particles, etc. You cannot modify anything that is part of the mesh datablock. Examples of things you cannot edit include:

vertex groups (and, thus, Weight Paint Mode is disabled)
UV maps
shape keys
skin radii

These basic concepts also apply with other linked data types as well.


Ok, tell me if i'm wrong (believe me I'd love to be wrong on this) but it turns out what I was trying to do is not possible because the diffuse texture is flat, and even when faking the normals, it still looks unrealistic. But it works if you bake them separately with just diffuse and color.


I am not sure what the texture is, but the color needs to go to Metallic, Specular, and Anistropic with the alpha in the roughness.


It looks like you need to adjust your camera clipping distance.

Select your camera and change the clipping end until you can see the full geometry.

If that doesn't work it's likely that you changed your viewport clipping.
In the viewport press 'N' to open up the side bar. Under 'View' edit the clipping distance as shown above.

You can change the clipping based on centimeters by changing the unit preset to centimeter. This can be done under the 'Scene tab':


Exporting my Blender models texture to unity

Place the . blend files inside the Unity project's Assets folder (or a subfolder inside Assets). You can open them for editing by double-clicking the file in Unity. ...
Place all the texture files in a subfolder named Textures in the same folder as the . blend file.


Object animate and deform follow path not working

I figured it out. I had a serious middle-aged moment. As each new triangle is added, it needs to be keyframed in. Doh!


Usually you're provided with a zip file or something, and you can hit this Install button in Preferences -> Add-Ons and choose the file.


Dynamic Paint is the answer, but it seems to be a little tricky here. But this works...
For your "mirror', it should be a canvas of type waves.

The object should be fairly subdivided, so I used a Subdivision Surface above the Dynamic Paint in the stack.
Here is the modifier stack for our mirror:

Next, I used an icosphere for the Brush in this example.
The settings are at the default.

Finally, the brush (icosphere) is animated from one point to another to contact the canvas, scale is also animated to increase on contact. Here, we have a cube parented to the icosphere, something like this may be an option in your scene. Constraints such as Copy Transform, and Limit Scale may be useful for that purpose. This is the result:


What happens to my 3d model when I apply the mirror modifier ? it adds extra vertices

The mirror modifier has a center.  You need to place your model on the correct side of its origin. You may just create vertices on one side of the local origin. You only need model on one side ... the left or the right.  There are more flexible alternatives than this but this is the good way to start.
In the image lets assume I am trying to make a sphere with just half a sphere. The blue sphere is almost correct.  I wanted the separation to be a little obvious visually for purposes of explanation.
The next attempt is where the model has too much separation.
In the last model I have unfortunately placed vertices on both sides of the X axis.  This may be what you did also.
You can either remove the mirror modifier. Or make a selection on the undesired vertices and grow the selection with Control+, then delete the vertices.
I wonder if you are seeing another mesh in the same place as the bird.  I suggest you change the names of the mesh to something like Bird so as to explain the issue better.


You seem to have some sort of mirroring applied: all your vertices on the left half of the mesh are just mirror images of the vertices on the right. Therefore, the median point of your selection is not at the middle of the mesh, because it only takes into account "real" vertices, the ones on the right. When you "Scale", your vertices will all move away from that point.

Make sure that your 3D cursor is somewhere on the middle plane (it looks like it already is), then select "3D Cursor" as your pivoting point:

Finally, you should be able to { S, X, move your mouse } to scale.


Why is the colour picker displaying tinted colors?

In Scene tab set Display device to sRGB.


Information
Use an game-property with type integer.
Blend File (made in a UPBGE 0.2x release)
https://blend-exchange.com/b/AEQKXKbY
Screenshot


Using bump maps in with the stencil brush in cycles

I use a bump node to plug the image into, and then route it to the Normal of the shaders like the image I have here


Is there a way to access a bpy.types.Operator value

Window Manager keeps track of registered operators

Lets say we add a property to the simple operator template, and make it register - undo

class SimpleOperator(bpy.types.Operator):
    """Tooltip"""
    bl_idname = "object.simple_operator"
    bl_label = "Simple Object Operator"
    bl_options = {'REGISTER', 'UNDO'}
    xxx : bpy.props.StringProperty(default="foo")

Invoke it from the UI

Then in python console use WindowManager.operator_properties_last

>>> op = C.window_manager.operator_properties_last("object.simple_operator")
>>> op.xxx
'ggggg'

There is a also a collection of operators used in WindowManager.operators  If the operator has register undo we can find the value used, for example having invoked bpy.ops.object.duplicate_move() in the UI

>>> C.window_manager.operators['
                                MESH_OT_snap_faces']
                                OBJECT_OT_duplicate_move']
                                OBJECT_OT_editmode_toggle']
                                TEXT_OT_run_script']
                                VIEW3D_OT_select']
                                VIEW3D_OT_select']
>>> op = C.window_manager.operators['OBJECT_OT_duplicate_move']
>>> # how much did it move
>>> op.macros['
               OBJECT_OT_duplicate']
               TRANSFORM_OT_translate']
>>> op.macros['TRANSFORM_OT_translate'].properties['value'].to_list()
[0.7582358121871948, 1.8491952419281006, 0.10750504583120346]

The collection is keyed using the idname

>>> bpy.ops.object.duplicate_move.idname()
'OBJECT_OT_duplicate_move'

Note that the value of properties here will be the as used only if the operator has 'UNDO' option, otherwise it will return the default value of the property.

Note the template class name is SimpleOperator but really should be OBJECT_OT_simple_operator to match its id name "object.simple_operator" as per the naming convention

From https://blender.stackexchange.com/a/159444/15543


My particles are halfway inside the floor, can I move them up the z axis?

The easiest way to fix your problem is (from the file you uploaded) rotate your bullet object on the x axis by -90 degrees in object mode, then apply the rotation on your bullet with ctrl-a.

The reason your bullets are like that is because blender thinks that (for some reason) the y axis is what should be facing up. Rotating the bullet as describes above sets the origin point of the bullet on the bottom relative to the y axis.


How do I copy an object without copying the weights?

I figured out the answer. I had to remove the armature modifier from the mesh. I found that out here, http://blenderartists.org/forum/archive/index.php/t-235499.html


Change circle segment depends on diameter

Your operator does nothing. It's missing an execute or invoke function.

To do what you want to do, you could create a modal operator:

In its invoke function you would create a circle curve object.
In it's modal function you would change the U resolution of the curve and the scale, for instance based on mouse movement
when confirming the modal, you would convert the curve to a mesh (if that is what you want)

Check the template scripts in Blender to understand how operators are structured.


Beginner Rig Problem - Model spinning around root bone

That is the expected behaviour. The root bone is the parent of every bone in your armature, by moving the root bone you are also moving every bone in your armature.

Technically it isn't moving your entire model, it is moving every armature bone that in turn moves each corresponding part of the model. This is like moving the upper arm bone and having the lower arm and hand follow along.

Often the root bone is placed at the bottom of the armature and is only moved to position the entire model. You may want to add another bone to be the root and set it as the parent to your lower spine bone.


When adding a new object the rotation is random

Open User Preferences (Ctrl+Alt+U)

In the Editing page go to the New Objects: Align To: Option.

Change it from View to World.


Changes in the UV Editor Not Flowing Over To 3D Viewport

Nevermind.  Just found out that in my UV maps, it wasn't showing the second UV map I had created.  Thanks everyone for taking a look.


How do I tile my textures when I am in Texture-Paint Mode?

You can use a brush texture (1) for which you assign your brush image (2) and use it in texture paint mode and with the "tiled" option (3). So you have your object texture painted with it (4).

To have a more regular result, you can also assign the brush image to your object (in its material (5)) and stretch its UV map (6):


Blender started lagging when using more (single) bones

Had a similar problem, but not with rigging. Check the size of your .blend file and see if it seems too large for your average model. I once made a simple hanger for clothes and it's size was over 15mb. I deleted few objects and managed to find out what was causing it.
If your file seems too large, try deleting the object/bone that makes blender lagspike the most when you select it and save the file somewhere to see if that fixed it.

PS: wanted to comment, but you apparently need 50 points to do that...


Are themes for Blender releases prior to 2.77 compatible with 2.77?

They should work well enough between versions for the most part.

Only thing that might happen is that older themes may be missing color definitions for newer themeable elements that were introduced in later versions and have no color information for them.

The closer the versions are the least trouble is to be expected.

Other than a few undefined colors everything else should work fine.


Compositing node not showing up in render

One way is to create two render layers and then mix them in the compositor. For instance

Here is how I made my example

Create the entire scene on layer 1 as usual. For the example I placed a sphere in front of a cube.
Move the object that you want the glow on to another layer.  For the example I moved the cube to layer 2.
In properties -> Scene modify the 'Scene' layers to contain both layers and 'Layer' layers to contain only layer 1

Add a new Render Layer.  Being lazy I left its name as "RenderLayer.001". Adjust its 'Layer' layers to contain only layer 2 and disable 'Use Environment'


How to rotate a bone around multiple times? It just snaps to closest rotation?

In the 3D View properties panel (activated with N), or in the Properties panel > Bone > Transform, switch the rotation mode from Quaternion to XYZ Euler, otherwise you will have the kind of problem you describe.

If you want your rotation to be linear (and not accelerate and decelerate, which will happen by default), go in the Graph Editor, select all and click T > Linear.

If you want the rotation to be infinite, select all and press shiftE > Linear Extrapolation.


Bone parenting without offset using Python?

Set basis and parent inverse to identity.
One of the simplest ways to do this is to set both the basis matrix and parent inverse matrix to identity, to ensure all transforms are those inherited directly.
Getting no feedback re what parenting "without offset" is, have included link to
https://blender.stackexchange.com/a/112856/15543 which has a number of methods to parent, either keeping current global location, (the operator result in question EDIT) or snapping to the transform of the parent as shown here..
The confusion is over the term offset. Code below puts an object at its parents transform with no "offset" from it, no local transforms.
Parenting, while maintaining the object in place, could be considered as setting the offset from child to parent, before parenting.  If turned on relationship lines are a visual rep'n of the parent to child offset.
Code below is same
as 'SNAP_IDENTITY'
import bpy
from mathutils import Matrix

ob = bpy.data.objects
child = ob['Cube']
parent = ob['Armature']
bone = parent.pose.bones['Bone']

child.parent = parent
child.parent_type = 'BONE'
child.parent_bone = bone.name

child.matrix_basis = Matrix()
child.matrix_parent_inverse = Matrix()

Please also notice that the parent bone  setting requires the name of the bone, not the bone itself.


To address the goo goal.

(01) Fluid Particles

This link

http://wiki.blender.org/index.php/Doc:2.6/Manual/Physics/Particles/Physics

Fluid Particles

(02) Some mesh animated using Wave Modifier and or Armature.

(03) Particles

(04) Fluid Simulation

Most preferred listed at top.  Suit to your tastes.

... Some would have dynamic 3D gravity qualities.

Some video sites have video instruction on these topics.

You stated you are "newly started".  Please assume that the above is work the first time .. but not too much work.  It might be a lot of work for some other people.


The option to select similar area is not available

You are not in face selection mode you can't select faces because Blender can't determine any area to select by.

Switch to face selection mode and the option should become available


How do I select and deselect only one object?

If you want to select with Left Mouse button instead the default Right Mouse Button you need to change this option:


RENDER tab property> FILM tab, mark "make transparent".


What is the difference between Translucency and Transparency?

Transparency allows light to pass through without refracting or scattering it, while translucency scatters light to some degree.
What the manual says about the Transparent shader:

Transparent BSDF without refraction, passing straight through the
surface, as if there was no geometry there. Useful with alpha maps for
example. This shader affects light paths somewhat differently than
other BSDF's. Note that only pure white transparent shaders are
completely transparent.

The Translucent shader is more like a Refraction shader with a high Roughness and an IOR of 0 (no refraction) It is also a little bit like an SSS shader in that light is scattered when passing through. (The main difference between the two is that the translucent shader scatters light more uniformly)

To visualize this using the manual images:

The Transparent shader lets light straight through:

The Translucent shader scatters light:


The most likely reason is the blender version. Make sure you are using the same version. Ducky is using version 2.80.75. I, personally, use 2.90 and I have the same settings as Ducky has.


Any way to move two symmetrical edges / vertices / faces in opposite directions?

If your model is aligned with one of the axes, you can scale your components (edges / verts / faces) along that axis if your pivot point is set to median point (default).


is there an inverse function of the circle function (w --> Loop tools) to form a square form a circle?

You could use a Cast modiifer > Cuboid, Factor: 1, and apply it if you want to. It doesn't distribute vertices evenly between the corners, though... and still only plays fair with a nice number of vertices ..


Add an empty to your scene, then add a copy rotation constraint to all of the objects using the empty as target.


How do I find global rotation values of a child object?

Add a Copy Rotation constraint to the object you want to rotate. In constraint panel, set Target to that child object;
After seeing it being aligned well, CtrlA >  Visual Transform;
Delete that constraint, since you don't need it anymore.

Edit:

If you just want to "know" the global rotation info, you can simply AltP > Clear and Keep Transformation, then you will see the visual rotation applied, which is the global rotation. After getting what you want, you can simply CtrlZ to undo.


How do I make a surface look like a polished one in Blender?

This polished look can be achieved with a black diffuse shader and a white glossy shader (roughness = 0), letting a fresnel node set the mix between them using a mix shader.


You can join the parts to a single object and animate shape keys. Not 100% what you asked for, but this could be a good work arround.


How to use Bridge edge loop to create arch

Just increase the Number of Cuts parameter in the operator settings panel (F6), and adjust the Smoothness value to a desired outcome.


How can I tell if my processor is being fully utilized on renders?

In the render settings under the performance tab there is an option that says threads, with auto-detect all the cores will be used, alternatively you can select the amount of cores if you select Fixed.

To check all of your processor is being used just open task manager (Ctrl+Shift+Esc) and you should see 100% cpu usage.


Okay so I've prepared this blend file: http://www.pasteall.org/blend/40069

It's a crude attempt at recreating your scene, but essentially, we have a large plane (which we want to bake our geometry to), and a number of smaller planes (which represents the geometry you want to bake)

Open the file. Select the large plane, tab into edit mode, select all vertices, press U, and then select "Unwrap"

Right click on the edge of the 3D viewport, select "Split area", and in the new area that appears, switch to the UV image editor. In the UV image editor, select "New" from the toolbar along the bottom, and create a new image:

Next, in the materials tab, create a new material, and under the "Surface" panel, click the little dot to the right of the "Color" widget, and select "Image Texture":

Click the dropdown to the left of the "Open" button, and select the image that you created in the UV image editor. Next, tab out of edit mode, and back into object mode. In the 3D viewport, select all the smaller planes, and then select the large plane. Make sure you select the large plane last, as this will make it the active object in the scene (indicated by the brighter shader of orange):

Next, under the Render tab, scroll down to the Bake panel, change the Bake type to "Diffuse Color", check "Selected to Active", and set the margin to 0px, and click "Bake":

Now, in the UV image editor pane, you should see the geometry of your scene baked onto the texture. However, you will notice that only some of the geometry has been baked to the plane, which I think is what's happening in your first screenshot. To capture the remaining geometry, increase the "Ray Distance" value under the "Bake" panel (it's located just under the "Selected to Active" checkbox). In my example, I have set "Ray Distance" to 3. Now, click "Bake" again, and this time, all geometry will be captured in the bake:

Does that solve your problem?


Breaking a cylinder into sections in blender

There are several ways to do so. As you mentioned, if you really need to fill sections after cutting, I would suggest a tricky way:

Create a mesh that contains expected sections. Add Solidify modifier to this mesh, set Thickness to 0.00001. You can leave other options as default;
Add Boolean modifier to cylinder, set Operation to Difference, and Object to the section mesh. Then press Apply;
Delete the section mesh, Tab into cylinder object, select all elements, P>By loose parts to separate each sections apart;
If you want to recalculate their origins, just ShiftCtrlAltC > Origin to Geometry.

P.S.:
In the latest version (the coming 2.70), Boolean modifier supports ngons, which will generate better and cleaner result.


There is an exporter for paper models, it even has a Blender Wiki Page with in depth usage guidelines.

For more information and plenty of examples of successful use cases you can read the BlenderArtists thread by the developer of the script.

Add seams like you would for any regular texturing job, experiment with simple geometry first. Here is an icosphere.


Where can I find a full and comprehensive knowledge about all nodes?

A good source of all the nodes is Blender manual:

Compositing nodes
Cycles material nodes
Blender Internal material nodes

There are also examples of usage, which is most important when it comes to nodes. What matters is the whole network, not just how individual nodes work.

Some other sources:

the Cycles shader encyclopedia - just shader nodes examples
Chocofur shader examples - full material examples
Shader Forge - collection of paid and free shader breakdowns
PBR by CynicatPro - pbr material breakdowns covered also by BlenderGuru here and here.

Some non-bundled addon nodes:

Animation nodes
Sverchok nodes
LuxRender nodes

For the complete Blender resources database head over here.


How to make clothing and body move as one?

In my opinion you should :

Apply the rotation of the armature (CtrlA > Apply Rotation)
Get rid of the part of the mesh you don’t need, for example the arms, as you have sleeves, but keep everything if needed (but you’ll have to do more corrections after parenting), and anyway keep a unchanged version somewhere.
Join all the objects together with CtrlJ
Unparent the object with AltP > Clear and Keep Transformation
Parent With Automatic Weight, make the needed corrections in Weight Paint mode or in the Properties panel > Object Data > Vertex Groups list and with the Assign button


First of all, you have to check Selected to Active in Bake properties (Image below). Second, you need to have the plane, on which you want to bake the cookie UV unwrapped (go to edit mode,open UV/Image Editor window, select the texture on which you want the cookie to be baked, press U and choose Unwrap). You also need the plane to be in front of the part of the cookie, that you need to be visible. So in this case, on top/in front instead of bottom/back. Then you need to make sure, that in Distance property you have appropriate number. Looking on your scene, I think that 1-2 would be enough. Next, in object mode, you need to select cookie, then Shift select the plane and press Bake.That should do the job.Also if you need to bake only color, without shadows and lights, choose Textures in Bake Mode.

Here you have shown step by step, what you need to do


how to set white or black background of textures transparent

Alphas are far more nuanced than people would typically know, or choose to acknowledge.

An associated alpha image is effectively a record of emission (RGB pixels) and occlusion (the alpha channel). If we view such an encoded image without alpha, it would appear as nothing more than the image composited against black.

If we apply this logic to your question, we can see that we have the emission recorded fine. We simply don't have the occlusion. In short, with a composited on black image, we are already halfway there. The second half would be via a generation of the alpha channel.

There are two manners to generate alpha, and given that this is a fire-like explosion, it is a perfect example.

When captured in an image, fire has both occluded areas, where particulate and such occlude a given ratio of a pixel's window. That is, we could consider a pixel grid as being a wire screen, and the unknown geometry that lands across any particular grid as being the occlusion ratio. Where there is solid geometry occluding the pixel grid, we set the alpha to 100%. Where there is zero occlusion, the alpha is set to 0%.

But what about fire and the atmospheric glowing emission that isn't occluding at all? That would be 0% alpha and any nonzero RGB value.

So in your above image, you have two ways to set alpha:

You could simply use a math node to deduce the maximum value in the RGB triplet, and use that as your Set Alpha factor. After doing so, your image would be 100% correct when using associated alpha overs (aka the horrible term premultiplied).
If you used a more nuanced approach, such as converting to BW via the node, you would end up with an alpha channel that would represent averaged luminance, which will result in pixels whose alpha is lower than the RGB values. When using a proper alpha over instruction, the fire would occlude the degree of alpha and emit the remainder.

The following demonstrates such a node tree that covers both versions, the upper being the alpha that will embody a glowing bit of emission and some occlusion, with the lower being a more "vanilla" alpha where the max(RGB) represents the amount of knockout:

And the result, in animated form to demonstrate differences:

If you try either of these techniques, you will likely find that the latter has a more nuanced look because it is closer to a physical reality within the confines of our image manipulation models.

Always remember, there is only one true alpha, and it is the one that can represent both occlusion and emission. It is not unassociated (aka the awful terms straight, key, etc.)

Hope this helps...

PS: This is why frequently element plates will always be shot against black, not white. If it isn't going to be keyed, black is the ideal background.


Alright so after around 8 hours of trying to figure this out, I've done it but I don't know why.

The normals apparently got screwed up at some point. I had to recalculate the inside, and then the outside, and flip the normals after that.

And now it works perfectly.
I don't know why this works, but I'm thankful that it does.


Is it possible to retrieve the rotation component of a single video tracking marker?

If you use the documentation of a more recent version of Blender, you can find a lot more options are available nowadays. There is no rotation, but you do get the coordinates of the search box.


joining multi objects in blender to make one object

It sounds like you objects may be scaled or have non applied transformations

Joining with Ctrl + J is done in object mode, selecting all objects you want to join and selecting the "receiving object" last.

Try applying all transforms to the objects before joining with Ctrl + A > Apply Rotation, Translation and Scale.

After that also try converting all objects to mesh with Alt + C > Mesh to apply all modifiers and deformations they may have. Only after that can you safely try to join.

Otherwise post your blendfile so we can look at what might be wrong.


Rendered aspect ratio different from the viewport's camera view

The image has been rendered with an aspect ratio using non square pixels.

The default setting is X=1 Y=1 so that the image is rendered undistorted using square pixels. You only need to alter with this settings if you are using some display that uses non square Pixels, like old TV or are integrating 3D elements into video shot with anamorphic lenses.

Info from the manual:

  Unlike regular computer monitors, some screens (typically older TV sets) do not have the square pixels making it it necessary to generate pre-distorted images which will look stretched on a computer but which will display correctly on a TV set. It is important that you use the correct pixel aspect ratio when rendering to prevent re-scaling, resulting in lowered image quality.

for more info see here: http://helpx.adobe.com/premiere-pro/using/aspect-ratios.html


Cycles. Box on font line unable to delete

After you converted the text to a mesh(That's how it was when i downloaded the .blend), there was more than one, many in fact, squares overlapping it's self.

Just select all, press W and select remove doubles. Then, select the square again and delete it.

A step by step guide:

Select the text.
Enter Edit mode.
Select all and then press W then press Remove doubles.
Press Z to go into Wireframe mode.
Press C to turn on Circle select.
Select the square using Circle select.
Press X or Delete and then press Vertices .
Exit Edit mode, and it should be done. :)

Link to the process.


UV Editor, Blurred vertex, edge, face UV selection

This is normal. The blur is to indicate what edges the vertex is (and more importantly isn't) connected to. This can be very useful when two vertices are on top of each other for whatever reason.


How to bake a particle animation over 250 frames

I think I understand what's happening in the video and why this is causing confusion.
For some simulations (such as Rigid Body) you set the range of frames on the cache and Blender will bake all frames within that range.
For particles, things are slightly difference since particles can exist for only a part of the range of frames - so the cache is automatic in that it will store those frames that have particles that are within the range of timeline frames. ie, you do not need to explicitly specify a range of frames to cache.
In the example video, the timeline frames are amended to the range 1 to 500 but the particle system is still defined as having particles emitted from frame 1 to frame 200 with a life of 50 for each particle. This means that the cache actually bakes 251 frames - with the last frame (251) to indicate purely that all particles have died. You can see the frame count in the right-hand panel just after the bake has completed.
So, all you need to do to have 500 frames of particles (after you have amended the timeline frame range end at frame 500) is to change the particle system to emit particles that persist after the 250th frame - eg, increase 'End' to 500 or increase 'Lifetime' to, say, 500. Running or baking the simulation will result in particles for the full frame range.


Replace the me.update with bmesh.update_edit_mesh(me)
Made a MWE from question code and tested on default cube with a single face in vertex group named "Group".
Recommend adding imports and a default dummy setting, which will make it easier for answerers to test, answer.
An edit mode bemsh is "bound" to the mesh and rarely likes it if you try and do anything to the underlying mesh data while it is active.
import bpy
import bmesh

class  SUBDIVIDE_OT_Vertexgroup(bpy.types.Operator):

    bl_idname = "subdivide.vertexgroup"
    bl_label = "Bake Displace modifier"

    def execute(self,context):

        ob = bpy.context.active_object
        mat = ob.active_material
        vertex_name = "Group"
        vg = ob.vertex_groups.get(vertex_name)

        if vg:
            bpy.ops.object.mode_set(mode='EDIT')
            bpy.ops.object.vertex_group_set_active(group=vertex_name)
            bpy.ops.object.vertex_group_select()
            me = ob.data
            bm = bmesh.from_edit_mesh(me)
            border = [ e for e in bm.edges if e.select ]
            bmesh.ops.subdivide_edges(bm,
                    edges=border,
                    cuts=1,
                    use_grid_fill=True)
            # me.update()
            bpy.ops.object.vertex_group_select()
            bmesh.update_edit_mesh(me)
        return{'FINISHED'}

bpy.utils.register_class(SUBDIVIDE_OT_Vertexgroup)

bpy.ops.subdivide.vertexgroup()


Can threading.event be used as an event in an modal operator?

No, there's no way to pass it to the operator's modal method, so you can't mix both event types. Using a Timer is a better option.


Set scale of object by giving distance between two points

If you need to do this based on an off-axis dimension, or some other measurement like the area of a face, you can use the add-on "measureit" (included with the Blender 2.79 distribution), which can be found in the 3d view section of Add-Ons in the User Settings.

When this is activated, a number showing the measurement you want appears on the 3dView and is updated in real time. You can select all the points of the object in Edit Mode and resize the object while watching this measurement change, then stop resizing when the measurement reaches the desired value.


Exporting only one animation to gltf from multiple objects each with an action

Not sure why but I got it to work by grouping the channels using this code:
for obj in bpy.context.selected_objects:
    new_group=obj.animation_data.action.groups.new("ChGroup")
    for fc in obj.animation_data.action.fcurves:
        fc.group=new_group

And then exporting to gltf without selecting NLA Track:
bpy.ops.export_scene.gltf(export_format='GLB', filepath=filepath, export_nla_strips =False )

Now there is only one animation in the gltf (the color is different too but that's unrelated):


what modeling tool is being used to shape the meshes in the linked video demonstration

Press O
 to turn on Proportional Edit in Edit Mode.  Use the mmb
to scroll the influence range. (or via keyboard with Page Up and Page Down)


You can add a Copy Rotation constraint to them pointed to one Empty, then just rotate the empty on that axis by pressing R+Z.

Now when you rotate the empty all the other objects follow that rotation.


The problem is numerical error. 8 bits can't resolve the direction in  a surface so sensitive to minute changes in angle.

Set up a new 32-bit image.. you can do this in the Image Texture node itself
Set its color-space to Non-Color
Bake as before.

If you want to save the image out, 16-bit PNG will probably do.


Animating separate objects with the same armature

The body and the armour are separate objects and you only have the armature moving the body, you also need to have the armature linked to the armour as well.

One way is to parent using automatic weights or manual weight painting, the same as you would for the body.

As your armour is most likely to be a single rigid piece you might want to parent the armour to a single bone so that it stays as one solid piece. To do this select the armour, shift select the armature and press CtrlP then select Bone. The bone used will be the selected bone in pose mode, you can change to pose mode and select the right bone before parenting.

EDIT: As you want to export to unity I would join the two meshes and use weight painting instead of parenting.

Select the armour and then the body and press CtrlJ. This will join the two objects into one mesh. Selecting the body last means the armour will be added to the body, keeping the armature setup as it is.

Go into edit mode and select one of the armour vertices. Press CtrlL to select the rest of the connected vertices. In the vertex groups find Chest and click assign with the weight set to 1.0. This will make the entire armour piece move as one piece as the chest bone is moved.


Select all vertices within box boundary when in Front view

The question was answered by the following comment:

It's not wireframe mode that lets you select backfacing vertices, it's X-ray mode. They are two separate modes. The one you want is the button with two interesting squares. Turn that on and you can select all vertices inside the rectangle. Also you can constrain your scale to X, Y or Z by typing "SX", "SY" or "SZ" and inputting a number or moving the mouse and clicking. You can also omit axes from scaling: "S+SHIFT+Z+2.5" (no plusses) scales the object along the X and Y axes by a factor of 2.5 but ignores Z. Also note that you can change the orientation of these axes (global local normal, etc) – hatinacat2000 Jul 15 at 23:33


Edited - refined answer that only requires numpy

To find the outline pixels of an object:

Make sure it has a separate object ID than other objects.

Check the Object ID pass in the scene tab of the properties panel.

Replicate this node setup in your compositor and render your scene.

Run this script:

import bpy
import numpy as np

S = bpy.context.scene

# Read render settings - image size
width  = int( S.render.resolution_x * S.render.resolution_percentage / 100 )
height = int( S.render.resolution_y * S.render.resolution_percentage / 100 )
depth  = 4 # RGBA

img = list( bpy.data.images['Viewer Node'].pixels )      # Read viewer node

# Reshape into 2D RGBA matrix, then Keep only R value for each pixel to convert to grayscale
img = np.array( img ).reshape( [height, width, depth] )[:,:,0]

# Find edge pixel coordinates. Each row has the X and Y values of an edge pixel
edgePixelCoordinates = np.array( img.nonzero() ).T

print( edgePixelCoordinates )

The print statement above will spew out a preview of the full array. Looks like this with the outline above:

[[128 511]
 [128 512]
 [128 513]
 ...,
 [379 531]
 [379 532]
 [379 533]]

Original answer with OpenCV

The code below will do most of the heavy lifting, though it isn't trivial to implement, and uses 3rd party python modules (mainly numpy and opencv). It also assumes you have a different object index for each object in your scene, and a node setup that includes an object ID mask plugged into the viewer node in your compositor.

What Isn't covered here:

How to install 3rd party modules in blender's python. See this answer to solve that.
How to automatically set the object index on the object ID mask node to that active object (that's a fairly easy step to add).

What is covered here:

How to find the outline of a mask using openCV.
How to find the pixel coordinates of the outline.
How to generate a blender image containing the outline (wasn't required but is useful for debugging).

To use this script, set a different pass index to each object, or at least a different pass to the object of interest compared to other objects. Also, in the scene tab of the properties panel, add the Object Index render pass. In the compositor, Add an ID Mask node and connect it to the IndexOB render layers output, then connect the ID Mask's output to a viewer node. Render the scene once, and you're good to go! Run the script and you'll be able to see the outline in a new (or existing) image called 'edges' by default.

The script stores pixel coordinates as an array of XY pairs. The first 10 pixels from the contour above look like this:

>>> edgePixelCoordinates[0:10]
array([[128, 527],
       [128, 528],
       [128, 529],
       [129, 527],
       [129, 529],
       [129, 538],
       [129, 539],
       [129, 540],
       [130, 527],
       [130, 528]], dtype=int64)

Here's the code:

import bpy
import numpy as np
import cv2

S = bpy.context.scene

# Read render settings - image size
width  = int( S.render.resolution_x * S.render.resolution_percentage / 100 )
height = int( S.render.resolution_y * S.render.resolution_percentage / 100 )
depth  = 4 # RGBA

img = bpy.data.images['Viewer Node'].pixels             # Read viewer node
img = np.array( img ).reshape( [height, width, depth] ) # Reshape to 2D RGBA matrix

# use 1 color channel (=grayscale) and convert from float to 8bit int pixel values
img8bit = np.array( img[:,:,0] * 255, dtype = 'uint8' )

# Use the canny filter to find edges
edges = cv2.Canny( img8bit, 10, 20 )

# Find edge pixel coordinates. Each row has the X and Y values of an edge pixel
edgePixelCoordinates = np.array( edges.nonzero() ).T

## Add outline as image in blender
# Generate an RGBA image from the 8bit outline image
edgesRGB = np.zeros((height,width,4), 'uint8')
for i in range(3):
    edgesRGB[..., i] = edges
edgesRGB[..., 3] = np.ones((height,width))

# Flatten image matrix to a 1D vector - the way images are stored in blender
blEdges = edgesRGB.ravel()

# Create new blender image to store outline, or assign to existing one
outlineImageName = 'edges'
edgesBlImage     = None
if 'edges' in bpy.data.images:
    edgesBlImage = bpy.data.images[ outlineImageName]
else:
    edgesBlImage = bpy.data.images.new( outlineImageName, width, height )

imNew.pixels = blEdges


Why do vertices move when trying to box select?

You've pressed W. This is mapped to the selection tool and will cycle through the different selection methods if the select tool is already highlighted.

Either press W until you're back to box select, or click and hold the Selection button in the toolbar below.


You can remove an action from an object by going to the 'Dopesheet':

Switch to the 'Action Editor' in the Dopesheet header and press the 'x' next to the action name (CameraAction in this case):

This will remove the action from the object selected in the 3D view.

If the action is not used by any other objects it will be removed from the file when the file is saved, closed and re-opened.


How can I control a rig with gamepad or vr controller

The topic you are intrested in is called Motion Capture and is quite vast.
TLDR: depending on your use case probably can't because you cant track enough axis.
The old school way of doing this is to build a real world version of your rig. Then you attach motion sensors often called Internal Mesurment Unit (IMU) that mesure each movement axis of each physical represented bone. This principal also exist in form of motion capture suits where you slip in.
When you have the motion data for each frame per sensor you convert it to FBX or blender keyframes usualy by python code. You also can build a plugin for blender that takes realtime input from the motion sensors so you can fiddel around with your rig and see wat happens in blender (there probably exist comercial products doing this)
Of course you dont have to track the data for every bone, but than you have to calculate it ither by smart IK rigging or by calculating the missing data yourself.
With a Gamepad and VR controller you dont have enough axis of fredom you can track.
A VR controler gives tracked in a room gives you one tracked translation and rotation. So you can use it to manipulate one object. Of course you have some butons so you could togle thro your bones and place them one by one .. but this seems quite tedious to do.
I think ther exist some gamepats with tracking as well. But still you need to track more than one thing for most rigs.
Ther is a solution to capture your motion to a rig using the Kinekt depth sensor for blender.
If you want to do lo entry cost motion capute probably motion capture via computer vision from webcam or video data is your way to go. There exist comercial products doing this.. and also code from research papers were you have to fiddle your way through.


From the looks of it, your texture is mirrored along the tube. Also, you have fairly even spacing all around the tube, and it somehow gets stretched around where you get the texture anomalies.
My guess is, that your mapping is very easy to fix by using Active Quads to unwrap your tube.

Mark one seam down your tube, from one opening to the other

To make sure the Unwrap works properly, I recommend first resetting the unwrap first with Mesh > UV Unwrap > Reset

Then, first deselect one of the faces on the island you want to unwrap and immediately re-select it. You will notice, its color is different from the rest of the selection. This is because this face is now the Active Face.

Now unwrap the strip with Mesh > UV Unwrap > Follow Active Quads

Usually, Length Average gives the best results on strips, but you can toggle through the option to see if you can get a better fit.

You should now have a perfectly rectangular strip of quads in your UV Map. It may require a little scaling along the X- or Y-Axes, but it will make texturing very easy.


Make an array/ animation node with adjustable angle and size for instances

I'm afraid the question not so simple as it looks like. I think the perfect solution for this - Animation Nodes

For example, this is a basic setup of objects on curve:

After this, you can try to find a way how add to control of scale and rotation of objects. For example, I use distance between empty and object to set scale for elements of array:

I'm afraid, Animation Nodes is a big topic, that I can't discus in one little post. But I give you an idea and providing file for you:


Quadriflow remesh will remove any UVs you have, one solution is to use Data Transfer modifier on the remeshed version, to transfer UVs from the photoscan to the remeshed version, use settings in the image below, you should also place both meshes in the same location, and preferably hide the photoscan
Another solution is to use the Remesh Modifier instead of quadriflow at the cost of low topology quality.


How to animate a bike chain with a low poly chainring?

What you could do is create a mesh that looks like the chain, with only the necessary amount of edge loops, hook these edge loops to empties, make the ring rotate 1/7 of 360°, move the empties and keyframe them so that they follow the ring rotation. Make the empties rotate a bit on themselves so that the chain keeps an even thickness. You can now make the rotation cyclic to give the illusion that it rotates 360° and more. I haven't hooked the left part of the chain but it's the same process.


Shape key driver posing affects the resting pose?

It all depends on how your driver is set up.  There are multiple things your shapekey can be driven by.  Some of those things are "at rest" in rest pose; some of those things aren't.
For example, if you drive from a "transform channel", that's the post-constraint, visual transform of a bone.  Those all go to rest at rest.
But if you drive from a "single property" like pose.bones["Bone"].location[0] (which you get from copying the X position of the bone as a new driver), then what you get is the keyframed X translation channel of that bone, which is pre-constraint, and which doesn't go to "rest" in rest position.  Rest position doesn't change your keyframes-- it just makes it so that they don't do anything.  If that makes it any easier to think about.
So, if you want to change your drivers from single properties to transform channels, I think you'll find that rest pose sets your shapekeys back to their defaults (whatever those are.)  Just be careful about it-- you'll need to specify the space of evaluation for the driver, and you'll be getting post-constraint values, and you'll no longer be getting rotation as your exact keyframed values (for example, you will never see a rotation of >180 degrees in your transform channel.)


How to alternate red/green color for a line chart based on segment direction?

I've decided to use normals, as they are perpendicular to the direction of the line, so from them you can read the direction of the line:

Above red and blue vectors (arrows) mark the rising line, while cyan and violet vectors mark the falling line. Problem is, those are the normals of the faces that aren't actually visible by the camera - the camera only sees faces facing the camera, which all point in one direction:

Fortunately, by enabling Smooth Shading in Skin modifier, you can make those information bleed to the front and back faces:

Smooth shading is effectively faking more geometry - we could achieve a similar effect using Subdivision Surface modifier, so let's do that (and disable smooth shading for the time being):

In this case it should be apparent that the visible part of the shape no longer faces just one direction - because the geometry is smoothed. A single level of subdivision surface actually completely eliminates faces parallel to the camera.
Now, by separating XYZ, we can separately investigate Y:

From that we can see that the top half of the curve always has positive (approaching white) Y component of the normal, while the bottom half of the curve always has negative (clamped to black) component.
...And separately investigate X:

When the top part is rising, it has negative (black) X component, which gets positive (white) when it falls. For the bottom part it's the opposite. Our logic can therefore be:
If Y > 0: [top]

if X < 0: green [rising]
if X > 0: red [falling]

If Y < 0: [bottom]

if X < 0: red [falling]
if X > 0: green [rising]

Or in the nodes language:


I found it in case you still need it. You can download a zip from the GitHub page at https://github.com/porkminer/CubeSurfer, but it gives you an error when you try to istall it in Blender. I fixed it by changing the line from cubesurfer import mciso just to import mciso. The download link is https://gofile.io/?c=sEWqb3.


How would I make a Cube look like a text box?

I am by no means a good modeler, but this is how I would do it.

Start with a plane in top view (NUM 7)
Scale on X so its a rectangle.
CTRL R in edit view to add edge loops, Slide them over how I did in video.
Pull down middle vertex to add the tail.
Select all 4 corner vertices and hit CNTRL + Shift + B for vertex bevel, slide up on mouse wheel for smoother corner.
Select all in edit mode and then hit E to extrude.

I am sure someone can find a quick and cleaner solution but this is my best effort.

EDIT:

Added in how I would do it with curves (Thanks to Cegaton comment)

Start by adding a 2D Curve object (Rectangle) in top view (NUM 7)
Scale on X so its a rectangle.
Select the bottom two corners in edit mode and hit W to subdive, CTRLR to duplicate a couple times.
Grab the curve vertices where you want the tail to be.
You will have to play with the handles in edit mode to get the desired look.
Go to your curve editor and change the extrude and bevel to taste.


Can I use the sapling addon in Blender render instead of Cycles

The sapling addon only creates geometry for your tree, not materials, and has such it is mostly render engine agnostic.

That means you can use it with any render engine you like, the addon only creates the shape for your tree and probably does some basic UV unwrapping for the leaves which can be used on any material.

Material creation is then up to you, and as no effect on the way the geometry was created. If you want to create materials for your tree you must search for adequate tutorials for Blender Internal material system.

If you want the transparent parts of our texture to affect your leaves you should tick the appropriate box in the texture settings to affect material transparency Under the Properties Window > Textures > Influence > Alpha


I want to suppress self-shadowing, but allow to receive and cast shadows otherwsie

Another Very Unsophisticated but simple method that worked for me,
after finish your scene:

Duplicate the desired object
go to Object tab > Cycles setting > ray visability, check 'shadow' for one object and uncheck 'camera ray', do the opposite for the other.

3.flat one of the duplications (the 'shadow') to be plane, face the light source.

I did it in order to save render time.


Copy Rotation Constraint not working when paired with a Shrinkwrap

I'm always suspicious of copying rotation (or scale, or transforms) from vertices.  Why?  Because vertices don't have those characteristics.  What is a vertex group's rotation?  What is its scale?  Those aren't questions with clear answers.  Blender might try to give them those characteristics, for purposes of a constraint, but it's really weird that it does, and, for a few reasons, I'd expect poor behavior from Blender when trying to do that stuff-- not least, because it's not likely to get very intensive testing from users.
What would I do?  I would shrinkwrap two empties to the ocean, then damped track one and locked track the other:

Empties have been scaled up and changed to sphere display to improve visibility.  Shrinkwrap constraints on empties are not shown.


Non-manifold mesh problems after boolean

How to find non-manifold geometry

From within Edit Mode, using Vertex selection, with no geometry selected, use the menu to navigate to Select > Select All by Trait > Non-Manifold. (The keyboard shortcut is ShiftCtrlAltM)

This will show you which part of your mesh is non-manifold.

What is non-manifold geometry?

Geometry is non-manifold if it doesn't form a single volume. Examples include internal faces, edges that don't form a face, vertices that don't form a face, two volumes connected at an edge or at a vertex.

Why booleans are not (usually) the answer

The problem is that you tried to model everything with booleans instead of actually taking the time to model a proper mesh. To make things worse, some of your geometry was very dense, and very dense geometry is more likely to cause problems when booleaned.

Instead, try to model it one area at a time, using as many quads as possible:

I'm oversimplifying with labels of "bad" and "good" for the sake of simplicity here.

The Mirror Modifier is just there to save time modeling, since this is a symmetrical shape.

Here's a list of the operations I used to create the mesh in my example: Extrude, Loop Cut, Delete (faces), Fill (faces), Snap (to vertex), Merge, Add (Circle), Bridge Edge Loops, Remove Doubles, Recalculate Normals, Crease. While that might seem like a lot to learn, these are operations you will use over and over, so they are worth getting comfortable with. It's likely you know some of them already.

While in Edit Mode you can select an edge and press ShiftE to add a crease to it. Typing 1 at this point gives the edge full sharpness and keeps the edge sharp even when a SubSurf Modifier is on the mesh.

You can later readjust the crease weight under the Edge Data section of the Properties Panel (a.k.a "the N Panel"):

Tip: In Edit Mode you can select an Edge and press ShiftG to select "Similar" edges, like those that have the same "Face Angles", and in this way select all the 90° edges at once so that you can crease them. It saves time.

There is no real substitute for a mesh with good topology. By learning to create better topology you will be able to make many more types of models, without encountering these kinds of problems. There may be some cases where you can get away with using booleans, but keep your mesh density lower in order to reduce the risk of problems like the one you experienced.


A problem about bevel after bool modifier

With your lower object (the cut one) selected, click on the Modifiers Tab in the Properties Panel, and check the order of your modifiers in the stack. I have confirmed that when your bevel modifier is above your boolean modifier in the stack, the result is your picture above. When the boolean modifier is moved above the bevel modifer, the bevel then goes all the way around, as it should. You end up with triangles at the corners of the resulting surface, however. But this may not matter, depending on your project. If you don't want triangles at the corners, consider a different approach: Do the boolean only, and apply it. Then in Edit Mode, select the face that makes up the new surface, and press i to inset it. After initiating the offset, but while the tool is still active, press Ctrl to allow the newly resulting face to be extruded in the direction of the face normal. The end result is that you will now have a bevel that doesn't consist of any triangles. The flip side is that the resulting bevel will only exist for this one face, instead of all faces.


When I applied Armature Modifier, Mesh does not follow the animation

The answer is fairly simple, don't apply the armature modifier.

Once a modifier is applied, it cannot dynamically change the mesh. Applying a modifier simply takes the current effects of the modifier an applies them permanently to the mesh. This is rarely useful for the armature modifier, as generally you want to keep animating the mesh.


Finally!

I had to increase the size of the area of the arealamp. i was set to 2mm or something. So the area was to small and messed up the light.

Want to give my thanks to Bfoot for helping me out! :D

Now I just have to redo every change I made to correct this :P


The bpy.ops.wm.link_append() function has been replaced by the two link() and append() functions and they can be used the same way :
Example :

import bpy

directory = "C:/folder/myfile.blend/Object/"
objname ='Cube'

bpy.ops.wm.append(directory=directory, filename=objname, link=False)


I'm assuming you're talking about the topology and not the tracks. This is just a general guideline to get some fast, easy (manually created) topology.
When I need a terrain such as this. I start with a plane, and subdivide it roughly 20 times.

I then select a few points that I want to be "elevated parts" and turn on proportional editing, set to "smooth".

Then I use the grab tool to move the points up on the Z axis. You can control the amount of the mesh that is affected by changing the size of the edit area (white circle) by scrolling the mouse wheel. If you want to make sure unrelated parts of the mesh are unaffected, check the "connected only" box.

Then, to get a more realistic and bumpy (uneven) surface, I select some different vertices in the same areas, and set proportional editing to "random".

I then move the points up on the Z axis some more. They can be a bit exaggerated, because in the next step I add a Subdivision Surface modifier, which smooths out some of the more "extreme" points.

Lastly, I add a Subdivision Surface modifier (using only the amount of subdivisions I can safely "get away with" without shading issues or noticeable geometry). I then set shading to smooth. After that, just add a grass or ground texture and you have a good base for a terrain.

This is just an easy example, obviously. Play around to get the look that works best for you. You can start with more subdivisions if you want finer detail, or you change the proportional edit modifiers you use, or how many times you use them. You'll have to experiment to see what looks best.


Set 3D cursor to stay at center at all times?

In User Preferences you can change the assigned key that sets the location of the 3D Cursor. I would recommend setting it to Shift + Left Click so you can still move it when necessary, but you won't relocate it by accidentally left clicking anywhere.


A quick way to fix your topology:

Starting with the wrong number of vertices, having X > deleted faces only
Select the square's edges, and WSsubdivide with 7 cuts
Select both edge loops, and CtrlE > Bridge Edge Loops

EDIT:

.. but if you're subsurface modeling, as batFINGER points out, you really should be heading for a much lower number of vertices to make a circle in the end result:

4 sides .. Noticeably not octagonal under one level of subdiv., or circular under two. You can get away with it if you know it's never going to be close up. Shading artifacts, too.

5.. Can't remember the last time I used it...

6.. Quite a lot of things have 3-symmetry, and a hexagon makes a perfectly good circle

8.. By far the most common because of the shown topology - comes naturally out of a quad, the diagonals can be absorbed in 5-poles in a holding loop around the circle, or your beveled edges, so don't propagate around your model

.. any more than 8, probably large-scale structure rather than detail, or soaking up necessary loops from somewhere else in the model.

The Illustration is of 0,1,2 levels of subdivision on the various polygons, with a 32-circle in the middle for comparison.


There are 3 ways for upVec to be found:

2 and 3 versions were suggested by mano-wii from here http://blenderartists.org/forum/showthread.php?361154-Coordinates-of-resolution-points-of-a-Bezier-Curve

1) Cross vec. https://github.com/mifth/mifthtools/blob/6b0469faea18d3375c3f3257963d7c85f327c44c/blender/addons/mira_tools/mi_curve_guide.py#L486-L488

2) Project vec.
http://blenderartists.org/forum/showthread.php?361154-Coordinates-of-resolution-points-of-a-Bezier-Curve&p=2866256&viewfull=1#post2866256
https://github.com/mifth/mifthtools/blob/6b0469faea18d3375c3f3257963d7c85f327c44c/blender/addons/mira_tools/mi_curve_guide.py#L490-L492

3) Dot vec.
http://blenderartists.org/forum/showthread.php?361154-Coordinates-of-resolution-points-of-a-Bezier-Curve&p=2866427&viewfull=1#post2866427
https://github.com/mifth/mifthtools/blob/6b0469faea18d3375c3f3257963d7c85f327c44c/blender/addons/mira_tools/mi_curve_guide.py#L494-L497

I choosed Cross vec for my approach for the upVec searching.
You can comment/uncomment any of approaches and try testing.

Also,I found another issue:
One direction can has different upVecs.
http://i.imgur.com/itANWG6.png

To fix this issue I have to pick first point upVec and then check all points after. If a current upVecAngle is more than 90 degrees - we need to invert upVec.
Here is the code to fix this issue:
https://github.com/mifth/mifthtools/blob/6b0469faea18d3375c3f3257963d7c85f327c44c/blender/addons/mira_tools/mi_curve_guide.py#L504-L509

And you can see the result of my custom curve in editmode here:
https://www.youtube.com/watch?v=VXWSUwOul-s


It's essentially the same as you're doing to mix between shaders for your surface:

Here, I'm using the exact same texture to mix between shaders and to mix between displacement.  Since displacement doesn't use shaders, I'm using colors and a mix RGB node instead of a mix shader node, but it could as easily be done with values and math nodes:


While loop Drivers and additive movement

Add a property to keep track of the drivers previous value, after adding the location driver.
The update order of the drivers will have exactly one update/frame, where the new location of the driver isn't copied to the custom property.

(I will add more details later, if needed.)

  Minor point
  The self.location[0] with itself as a driver is not very elegant. Use a shape key if you want to have a visual indicator of 0 and 1 as in the example file.
  Also use the Transformation Constraints instead of the channel locks, since the channel locs won't stop changing of the number via the transform (N) panel.

Changing the property every full second

You can check for full seconds with frame%24 == 0.

Expression: var if frame%24 != 0 else var+1 if var1==1 else var
with var = empty.y and var1 = cube.x as in the original demo file.

Unraveled, this is:

# do nothing (value = var) for 23 of 24 frames
if (frame%24 != 0):
    return var
else:
    # on every 24th frame (frame%24 == 1) check for the condition
    if (var1 == 1):
        return var + 1
    else:
        return var


In User Preferences (Ctrl+Alt+U), go to the Input section. In the search field on the right, search for shift up arrow (be sure to set your Filter Type from Name to Key Binding). You'll find the binding for the Frame Offset operator. If you expand the operator, you should see a Delta setting in the lower right. It's default value is 10. You can change it to 12 (or whatever other value you want).


try re-installing the drivers.. last ubuntu 14.04's updates are quite strange.. I had to re-install twice due of them in the last month.... remember to disable nouveau and purge other nvidia drivers (if you are gonna use the nvidia's proprietary from the home-page) before performing the installation, It could cause problems!

$ sudo apt-get remove --purge nvidia-*


The addon you refer to will add a shake to an object in the 3Dview, it is not setup to work with a strip in the sequencer.

To add some shake to a VSE strip, you can animate the strip offset and use a noise modifier to add random movement. The same technique can be used on any animated value.

Enable the offset option and insert a keyframe for the X and/or Y offset value. In 2.7x this can be found under Strip Input.

In the graph editor, select the keyframed value and add a noise modifier. Increase the strength and adjust other properties to get a suitable variation. Repeat for the other value if you are keying both.

To restrict the shake to a portion of the strip you can set the Restrict Frame Range options or you can cut your strip where you want the shake to start and stop and add the noise modifier to the smaller strip.


Hiding any mesh when another mesh touches it

Describe the way they should disappear. You can use dynamic paint.

But it seems like a job for Animation Nodes: https://github.com/JacquesLucke/animation_nodes


Blender 2.81 hollow model for 3D printing

There are a few solutions that I use.

1) booleans - if the models is without errors like double faces etc. and the boolean works, just make union and then triangulate faces to avoid necessary ngons

2) I used external software meshmixer, its free and have some great functions for this purpose like solidify, which takes all the geometry and create just the "visible" part as the one solid object, then there is possibility to hollow it to make it like vase with certain wall thickness.

3) Voxel remesh - after blender introduced voxel remesh I stopped using meshmixer. You just join the object in blender to be one and then use voxel remesh which "bake" the object into one with no internal geometry.


How to get client script to run before rendering on Network Render

I expect it is the way the addon runs. The python script is in control as it reads the file and starts rendering, only after it has finished does blender sit idle and go back to running registered text blocks from the open file step.

First I would suggest you setup the slaves to always start with gpu rendering enabled.

Failing that, you could adjust the netrender addon on each slave. You will find in netrender/operator.py that rendering starts either on line 80 or 97 you could specifically run your script before the render step or add your gpu enable code to the addon.

text = bpy.data.texts['myStartscript.py']
if text is not None:
    exec(compile(text.as_string(), 'errors.log', 'exec'))
 bpy.ops.render.render('INVOKE_AREA', animation=True)


See bpy.types.Image for the available information about images.

The current image of an editor can be accessed from SpaceImageEditor.image. So for a given context

context.space_data.image

Can you be more precise about what kind of metadata you are interested ?

It depends on the graphics file format (i. e. png format) and might be a question for Stack Overflow

Reading chunks from png

import os

# chunk generator
def chunk_iter(data):
    total_length = len(data)
    end = 4

    while(end + 8 < total_length):
        length = int.from_bytes(data[end + 4: end + 8], 'big')
        begin_chunk_type = end + 8
        begin_chunk_data = begin_chunk_type + 4
        end = begin_chunk_data + length

        yield (data[begin_chunk_type: begin_chunk_data],
               data[begin_chunk_data: end])

# open arbitrary pngs
blender_path = os.path.join(os.environ['HOME'], "Documents", "Blender")
pngs = (os.path.join(blender_path, elem)
            for elem in os.listdir(blender_path) if elem.endswith(".png"))

for png in pngs:
    with open(png, 'rb') as fobj:
        data = fobj.read()

    # check signature
    assert data[:8] == b'\x89\x50\x4E\x47\x0D\x0A\x1A\x0A'
    print("-" * 80, "chunks of: %s" % png, "-"*80, sep='\n')

    for chunk_type, chunk_data in chunk_iter(data):
        print("chunk type: %s" % chunk_type.decode())
        if   chunk_type == b'iTXt':
            print("--chunk data:",  chunk_data.decode())
        elif chunk_type == b'tEXt':
            print("--chunk data:", *chunk_data.decode('iso-8859-1').split('\0'))

Output

--------------------------------------------------------------------------------
chunks of: /home/User/Documents/Blender/0001.png
--------------------------------------------------------------------------------
chunk type: IHDR
chunk type: pHYs
chunk type: tEXt
--chunk data: File <untitled>
chunk type: tEXt
--chunk data: Note Test
chunk type: tEXt
--chunk data: Date 2015/08/12 17:07:41
chunk type: tEXt
--chunk data: Time 00:00:00:01
chunk type: tEXt
--chunk data: Frame 1
chunk type: tEXt
--chunk data: Camera Camera
chunk type: tEXt
--chunk data: Scene Scene
chunk type: tEXt
--chunk data: RenderTime 00:00.06
chunk type: IDAT
chunk type: IDAT
chunk type: IEND

So metadata for png is stored in tEXt chunks, separated by 0 character. See png specification


Is it possible to link a shape key animation to only one of my actions?

Whilst trying to solve my problem I realized that there was a better way to do this and by using a driver bone to animate the shape key I could keep the shape key animation linked to only one of my actions.

If anyone else is had this same problem I would recommend looking up key shape drivers. It will save you a headache.


Okay, I can give a more complete answer to describe how to make a custom shortcut.

The desired feature in this case appears to be under "Transform Modal Map" and the desired value is "Cancel".  It is by default mapped to "Any Esc" as shown below.  (This is in User Preferences-->Input.)

You can simply scroll down to the bottom of that section and click on "Add New" to create an alternative mapping for Cancel, as shown below where I have mapped it to "Ctrl-Alt-X":

. . . and you've now got a new keyboard shortuct for that function.  Obviously save your user preferences if you want it to persist.


that will happen sometimes and there is no solution but to add weights yourself. you could try with envolope weights too, but that wont always work either. you could try checking your scale rotation and location too. they should be at 0 0 0 for rotation and location, and 1 1 1 for scale. Also looking at your model, you have some complex things like the finger blasters, and I may be wrong, but it also looks really high poly, so that may be an issue.


modifier_apply not working when objects created in a specific order

In oper() when you call bpy.ops.object.modifier_apply() it works on the active object, which is the last object you created - the cylinder.

After you select obj1 in oper() also make obj1 the active object and you will get the result you want.

obj1.select=True
S.objects.active = obj1


Is it possible to move the camera, after rendering the scene, through keyboard input as you would move a character in a video game?

I think the answer to your question is "no". You can't "walk" into a render, whatever method (or program) you use to render. A "render" is a non-interactive image (or a sequence of for an animation render), so the best you can do with an image is zoom, pan, but you can't do what you asked.

What you wish to do (ie: walking into the scene with some WASD keys setup) needs an interactive scene, aka a "game". Blender "game engine" allows to create interactives scenes but, as you discovered, this "game engine" uses "blender internal" material types.

The "game engine" is there since many years, well before cycles renderer came, and it is also understandable that it uses "blender internal" materials, because of course cycles gives  way better results, but is also usually way slower than the "blender internal" way of rendering scenes.

You could, perhaps, try this: you could try to "bake" cycles materials to textures, UV map those textures to your "blender internal" objects, and then use the game engine to "walk" inside a scene that appears much like if it was rendered with cycles... it's a sort of precalculation. It will not be like a realtime cycles game, but it could also allow for much better results than the standard "game engine" ones.

I remember a cool project, let me search...
Found! Look at this: http://www.blendernation.com/2014/07/23/the-horror-of-cycles-baking/ this has been done with this method, I think. Also you could learn something about this setup watching this: https://www.youtube.com/watch?v=sB09T--_ZvU

HTH


How to check if two meshes intersect in python?

There's unfortunately no way to use the Bullet physics engine to test for collisions. So you really have to ray_cast() to find intersections.

The 3D Printing Toolbox addon comes with a self-intersection checker. I quickly adapted the code to test for intersections between two objects:

import bpy
import bmesh

def bmesh_copy_from_object(obj, transform=True, triangulate=True, apply_modifiers=False):
    """
    Returns a transformed, triangulated copy of the mesh
    """

    assert(obj.type == 'MESH')

    if apply_modifiers and obj.modifiers:
        me = obj.to_mesh(bpy.context.scene, True, 'PREVIEW', calc_tessface=False)
        bm = bmesh.new()
        bm.from_mesh(me)
        bpy.data.meshes.remove(me)
    else:
        me = obj.data
        if obj.mode == 'EDIT':
            bm_orig = bmesh.from_edit_mesh(me)
            bm = bm_orig.copy()
        else:
            bm = bmesh.new()
            bm.from_mesh(me)

    # Remove custom data layers to save memory
    for elem in (bm.faces, bm.edges, bm.verts, bm.loops):
        for layers_name in dir(elem.layers):
            if not layers_name.startswith("_"):
                layers = getattr(elem.layers, layers_name)
                for layer_name, layer in layers.items():
                    layers.remove(layer)

    if transform:
        bm.transform(obj.matrix_world)

    if triangulate:
        bmesh.ops.triangulate(bm, faces=bm.faces)

    return bm

def bmesh_check_intersect_objects(obj, obj2):
    """
    Check if any faces intersect with the other object

    returns a boolean
    """
    assert(obj != obj2)

    # Triangulate
    bm = bmesh_copy_from_object(obj, transform=True, triangulate=True)
    bm2 = bmesh_copy_from_object(obj2, transform=True, triangulate=True)

    # If bm has more edges, use bm2 instead for looping over its edges
    # (so we cast less rays from the simpler object to the more complex object)
    if len(bm.edges) > len(bm2.edges):
        bm2, bm = bm, bm2

    # Create a real mesh (lame!)
    scene = bpy.context.scene
    me_tmp = bpy.data.meshes.new(name="~temp~")
    bm2.to_mesh(me_tmp)
    bm2.free()
    obj_tmp = bpy.data.objects.new(name=me_tmp.name, object_data=me_tmp)
    scene.objects.link(obj_tmp)
    scene.update()
    ray_cast = obj_tmp.ray_cast

    intersect = False

    EPS_NORMAL = 0.000001
    EPS_CENTER = 0.01  # should always be bigger

    #for ed in me_tmp.edges:
    for ed in bm.edges:
        v1, v2 = ed.verts

        # setup the edge with an offset
        co_1 = v1.co.copy()
        co_2 = v2.co.copy()
        co_mid = (co_1 + co_2) * 0.5
        no_mid = (v1.normal + v2.normal).normalized() * EPS_NORMAL
        co_1 = co_1.lerp(co_mid, EPS_CENTER) + no_mid
        co_2 = co_2.lerp(co_mid, EPS_CENTER) + no_mid

        co, no, index = ray_cast(co_1, co_2)
        if index != -1:
            intersect = True
            break

    scene.objects.unlink(obj_tmp)
    bpy.data.objects.remove(obj_tmp)
    bpy.data.meshes.remove(me_tmp)

    scene.update()

    return intersect

obj = bpy.context.object
obj2 = (ob for ob in bpy.context.selected_objects if ob != obj).__next__()
intersect = bmesh_check_intersect_objects(obj, obj2)

print("There are%s intersections." % ("" if intersect else " NO"))

Select two mesh objects and run the script. It will print the result to the system console.

Note that there's a special case: If, for instance, a cube is fully inside another cube, it will report "NO intersections" - since there are none. But if you think of the objects as solid bodies, they do collide.


How can I remove all unused materials from a .blend file?

After unlinking your materials, save your file. Then reload it with Ctrl+Shift+O.


Is there a way to hide the cycles shader node when using my own render plugin?

cycles is an addon that can be disabled in the user preferences.


Making an array object follow the shape of an object

Array modifier should not be needed.
I replicated your steps by making a plane above a sphere and subdividing and shaping it as needed. I also shrink wrapped it with the following settings:

I then applied the shrink wrap modifier and extruded the plane by 0.02. I made a rough selection of the holes that make up the grate. A fast way of doing this is to press C to create a selection circle and use the scroll wheel to make it very small. You can hold Shift + left-click to deselect faces.

Afterwards I extruded the selected faces by -0.01 (a value less than the initial extrusion). To get the proper materials set up without having to select everything all over again 2 materials were created, the first one being the base metal material that all the vertices will be assigned to by default, the second was the Pitch black material. With the selection still in place, Ctrl + Numpad + will expand the selection to the surrounding faces of the extrusion, you can then assign these faces to the second Pitch Black material.

For the Pitch Black material, simply hit Use Nodes and delete the default Principled BSDF and replace it with a Diffuse BSDF black color that will absorb zero light.

It should look good after that, you can make as many subdivisions as you want and make a proper metal material for the rest of the vent.

An alternative approach would be to extrude the vent from the actual sphere itself and disconnect it. That might flow with the sphere better if you don't like the shape that the plane takes.


Is it possible to move parts of a model along the selected normals?

You can set the Transform orientation to Normal in 3D view > Header:

This will align the Z to the normal of the selected element. (Or in the case of multiple selected elements, the average of the normals of all selected elements):

Note that pressing GZ will still move the selection along the global coordinates, to move the selection along the orientation set with Transform Orientation you need to press the axis key twice (so GZZ).


How to trim down the total ammount of keyframes in a animation

Youn go to pose mode, menu pose, animation, bake action, and set the frame step to three, reducing at one third the number of keyframes.


Unable to render with cycles using GPU: failure to compile CUDA kernel

Seems like GTX570 cards are no longer supported in Cycles. You should still be able to render on them in previous versions of Blender. I think 2.77 or 2.76 should still work. Else than that unfortunately I don't think there is a solution for this other than upgrading to a newer card.


Why is it rendering twice before I get the final rendering?

The possible chances are that, either you might have clicked on render animation, which is present under the Render menu, or you might have multiple passes in view layers or in simply you are rendering passes.


What do the sampler numbers at the bottom of the image editor mean?

From left to right: X & Y are the coordinates you clicked on.
R, G, and B are the RGB values for that pixel.
A is Alpha.
These values are in Scene Referred values in a infinite linear scale,
The numbers after "CM" are the Color-Managed values.  Based on how you have set the Color Management section of your scene, it's telling you what the effective colors will be after applying the settings.
R, G, and B are adjusted for your color management, and the little square next to them is showing a visual representation of the adjusted color.
Then H, S, and V are Hue, Saturation, and Value, which is simply a different way of representing the R, G, B values.
HSV is closer to how humans perceive color, whereas RGB is based on colors of light, so some people prefer to work in that color space.
The L is Luma, which is a gamma-corrected sum of R, G, and B.  Basically if you converted a color to grayscale, how bright it would be.
Since yours already is grayscale, the L value is the same as the RGB and V values.
Here's way too much detail: https://en.wikipedia.org/wiki/HSL_and_HSV
The RGB on the left are "scene-referred" values, meaning they are the actual values in the scene.
Only formats such as .hdr or .exr can hold this kind of information.
If you were to display this information without a color transform by the color management, the colors would look wrong, too dark and contrasty, and all values beyond 1 would be ignored or clipped in the standard sRGB display transform (the clip point is at 16.19 when using filmic).
The numbers to the right of the "CM" indicator are "display-referred" values, meaning they are adjusted to show on a monitor based on your CM settings.
These are my scene settings, for example. If you change them you'll see the "CM" numbers will be different.

If you're not familiar with color management, I suggest watching this video: https://www.blenderguru.com/tutorials/secret-ingredient-photorealism
Read also:
Render with a wider dynamic range in cycles to produce photorealistic looking images


How to make python script check some value every frame

After a lot of googling, combining scraps of code and testing, I finally found the solution for this issue.I'm leaving it here cause it actually can be pretty useful in some situations.

See the docs about event handlers

import bpy
import math

sce = bpy.data.scenes[0]

# the function to call whenever the handler is envoked
def my_handler(sce):
    # contObj is controlling object, the one, which world Z position
    # I take to control rotation of "Target"
    contObj = bpy.data.objects["Controler"]

    # posOnZ is rounded world Z position of contObj
    posOnZ = round(contObj.matrix_world.to_translation().z,3)

    # targObj is the object, which rotation will be changed, when posOnZ reach
    # certain value.
    targObj = bpy.data.objects["Target"]

    if posOnZ == 1.168:
        targObj.rotation_euler[2]+=6*(math.pi/180)

        # check if everything works (can be omitted)
        print(targObj.rotation_euler[2]*(180/math.pi) )

        #without sce.update() you can't see the changes in 3d view
        sce.update()

def register():
    bpy.app.handlers.frame_change_pre.append(my_handler)

my_handler(sce)  # optional, to test if the function is working..

register()


Render fails at tesselation with out of memory error

The linked blend file does not have anything connected to the displacement output, and the displacement mode is set to "bump". Are you sure you supplied the correct version of the file?

In any case, the most likely explanation is the preview vs render tessellation options. The default adaptive setting on the modifier is to subdivide until triangles are 1 pixel in size. In the geometry panel under render settings are some option to scale this setting:

The preview setting is "8", which increases the target size of the triangles by a factor of 8. Meaning Cycles will subdivide only until it gets 8px triangles. The render time setting of 1, however, does not scale the target triangle size. Cycles will keep subdividing until it either gets those single pixel triangles, or hits the subdivision limit (12 by default). Or, in your case, until it runs out of memory and pukes.

You can adjust either the subdivision surface modifier or the render scale setting in the geometry panel to target a less dense mesh (say, 2px or 4px triangles). If you start loosing surface detail from this, you can change the displacement mode in the material settings from "true" to "both":

Choosing "both" will further adjust the surface normal to fit a theoretical perfectly subidivded mesh, rather than the limited mesh you actually have. This creates a bump mapping effect which fills in the missing detail. As long as the sillouhette of the mesh is basically correct, this can be quite convincing.


Baking displacement map with Cycles Experimental

Baking Displacement maps is very easy in Blender Internal. Switch to it.Then unwrap low poly object. Switch baking pass to Displacement, set appropriate distance.Enable Selected to Active. Select low poly object, switch to Edit mode.In UV/Image editor create new image (switch 32bit float on when generating), make sure, that UV map of the object is displayed on this new image.Tab out of edit mode, select first high poly object, then low poly object and hit Bake. Like this:


I've solved it by simply putting an always > and > action, this will play separately on all objects.


Use all Ram on Blender when rendering? (Cycles and Blender Render)

No.
Memory is for storing information. If blender doesn't have 32GB of information to store, then it won't use up 32GB of memory.

To force blender to use more ram than it needs would mean reserving memory and not putting anything in it (a waste), or filling it with useless data which doesn't help blender render (also a waste).

TL;DR: This doesn't really seem like it would be useful.


Ok so I figured out what was wrong, the compositing in post processing was disabled so I just had to tick the box to enable it.


How to make a see through silk material?

I'm not sure exactly how physically correct this is but artistically it should look fine.

  Note: I've exaggerated this effect a bit to be better visible.

Mix Principled BSDF with Translucent (pure white color) shader trough Layer Weight > Fresnel. You can tweak Fresnel to make it more/less transparent.


Rotating repeated Image Texture/ Tile a Texture in 90° increments

A possible node settings:

Use a "vector rotate" node with UV as input and a random rotation around z.
The random rotation is given by picking one random value per tile:

Take the floor part of the UV (so one value per tile)
Use a white noise to get a random value between 0 and 1
Multiply by 4 as we want 4 cases: 0, 90, 180, 270°
Take the floor of that to be aligned to the integer values
Multiply by pi/2 to obtain the rotation in radians


How to DROP an object when releasing Child Of constraint?

I assume you are creating an animation ? In that case, a trick you can use is just to set the position of your object at the exact position it was before, on the frame you drop the influence option to zero. Then, if you run a physics simulation, I think it should work.

Let me know if you have any question !


How to avoid dark/black area in blender when using hemi?

There is no edges showing on the planes because they have no thickness. Add a slight thickness to each plane and you should see detectable edges.

This seems an odd way of doing this though, I'd look into blender's edge detection functionality or freestyle as an alternative.


You need to translate vertex weight into some proxy that nodes can read.  Consider using UV as a proxy.  It can be read by nodes and it can easily be mapped to vertex group weight.

Create a new UV mapping for your mesh and set all vertices to 0,0 on that new map.  Add a UV warp modifier editing this new mapping, modulated by the vertex group you want to reference, and set it to use two empties, one located at 1,1 and one at 0,0.  Now, by accessing these new UV coordinates, you're accessing the vertex group modulating the modifier.


One of the few reasons why your translation widgets are missing might be that the location of your destroyer is locked. Sadly your screenshot has the properties (N ) closed, so I can only guess. If the little locks are dark, then that's very likely the reason.


Jump cut editing in the Video Sequence Editor

The Jump to Cut Addon assembles various important tools, which can be found in the Blender Sequencer, but has no premade method to create jump cuts.

The manual way is already rather fast.

 RMB select the movie strip.
Position the cursor at the beginning of the jump cut.
Soft Cut with K.
 RMBSelect the start handle of the 2nd part of the
strip.
Move it forward a  number of frames. Assuming you want to jump forwards a second in 24 fps the shortcuts would be GX24⏎ Enter.
Remove the gap. ⟵ Backspace or Strip > Remove Gaps.


To separate the joined objects, go to edit mode and select all the vertices of object you want to separate. Then, hit p and click, "selection."


I honestly don't know what's going on exactly with your process, but I've followed this video myself and works just fine:
https://www.youtube.com/watch?v=Pt3-mHBCoQk

Hopefully this helps!


Is there a way to apply uv texture in the middle of animaton?

To unwrap it in the cloth simulated position you need to apply the cloth sim as shapekey, then activate that shapekey and project your texture in editmode, then delete the shapekey and add the clothsim back in.


In Blender 2.8, how do I light an EEVEE scene with an HDR?

Yes and no.
EEVEE can't use mesh lights or HDRI lights "properly". Why? Because EEVEE is not raytracer.
For further reading/watching please see:

Blender Cycles vs. Eevee 15 Limitations of Real Time Rendering in
Blender 2.8
Blender's Cycles vs. Eevee (Ray Tracing vs. Real
Time)
How does EEVEE work?
EEVEE and Cycles render lighting differences

What you can do about it.
Fake it. Or just try to do it.
You will not get the same results in EEVEE as in Cycles. Period. You can try to match HDRI lightning with use of Sun lamp, and smaller lamps (point, spot, area) to be as close as possible to source.
Render your image in Cycles and then by eyeballing try to reproduce as close as possible result in EEVEE.
EEVEE will use colors and light direction from HDRI but the rest like AO and shadows are not supported.
Example.

This is just a quick example of how you can try to mimic "proper" lightning and shadows. As you can see it's not nearly as good as Cycles result due to pretty complicated HDRI.
For second image I've used Sun lamp, two Area lights for blueish tint, EEVEE AO with high factor (3), Soft Shadows in EEVEE Shadows settings and a lot of tweaking under the light settings itself.
I'll not post settings screenshot on purpose as they will be always different for different scenes and there is no "rule of thumb" for them and posting mine could cause more distraction then learning value.


collision sensor only detect collision first time only

A collision sensor sends only one positive pulse, as soon as its owner object collides with another object. To make it send pulses as long as this happens, you can use another script to reset the sensor as soon as it fires.

Here is the script I wrote:

import bge

cont = bge.logic.getCurrentController()

sns = cont.sensors['Collision'] # Whatever your sensor is called, not necessarily 'Collision'

sns.reset()

This script should be placed in a Python controller linked to the collision sensor in question (in the Plane object's logic). It will cause the other script to print "Hello" continuously until either 1) the game engine stops or 2) the object no longer collides with anything at all.

I hope this answer helps...


Why do I have 'glitched' areas in my render after enabling denoising?

I agree with the link Duarte Farrajota Ramos posted.  I'd also like to add that I prefer the denoise settings turned down a bit, to minimize it's blur effect.


You have no material in the smoke domain, so the smoke domain will render as a white box.

Read the following link to set the materials correctly.

Rendering smoke in Cycles?


Object panel > Display > Transparency Checkbox.

This works for Blender Internal but not Cycles.


applying two different textures to a plane

You can use backface properties, which mean the inner side of the face. With the proper node setting:


Hard 'sketch and toon style' shadows in Eevee?

In EEVEE, you can toonify as much as you like by using the Shader to RGB node, and passing the resulting color through a threshold:

Here, the floor-plane receiving the shadow has the material shown... original shadows, in this case, soft, and hardened in the color ramp.

The background curve is just the natural fade of a Sun lamp by reflected angle, caught at a certain level of grey by the threshold.


Cannot join armatures without mesh detaching

Did you apply scale to the rig/armature after re-sizing the armature? If you don't apply scale (Ctrl+A) the mesh will not follow it.
Or are you trying t o"join" them together? Ctrl+J.


Having different material for 2 linked object

Go in the Properties panel > Material > In the dropdown menu, switch from Data to Object, now you can create a new material but the meshes are still linked.


Automatic Weights Deforms The Whole Thing

do not edit bones in pose mode. only edit them in edit mode. pose mode is only for posing the rig!

go to pose mode and ctrl + a to select all. then press alt + g and alt + r and alt + s to set it to default position. edit in edit mode. then do automatic weights.


Texture not loading in render view Cycles

Solution for this one was saving file (that was dds) as png and loading the texture from png file.


Try turning off smooth shading. Select object, Rt click and set to Shade flat. If this works (it worked for me) you have to copy the scalp parent it to the object and turn off show emitter in the particle settings.


What is causing this weird shading effect in rendered view?

It seems to be an issue with backface culling. I turned that on and subdiv+ smooth shading and it seems to have solved the problem.


How to import VMT (valve materials) to blender materials?

From what I gathered, PhongWarp seems to be either Specular or Metallic, Phong is how strong the PhongWarp is. PhongExponent seems to be roughness, with the non-texture variant being how strong/bright it is. BumpMap is just a normal texture.


Certain Faces not Appearing after .OBJ Model Export

They are not gone, they are flipped. GE don't render the backside of faces, unless you specifically tell them to.
You can tell that's the case, because the part that's missing in Blender has a blueish color.
Select that part, go into edit mode and hit CRTL + N
if that doesn't change anything, go back into edit mode and press CRTL + F and choose Flip Normals


Weird shapes and lines on solid shapes and low light on cycles

From your picture, the shape glitching looks like Z-fighting. This happens when you have two objects (or faces of the same object) that occupy the same space. If it is Z-fighting, it will probably flicker when you move around in the viewport.

To fix it, try moving the object around. You can also try going into Edit mode, selecting all the vertices, and pressing W > Remove Doubles. (This is also good to do just on general principle—even just canceling a Shift+D will create duplicate vertices in the same spot.)

I don't know about the lighting issue; can you post a picture of the rendered view so I can see what it looks like?


How to extrude faces with a value of its area?

I find the answer
the problem was in using extrude individual faces command for this operation , when I change it to ordinary extrude for flat objects and extrude faces along normal for curved objects , that solved the problem
I added scale in the end to give that shape
you can change the multiplayer with ar variable in the extrude command to control extrusion value

this is the code

import bpy  #
import bmesh

# Get the active mesh
obj = bpy.context.edit_object
me = obj.data
# Get a BMesh representation
bm = bmesh.from_edit_mesh(me)

for f in bm.faces :
    e = f.index

    bm.faces.ensure_lookup_table()
    bpy.ops.mesh.select_all(action='DESELECT')
    bm.faces[e].select=True

    ar = bpy.context.active_object.data.polygons[e].area
    print (ar)
    bpy.ops.mesh.extrude_region_shrink_fatten(MESH_OT_extrude_region={"use_normal_flip":False, "mirror":False}, TRANSFORM_OT_shrink_fatten={"value":-2*ar })

    bpy.ops.transform.resize(value=(0.6, 0.6, 0.6) )


Point and Edges based on Armature Hierarchy

On the face of it (no pun intended), this should be reasonably simple to do. Your script would basically go through the following steps:

Create an empty mesh object
Loop through every bone in the armature. For each bone:

Place a vertex at the bone tip and one at the bone root
Connect an edge between those two vertices

Execute a Remove Doubles operator to remove any vertices that are in the same location as one another (thereby also chaining your edges together.

Wrap that process in its own operator and you're good to go. That's pretty much it. Is there a specific part of that process that you're having difficulty with?


how to control an rgb node's color through a custom property

You can do it like any other custom property, but you have to set a different driver for each channel.
Expand the color wheel by clicking on the custom property color field, set it to R,G,B and right click on the first channel, choose Copy as new driver.
Then expand the RGB node color wheel by clicking on the color field, set it to R,G,B and right click in the first channel, choose Paste driver.
Now repeat that for the Green, Blue, and Alpha channel and the two colors will be synched.


Can i apply normal map & bump map & a texture on the same object

This seems to work, but i want to know if there is a better way to do it


Selecting all coplanar vertices from another mesh

Select all co-planar verts in other edit meshes based on 3 selected verts of active mesh.

3 selected verts form a plane. The coordinate of one and the cross product of vectors formed by two "edges" is the normal.

For all other meshes select their verts based on there distance from plane defined in step above.

mathutils.geometry.distance_point_to_plane is a utility function that returns the distance of a point to a plane.

The vert coordinates of other meshes are converted to the local space of active object to perform the test. Could instead use global coordinates. To make a local normal global see Python: vertex normal according to World

Test script. Select objects of interest and enter edit mode (2.8+). Select 3 verts of same object and run script. Any verts in the same plane (within tolerance) are selected in other meshes.
import bpy
import bmesh

from mathutils.geometry import distance_point_to_plane as dp2p

TOL = 1e-4

context = bpy.context

ob = context.edit_object
mw = ob.matrix_world
mwi = mw.inverted()
obs = [o for o in context.selected_objects if o.type == 'MESH']
obs.remove(ob)

bm = bmesh.from_edit_mesh(ob.data)

# using face normal
'''
f = bm.faces.active
plane_no = f.normal
plane_co = f.calc_center_median()
'''
# using 3 verts from select history
v1, v2, v3 = bm.select_history[-3:]
plane_co = v1.co
plane_no = (v1.co - v2.co).cross(v3.co - v2.co).normalized()
# should assert all verts and not inline.
for o in obs:
    bm = bmesh.from_edit_mesh(o.data)
    M = mwi @ o.matrix_world
    for v in bm.verts:
        v.select_set(
                abs(dp2p(M @ v.co, plane_co, plane_no)) <= TOL              )
    bmesh.update_edit_mesh(o.data)