Exporting / Rendering in a Print-Ready Format - I'm Stuck!

People at print shops expect most illustration, desktop publishing and page layout graphics design work to be handed in a vector format like say PDF, commonly also EPS, Adobe Illustrator, Coreldraw, Indesing, and to a lesser extent even SVG.

The advantage of these vector graphics formats is that they don't pixelate when zoomed in on, so they provide a theoretically infinite quality and definition. They can also be much smaller in file size for higher image quality levels.

And for much of your work it does look like it could be made in a vector graphics editors, like say Inkscape, CorelDraw, Adobe Illustrator, Indesign, etc.
Logo designs usually benefit from vector formats, so does page layout like fliers, posters, advertising.

That being said not all stuff can be done in vector graphics, images, photos, renderings, and elements with many color variations benefit from raster graphics file formats like JPG, TIFF, PNG, TGA, HDR, etc..

Renderings from 3D models are among those that are generally represented by raster images. These can and should be combined with the remaining vector elements in a mixed document whenever possible.
While it is possible to extract vector drawings from 3D models directly, it is quite more limited in terms of representation, and not trivial to achieve.

Under Blender you have a few options, which is using Freestyle which is implemented as a rendering engine that allows extracting non-photorealistic images. There is one plugin shipped with Blender by default that allows exporting SVG from freestyle.

One other option under Blender is using the third party addon SVG Output Script, which while more basic at times, allows viewport exports that may produce closer to expected output for certain situations.

You can also look into NURBS modelling applications like Rhino or Moi that have math based geometries and allow more accurate vector output in PDF format.

You can then import those into any vector graphics editor and tweak it further.

Have in mind that non of these options aim to export a fully realistic raytraced image of your model, like traditional rendering, quality may also vary. Most of the time though, a high enough quality rendering, with dense enough resolution images should suffice even for printing, if correctly combined with vector info for all non 3D elements.

For purely bidimensional graphics like most of the logos, they are likely right, you should probably change your workflow and use proper drafting tools like say free and open source Inkscape, or Scribus.

I see no good reason (other than enjoying your current workflow) for doing basic 2D graphic design in a fully 3D workflow. It is more complex and doesn't really provide any benefit.


Get list of selected objects on specific layer

Returning only the selected objects on a layer simply requires checking the object's select property at the same time as checking which layer it is on.

To extend the example on Get the list of objects on a layer in python:

import bpy

layerIndex = 0  #Chosen layer
objects = bpy.context.scene.objects

selectedObjects = [ob for ob in objects if ob.layers[layerIndex] and ob.select]


For this purpose blender user usually use Rigid Body simulation. Here is a cookbook for a cube segmented into 10x10x10 (1000 parts). Yes it is process intensive and this is just one cube. The most calculation takes Constraints.

Create a Cube

Select a Cube
Assign Array Modifier > Count=10 > X=1
Assign Array Modifier > Count=10 > Y=1
Assign Array Modifier > Count=10 > Z=1

Search for operators:

Convert to Mesh
Separate by Loose Parts
Origin to Geometry
Move to Collection > New

Create a floor
Add a Plane and search for operators

Transform Scale
Apply Scale

Create a simulation
With Cubes selected, search for operators:

Active (Rigid Body)
Change collision shape > Box
Connect (Rigid Body)

With Plane selected, search for operators:

Passive (Rigid Body)
Change collision shape > Box

You can also try version of Blender with Fracture Modifier, that is much comfortable to work with, especially with constraints, but I didnt find grid cuts.


You could do this by adjusting the offset value of the fluid simulation.

Here's a short summary of this:

Go to the offset settings of the Blender fluid domain (Assuming you are using Blender v2.81 or before), and adjust the value to a higher number to make the simulation happen earlier, and lower to happen later.

This will cause your fluid to show up later or earlier depending on the offset value. For a detailed answer to a similar question, look here.


Is netrender only useful for multiple frames?

AFAIK, it does not (yet):

From the wiki:

  Todo:
   Dispatch single frame as tiles

however, another fairly simple way to do this is to render relativity low samples on each machine with different seeds, then combine the images afterwards.
(see this post for more info)


Have a look at the UserPreferences->Input->Info

The 'Select Mouse' on window is a right-click. This will highlight a line, and the same action to remove the highlight. Whatever you use on the Mac to select geometry, should be the same key that will work in the info-window to select lines.

Copy Reports: will copy highlighted reports.

short-comings: (November 2015)
It isn't currently possible to select part of a line, it's the whole line or nothing.


Not sure if this is the result you're looking for, but if it is you can unwrap your object, projecting the UV-map from view (hotkey U). And then move and scale the UV-map over the normal texture (decal image.png).

Then when you apply the material to your object, it will look like this:

Edit:
(because comments do not allow for enough characters)
I thought you made a nice decal, and if you wanted it to be more 3D you could add it to your 3D model. I thought that was clear. Maybe a bit silly of me because i understand that often the point of using decals is to minimize the use of actual 3D geometry, So i did some digging.
It seems the Decal Machine Addon does not simply use normal maps. It adds to the illusion of geometry using parralax mapping or parralax occlusion. I don't know enough about it, but i believe that is currently not easy to do with Blender alone (hence, i suppose, the existence of the Decal Machine Addon)
Here are some resources on the subject (that also have .blend files implementing the technique):
https://devtalk.blender.org/t/parralax-occlusion-for-blender-2-8/3641 ,
https://blenderartists.org/t/parallax-shader-with-silhouette-clipping-for-blender-2-8-eevee-and-cycles/1162334
and
https://blenderartists.org/t/parallax-mapping-with-silhouette-clipping-shader-node/561285
They might be of more use to you than my answer


The light does travel farther, its just that volume lights take longer to resolve. If you up your samples you should see the light extend further. You could also use a standard emission shader without volume which will render faster.


Modifiers:

This is possible with the displace modifier, and you can use a procedural texture for the voronoi diagram. This way you don't even need to paint in each part of the voronoi texture, because they will generated each slightly darker/lighter.

Add a subsurf modifier to increase the mesh density.
Add the displace modifier and add a new displace texture (click New on the texture input of the displace modifier).
Set the Type of the texture to Voronoi and the Coloring to Position:

Add a Decimate modifier set to Planar to remove the unneeded geometry.

Result: (click for full size)

And here is an example blendfile.

You can sort of smooth out the edges with a Smooth modifier:

Cell fracture:

Expanding on Mike Pan's answer, here is a workflow using the Cell fracture addon. This addon is bundled with blender, but you still need to enable it in CtrlAltU> User Preferences > Addons:

Once it is enabled,

Add a plane and subdivide it (Edit mode (Tab) > Select all (A) > W > Subdivide). The mesh density will affect the size of the resulting shards.

Select all and extrude down so it is now a manifold mesh:

With the cube selected in object mode, press Cell Fracture in 3D view > Tool shelf > Object tools > Cell fracture and set the Margin to 0. Changed settings are highlighted. Press OK when ready:

Delete the original cube, then select all the shards (making sure that one of them is active) and press CtrlJ to join them into one object:

Enter edit mode and remove double vertices by pressing A> Select all > W> Remove doubles. If needed increase the Merge Distance in the Tool Shelf > Redo menu:

Still with everything selected, run Delete> Limited Dissolve in order to further simplify the mesh (note that limited dissolve functions the same way as the Decimate modifier in planar mode):

Delete the excess geometry. The easest way to select it is by going into front orthographic view (Numpad 1, Numpad 5), the using Box select to only select the very top vertices:

You could also try going into top (Numpad 7) ortho view with solid shading enabled, then box selecting everything visible. This works, however you may need to deselect some vertices on the sides after doing this.

The easiest way to do this is to enter front (Numpad 1) wire (Z) ortho view and deselect using box select. (B > MMB)
Invert the selection (CtrlI) and delete the selected vertices (Delete> Vertices). This should result in a nice clean plane of ngons, like this:

Select all (A) and press AltE> Individual Faces:

Without changing the selection, set the Pivot Point to Individual Origins (Ctrl. (period), or set it in 3D view > Header) and scale (S) to taper the extrusions slightly:

Invert the selection (CtrlI) and hide those vertices (H), so you are left with this:

Switch to face select mode (CtrlTab> Face) and select random (* 3D view > Header > Select*):

Move the randomly selected faces on the Z axis (GA) arbitrarily, randomly select again, move again, etc.

This process can be made slightly faster by running Select random from the Operator History (F3)
Unhide the hidden geometry (AltH). This should result in something like this:


Those are called fireflies and are caused by not enough samples.

I will refer you to the manual:

https://docs.blender.org/manual/en/dev/render/cycles/optimizations/reducing_noise.html

  To understand where noise can come from, take for example this scene.
  When we trace a light ray into the specified location, this is what
  the diffuse shader “sees”. To find the light that is reflected from
  this surface, we need to find the average color from all these pixels.
  Note the glossy highlight on the sphere, and the bright spot the lamp
  casts on the nearby wall. These hotspots are 100x brighter than other
  parts of the image and will contribute significantly to the lighting
  of this pixel...


Get raw sound data in Blender using python

Say with a Plane object selected, you bake a sound file to its location keyframes.

>>> obj = bpy.data.objects['Plane']
>>> obj.animation_data.action.fcurves[0].sampled_points[0].co
Vector((1.0, 0.0))

>>> obj.animation_data.action.fcurves[0].sampled_points[1].co
Vector((2.0, 0.34159383177757263))

>>> obj.animation_data.action.fcurves[0].sampled_points[2].co
Vector((3.0, 0.8729846477508545))

>>> obj.animation_data.action.fcurves[0].sampled_points[3].co
Vector((4.0, 0.8701881766319275))

>>> obj.animation_data.action.fcurves[0].sampled_points[4].co
Vector((5.0, 0.6890017986297607))

This gives the points that the graph makes. And you can limit the frequencies used for the bake.

Then making a mesh is simple (relatively)

import bpy

rescalex = 20
rescalez = 0.2
obj = bpy.data.objects['Plane']
points = obj.animation_data.action.fcurves[0].sampled_points

# turn 2d points into 3d coordinates and rescale
verts = []
add_vert = verts.append
for idx, p in enumerate(points):
    z = p.co[1] / rescalez
    x = idx / rescalex
    add_vert((x, 0, z))

# connect sequential vertices
edges = [(i, i+1) for i in range(len(verts)-1)]

mesh = bpy.data.meshes.new("mesh_name")
mesh.from_pydata(verts, edges, faces=[])
mesh.update()

obj = bpy.data.objects.new("obj_name", mesh)

scene = bpy.context.scene
scene.objects.link(obj)

that gives this.


Three.js export option is sometimes disabled

In Blender there is a difference between active and selected,
typically its fine to think of active as last selected.

Notice when you select the object, its outline (or wire) color is brighter then other selected objects.

The poll only succeeds (i.e., the operator is only enabled) if bpy.context.active_object != None: see io_mesh_threejs/__init__.py:323.

This will be the case right after you deleted an object, imported models (e.g. OBJ) or certain operator calls. These operations can clear the active_object, although objects may still be selected.

Select any object (or set active_object to an object with python) before you open the File > Export panel.


Cannot Deselect objects in when other objects are behind the selected Ones

When you right click on an area with multiple objects, blender will cycle among these object.

You have several possibilities to overcome your issue:

changing the view a little (by panning around but, even more effectively, by zooming in) in order to free up that portion of space, and make a less ambiguous click. Note: in wireframe view, the objects you select are the ones whose edges - not faces/volume - are near your mouse pointer.
using the Outliner window, that is the top-right window in the default worktable
using Undo: Ctrl+Z. The Undo history contains selections as well! Note: there are separate histories for Object and Edit mode.
[Edit, thanks Mr Zak] you can use the other selection methods that you have mentioned (B, C), provided that you then use MMB for the selection to make it subtractive.

However, the "selection by depth" menu Alt+RMB can help you make more precise selections.


Is it possible to parent an object to a different bone in 2 different (multiple) animation?

The only solution is the Child_Of constraint if you want to alter parenting in pose mode. If that leads to another problem, ask it, there is probably solution to it.

Make sure the bone that is gonna get the Child_Of constraint has no parents. Else you will get multiple parent transformations (the original parent and the constraint on top).

There is a way to rig an inverse parent transformation to negate the original parent (if present) when needed from pose mode, but it is complicated and probably not worth it.


I'm having trouble understanding how to work with nodes using python

Set the default_value of the input

There are many examples of this here, probable duplicate.  Here is an answer in lieu of a long comment

Set an input node value by altering its default_value property

import bpy
name = "Foo"
newmat = bpy.data.materials.new(name)
newmat.use_nodes = True
node_tree = newmat.node_tree
nodes = node_tree.nodes
bsdf = nodes.get("Principled BSDF")

bsdf.inputs[4].default_value = 0.9

Tip, for new material created as above can

>>> bsdf, output = nodes
>>> bsdf
bpy.data.materials['Foo.002'].node_tree.nodes["Principled BSDF"]

Testing in python console.

>>> import bpy
>>> name = "Foo"
>>> newmat = bpy.data.materials.new(name)
>>> newmat.use_nodes = True
>>> node_tree = newmat.node_tree
>>> nodes = node_tree.nodes
>>> bsdf = nodes.get("Principled BSDF")
>>> bsdf
bpy.data.materials['Foo.002'].node_tree.nodes["Principled BSDF"]

>>> bsdf.inputs[4]
bpy.data.materials['Foo.002'].node_tree.nodes["Principled BSDF"].inputs[4]

Notice the input node is not a float

If we autocomplete the input node, will see its properties and member methods...

>>> bsdf.inputs[4].
                   as_pointer(
                   bl_idname
                   bl_rna
                   bl_rna_get_subclass(
                   bl_rna_get_subclass_py(
                   default_value
                   display_shape
                   draw(
                   draw_color(
                   driver_add(
                   driver_remove(
                   ....


If that's all sketchup gives, then it's a little awkward -- but I think still doable. Maybe something like this. You will have to 'tame' the dimensions yourself.

import bpy

# Data from Sketchup.
cam = {
    "eye": (240.719, -236.069, 102.276),
    "target": (-285.372, 553.004, -82.0446),
    "fov": 35.0,
}

# Create empty to target.
bpy.ops.object.empty_add(location=cam["target"])
target = bpy.context.object

# Create camera.
bpy.ops.object.camera_add(location=cam["eye"])
bpy.context.object.data.lens = cam["fov"]

# Configure camera to track the empty.
constraint = bpy.context.object.constraints.new("TRACK_TO")
constraint.target = target
constraint.track_axis = "TRACK_NEGATIVE_Z"
constraint.up_axis = "UP_Y"


Using a curve/path to animate solid mesh rope - (Blend file below)

The blade doesn't use physics to fall.  It is instead animated.  That only involves two keyframes so it comes to a sudden stop at the end. (see the blade's curve shape in the graph editor)
A tiny bounce can be added if desired. (see that also in the Graph editor)
The rope is a hard mesh cylinder scaled to become long and thin.  This is generously subdivided along it's length so when it's bent it's not going to appear blocky. (Typically x 128 to 200)
It is also deformed to bend over the pulleys using a Curve->Path and curve modifier.
The easiest way to shape the path is to lay the curve over the top of the two pulleys and bend it down so it hangs down to the blade, the other end to dangle over the frame's side.
Subdivide between it's control points as often as necessary to get it flexible enough.

As for the rope's length, it isn't necessary to get that right initially.  Extra path can be added or removed later.
To drag these control points about so the rope can bend, hooks are placed at several (or all) of these control points. (CTL-H then "Hook to new object")
It's the hooks that are animated when bending is required.  Shapekeys could be used but arguably, hooks are a lot easier to work with in these circumstances despite the extra work setting them up.
With the hooks installed, at this point you could simply use the curve as it is and beveled to suit, but if requiring meshed rope, read on...    If not, skip down to "POINT A" .
-================-
Using meshed cylinder for the rope -
Once the path has been set up, it's used along with a curve modifier to shape the rope.
IMPORTANT -  Be sure that both the curve and rope share precisely the same origin point.   Press SH-S to achieve this.  The modifier is added to the rope.  Name the path as the curve object.
By default the X axis is used in the modifier, but when sliding the rope up along the curve, drag it up with the blue Z axis gismo. (Global orientation)
The rope will be forced to follow the curve's shape much like a plastic tube being pushed over one end of a shaped rod.

With the rope's curvature now following the path we need to animate the former individually so it stays in synch with the blade.  (Parenting it to the blade sends it all over the place)
You can either copy the Blade's keyframes into the Rope's Z axis and once done, adjust them all as one in the graph editor,  (raise/lower it's end inside the blade where you want it) or -
At the same frames as each step in the Blade's ascent, insert a frame for the rope also and take it's lower end back to the anchor location in the blade.  What little variation (if any) will exist between the blade and rope's ascent, can easily be realigned between keyframes with the Graph editor's handles.
When done the rope will rise with the blade,  it's loose end descending down the side the same distance.
Because it's mesh it won't stretch or shrink.
Sufficient path length will be needed at the side to accommodate the descent. If there isn't, the rope's end will extend beyond the path's end eventually and that section of rope would be no longer controlled by the path.  Simply append extra control points to the path as needed and add hooks.
-=======================-
POINT A -
Thanks to the path, the rope's shaping has so far been automatic.  When it's to appear loose and swinging about however, those mechanations are brought about by manually animating the path's control points. (keyframes)
See immediately below for a painless way to emulate physics.

To emulate rope physics, simply place a strip of 'cloth' (a plane) along the top of the guillotine frame and give it PLENTY of  "Structure"  in it's properties.  (150 to 200)
Pin and parent the cloth if it wants to fall off.
Play the animation through at least once and watch it wrap down over the corner pulley to flop around and do it's thing.
Once settled, step it through again frame by frame and simply trace it's movements with the path's hooks so the rope more or less stays with the cloth and keyframe those changes.  Indulge yourself and add a little bounce or swing at the end!

The circular empty - "Nav handle" is used to hold it all together.  Move the guillotine about by this only.


Is it possible to use 3D perlin noise to manipulate a mesh in the Blender Game Engine?

The BGE does not generate anything. It loads all mesh data from .blend.

Therefore you can generate your mesh within Blender save it inside the blend and load it from there.

This is pretty static (a fixed number of meshes). There are various methods to hide this limitation:

combine different "patches" to build an object with variations (Example: puzzle, grid tiles). This works with any structural design and can have any detail (from large patches to very tiny ones). It is important that patches fit together.
manipulate the mesh vertices in-game to get variations of the same mesh (Example: terrain as height-map. This does not match your requirements as it is not possible to create bridges and loops.). The basic idea is to ensure the mesh does not look exactly the same as the original. Therefore the limited number of available mesh-"types" is not noticeable that easy.

Both methods can be combined. E.g. you can have an height-map mesh but add bridges and loops as patches on top of it.


Rigid body falling through conveyer belt

That happens to me sometimes. I dont remember exactly what i did to fix it but i think the problem was caused because it had something to do with moving the origin and editing the mesh once a rigid body is added to the mesh. I think if you CtrlShiftAltC and select origin to center mass it might work.


if you already applied your modifier, you cannot change it afterwards. As long as you don't apply the modifier you can change it.
e.g.:
green: not applied modifier
red : applied modifier


Update 19/01/2021 (Solution)
I finally found a way to this by using the knife tool. After searching I found this video which had exactly what I needed. The info from @Gorgious and @Carlo in the comments helped me get a better direction. In short the process is the following:

Use the knife tool
Create a cut, just above the end, to have different surfaces
Following the instructions of the video, to rip the selection and then separate the meshes, delete the small object at the base of the head.


Do you have any modifiers active during export? Try applying any active modifiers and then exporting. It might be an issue with the multires modifier if you have that on.


Animating a mouth in 2D with blender 2.8

I had this same problem. I don't know why it's happening to me, while others seem to do it without trouble, but I tried to change the interpolation mode to constant, and it worked.
Go to:
Editor type > Action editor
right click > interpolation mode

Let me know if it worked for you!


Nodes increment by 0.1, can this be changed?

Trying holding down the shift key while clicking and dragging to change the values. This will allow you to increment the value by hundredths versus tenths.


How to use bones to fold a model like cardboard?

If you select the armature, then the box, and switch to Weight Paint mode, you can see what is the influence of each bone. In your case you can see that it's not correct. For example the bone on the left has an influence on the whole box while I guess the top is supposed to be controlled by other bones. Same thing for the top bones, if I move one, it deforms much more that what is supposed to deform, even some parts that appear blue, but must have an influence superior to 0.

I think maybe you counted on the Automatic Weights mode when you parented, but for this kind of rigging (i.e. not organic object) you should have used the With Empty Groups method:

So first delete all existing groups (or in your case, unparent your box with altP, it will keep the vertex groups and you won't have to parent with empty groups).

Once you've parented With Empty Groups, your mesh has as many vertex groups than you have bones, but they have not been assigned to any vertex yet. You just need to select your object, go in Edit mode, go to the Properties panel > Object Data > Vertex Groups, select a group in the list, then in the 3D view select the vertices that are supposed to be part of this group, meaning which are supposed to be influenced by the bone with the same name, and press the Assign button under the vertex groups list.


Looks like you're using a nightly build of Blender with vector displacement support. In that case, you'll need to translate the map with the new "Displacement" (displace along normal) node. Add Node > Vector > Displacement. That node can also replace your math nodes if you like, use the "offset" value instead of the subtract node and the "scale" value instead of the multiply node. They do the same thing, just built-in functionality. Plug your displacement map itself into the "height" input.

See also: What value does the Displacement input of the Cycles Material Output node expect?


Why do I have more particles in the render than the viewport?

Properties editor > Particles > Viewport Displaly > Amount

Properties editor > Particles > Children > Display Amount


Animation Nodes: How to cut copy and paste functions

Use a switch node and a compare node to evaluate the input x.


Best way to export scene objects to external program?

Export as an .fbx or .obj with "only selected" enabled...if you try to use .blend files in Unity you will run into all sorts of problems (bugs, only works if a compatible version of Blender is installed).

Select your objects that you want exported, then choose to export as .fbx or .obj. FBX supports animation, OBJ does not. If you just need a simple static mesh, you can use .obj, but I personally prefer to only use .fbx format for simplicity.

Finally, you don't need to export specific objects if you would rather not. If you need to export the entire scene (and will only want to export the entire scene in the future), just use this tool with all desired objects selected, and Unity will import it just fine. When it gets into Unity, the objects are still separate once you pull them into your scene...


How can I apply a modifier to a multi-user data object?

You can create a plain duplicate using ShiftD (instead of a Linked Duplicate).

Then apply the modifier on the duplicate. Now this unique mesh data will have the modifier applied to it.

After that, for any object that you want to use the modified mesh, just go to the Mesh Context and select it from the drop-down list.

In this example 'Cube.001' is the mesh with the modifier applied.


There are two problems with your mesh. First, your normals are inside out, which will give you some problems if you try to skin (or anything else, really). Go into edit mode, select all of your mesh, press ctrl-n. A good way to visualize the normals of a mesh is to turn off double-sided lighting. You can do this in the mesh data tab, where you find your vertex groups. Disable the option; if the mesh looks really light, the normals are facing the right way. If it looks dark, the normals are facing inward and need to be reversed. Your screenshots show inverted normals.

Now you can rig the mesh. You already have certain bones set up to deform and not deform, which is good.

First you need to delete your vertex groups on the mesh. This will remove any old weight data on the mesh so you can start clean and fresh. From here, just use automatic weighting. You will certainly need to fine-tune your weights after.

The reason your mesh was deforming so terribly was because your weights were spread out over the whole mesh, not localized to the area with the respective bone. Leg bones were affecting mesh on the opposite side, torso bones had weight up in your arms, etc.

This is a good overview of what weight painting is and how to do it.

https://www.youtube.com/watch?v=S0VS0IVylzg

For documentation on weight painting, see the manual here: https://www.blender.org/manual/rigging/skinning/obdata.html


What workflow should we use to create a text object that requires characters from multiple .ttf fonts?

Not sure if it works for you, probably not a very solid or flexible long term solution,  but have you looked into Object Font?

Basically you specify a "family name" or a base naming convention for a bunch of objects, you then manually name any 3d object using that naming convention like fontobject_a fontobject_b fontobject_c fontobject_n etc.

You then enter this family name in the Properties Window > Object Data > Font > Object font as fontobject_

You can now specify any regular blender objects as a character replacement. You manually create objects for every character, can be a 3D mesh, a bezier curve or even another text object using the desired font file, and name it properly.

Turn on vertex duplication on the original font object under Properties Window > Object > Duplication > Verts and you can have as many different fonts as you like.

Have in mind that it is an admittedly cumbersome solution and will probably require post processing like making the duplicates real and hiding the underlying text object.


Hide subsurf modifier curve in edit mode

To disable the modifier only in edit mode press the cube icon:

You can also:

Enable the Deformed display which deforms the edit mode mesh to the subserfed object, making it easier to see geometry. Note that this can make tools like loopcut and knife hard to use, you may have to disable it to use those accurately.

Disable the modifier in the viewport by clicking the eye icon (affects object mode too). This will not affect the render. To disable the modifier in the render, click the camera icon.


How to avoid grainy renderings in Cycles?

Sample number is set to 128

Unless you have the "square samples" option enabled (which turns it into 128^2 samples, aka 16384 samples), 128 is not high at all. Set it higher.

  Light paths are set to "full global illumination," where maximum numbers of bounces are all 128 (but this also means caustics are on. Maybe I should try turning them off. Thought they contribute to photorealism, the graininess I current have is unbearable...)

I'd advise never using the Full GI setting unless you specifically want to wait around for awhile to get every last lighting detail. The benefit of extra diffuse bounces drops of FAST after 2-4. Glossy and transmission often need more to avoid dark reflections/refractions, but 128 is overkill. Try 4-6 for glossy and 10-16 for transmission.

  Filter glossy is set to 0.5

Try 5.0. 0.5 is barely enough to even do anything.

  world.cycles.sample_as_light set to True, as I read from a article by Andrew Price

Do you know what that setting actually does? If not, give this a read: What is multiple importance sample option While that option is usually the right call for scenes with HDRIs, you should understand WHY you are enabling options, not just flipping them on because the tutorial said to.

Generally, here's my steps for cutting down render time and noise, in order of increasing desperation:

Turn on filter glossy
Disable refractive caustics
Turn off diffuse visiblity on mesh lights, add a lamp object to cover the missing lamp.
Lower diffuse bounces
Disable reflective caustics (they're generally softer than refraction caustics, so less noise and more contribution)
Turn on clamp indirect. Remember that it clamps sample values and not final pixel colors. Mind what white point you're using if you have enabled exposure options, post-processing, the filmic-blender LUT kit, etc.
Turn on clamp direct (absolute last resort, avoid this setting if you can).


The materials tab appears different than the usual material tab

Nodes are used to create materials using cycles renderer. You can see "Blender render" selected on top of your Blender window (which is old Blender render and soon is said to be removed with next version), click on it and switch to Cycles to get nodes to work.


It did not work in the link you provided. The bug was that the DNG actually crashed blender. The bug causing the crash was resolved, but DNG was still not supported.

There is a discussion here: http://www.magiclantern.fm/forum/index.php?topic=6457.0  about converting DNG to EXR which may be of interest to you.


Quick anwer, you can reorient gravity by changing the world setting on the scene tab.

From

to

However force fields can provide a more realistic collision at a planetary scale.

For example, here is a direct impact

and a glancing impact

To do something similar to this, do the following in Blender 2.76:

Create a new blend file.
Delete the cube.
Add a sphere for the planet.
Set the gravity in the scene to 0 for all axes.

Rename the sphere to 'Planet'. This is so we can refer to it easier later.
Set the physics for 'Planet'

On the physics tab select 'Force Field', 'Collision', and 'Rigid Body'. This will add several panels.
On the 'Rigid Body' panel, unselect 'Dynamic'. This will prevent the planet from moving due to the simulation.
On the 'Force Fields' panel set the force to a negative value. This will cause other rigid body object and particles to move towards 'Planet'. Use a value of -50 for this example.

Add another sphere. This will be the meteor which crashes in the planet. Rename this sphere 'Meteor'. You might also want to adjust the camera to keep both objects in view.
On the physics tab for 'Meteor', select rigid body. At this point, hitting play on the timeline (or alt-A) 'Meteor' should be pulled toward 'Planet' and stop when it hits the surface.

The final step is to add particles for the explosion on impact.
When running the animation note when the 'Meteor' hits 'Planet'. In this example it occurred at frame 27.
On the particle tab, add a particle system to meteor.

In the emission panel, Set the 'Lifetime' to a large number to make sure the particles persist through the animation. In this example, use 500.
Set the particle 'Start' and 'End' to the frame of the impact. In this example the value is 27. Adjustment may be required for the specifics of a simulation.
In the Velocity panel, set the 'Normal' velocity to a value large enough to overcome the velocity of the impact. In this example, a value of 15 was enough.
On the physics panel, select 'Die on hit'. This will cause the particles to disappear when they hit 'Planet'.

Play the animation using the play button or alt-A, and the result should include a shower of debris after the impact.

The blend file for the direct collision animation above is available at


wireframe render over an object with the subdivision surface wireframe?

Rendering curved wireframes:
Blender Internal
You can either use freestyle or a wireframe material, see Rendering with wireframe.
If you use a wireframe material, make sure Optimal display is enabled on the modifier, otherwise all the edges generated by the subserf will be rendered as wires (they won't be curved).

Cycles
To do this in cycles, you could use two scenes, one for the cycles render and another to render the wireframe with one of the BI techniques.
To get a BI wireframe material to render with a transparent background (for combining with a cycles render), just set the second material to Masking alpha:

And set Alpha to Transparent in Render settings > Shading:

Original answer
OP clarified the question, making this no longer relevant. As far as I can tell, that is..
If you want to do this in the viewport/opengl render, just enable Draw All edges in Properties > Object > Display:

And make sure Optimal display is disabled in the subserf modifier:


I believe your problem in the screen shot you posted is because the direction of your normals don't match. Or it could be that you accidentally made two identical spheres overlapping. Without seeing your .blend I can't verify the nature of the problem. But there is a better way to texture a sphere anyway, and I will now share that with you.

1. Use a round cube instead

To get these menu options enable the Extra Objects mesh add-on in your preferences.

2. Set round cube's divisions as desired

3. UV Unwrap using Follow Active Quads

4. Scale to fit your UV layout and add an image texture

Rotate 180° if feeling unholy ;-)

(I'm just having a little fun, so I hope you guys won't get cross with me)


Shortcut for Back View (Ctrl 1) doesn't work

The macOS Japanese text input implementation was interfering. By disabling it and using the Google IME instead I was able to regain normal functionality of my Ctrl key.

Anyone wanting to know more can read the question I posted on Ask Different that led to solving the mystery.


Sun object not moving when Rendering Animation

It seems that during rendering you need to use the depsgraph so that you obtain an evaluated object.
Don't know why this is not useful when just playing the animation.
So add this line:
sun = sun.evaluated_get(depsgraph)

In the complete function:
@persistent
def sun_handler(scene, depsgraph):
    if "Sun" not in bpy.data.objects:
        create_sun()
    sun = bpy.data.objects["Sun"]
    sun = sun.evaluated_get(depsgraph)
    print(scene.frame_current, sun.rotation_euler)

A link to the documentation if needed.
For information, I've asked on blender coders and had an answer by dr.Sybren:

The difference is caused by the render engine using its own dependency
graph, which is not marked as 'active'. As a result, it does not copy
animated values back from evaluated to original objects.

This behavior is confirmed to be intended.


Tracking Problem with floor and wall and other things

I tracked the garage and the solve error is 0.11 because there is no movement

If there is no motion there is no way to solve a scene. You can't determine 3d information out of a still image.

3D reconstruction is based on calculating 3d space based on the movement of different elements across the frame. Moreover, only translation movement, (where the camera moves sideways or up down, not only rotation) is useful to recreate 3d data. Blender needs parallax information.

For situations like this use BLAM or Fspy.

Read:

How can I recreate geometry using a photograph?

For a comprehensive post on motion tracking read:

How can I get better results when doing camera motion tracking?


Just turn on "Affect Scale" in the snapping settings.

Now just hold left Ctrl and your scale should snap.


The naming scheme is object.parent_clear -> OBJECT_OT_parent_clear.

To find the source code you will usually find the declaration of the operator in the headerfile, somewhere in source/blender/editors/*, in this case it is source/blender/editors/object/object_intern.h

The comment points to the source file source/blender/editors/object/object_relations.c

 541 void OBJECT_OT_parent_clear(wmOperatorType *ot)
 542 {
 543         /* identifiers */
 544         ot->name = "Clear Parent";
 545         ot->description = "Clear the object's parenting";
 546         ot->idname = "OBJECT_OT_parent_clear";
 547
 548         /* api callbacks */
 549         ot->invoke = WM_menu_invoke;
 550         ot->exec = parent_clear_exec;
 551
 552         ot->poll = ED_operator_object_active_editable;
 553
 554         /* flags */
 555         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
 556
 557         ot->prop = RNA_def_enum(ot->srna, "type", prop_clear_parent_types, CLEAR_PARENT_ALL, "Type", "");
 558 }

The poll method checks for the right context. The exec method is located in the same file

 523 /* note, poll should check for editable scene */
 524 static int parent_clear_exec(bContext *C, wmOperator *op)
 525 {
 526         Main *bmain = CTX_data_main(C);
 527         const int type = RNA_enum_get(op->ptr, "type");
 528
 529         CTX_DATA_BEGIN (C, Object *, ob, selected_editable_objects)
 530         {
 531                 ED_object_parent_clear(ob, type);
 532         }
 533         CTX_DATA_END;
 534
 535         DAG_relations_tag_update(bmain);
 536         WM_event_add_notifier(C, NC_OBJECT | ND_TRANSFORM, NULL);
 537         WM_event_add_notifier(C, NC_OBJECT | ND_PARENT, NULL);
 538         return OPERATOR_FINISHED;
 539 }

I would recommend an IDE like QTCreator to follow the symbols though you might use grep/search the files manually.


Video Editing - System Resources not being used

The video sequencer is doing all its editing in CPU currently (version 2.75). I do have a plan to move some operations to OpenGL. A lot of operations are also not multithreaded. Effect application is multithreaded for instance but scaling images to screen resolution, which is a big computational sink is not.


You can use a different weight group for the dynamic paint. Then mix these two groups with the Vertex Weight Mix modifier. This way you can choose how your weights will be mixed with great possibilities.


Yes, you can select all with A.

If there is anything selected then A will deselect everything, if nothing is selected A will select everything.  You can change this behavior immediately after pressing A at the bottom of the T toolbar, or with the F6 menu.


You can change the brightness of the environment texture in the world section by modifiying the Strength value for the HDR.

Read:

How can I create a silhouette using HDR in cycles?

and

Increase brightness of HDR to light the scene, but keeping the background at a lower exposure

and

How do I adjust for overexposure using physically based lighting?

and

How to scale properly HDRI image, to be used in ASC-CDL HDR render?


How to only show the faces of an object based on relation to another object

I might try using the object as a texture coordinates and lining that up with the material alpha value, and then maybe throw in some back face culling so it is not visible from the inside.


Cloth simulation doesn't work for particular object

I had the same problem. Took me over half an hour to figure out.
The problem is caused by duplicated vertices.
To fix it switch to edit mode.
Press Alt + H to make sure there is nothing hidden. Then select all vertices A and then press M to merge them by distance.
Have a look at the status bar: 148 vertices removed. Switch back to object mode. Play the simulation. It works again.


How to copy modifiers with attribute values from active object to selected objects with python scripting?

I don't think that's possible.

A modifier can only be inserted through modifiers.new, so its properties do need to be copied individually. The problem here is in checking which properties can be copied. (e.g., Subsurf modifier's subdivision_type property is actually not readonly as you claimed, but we'd need to test it manually or check the API reference to find out.)

The whole "check writability then copy" procedure can be done more efficiently, though. For example, see this function:

import bpy

def main():
    active_object = bpy.context.object
    selected_objects = [o for o in bpy.context.selected_objects
                        if o != active_object and o.type == active_object.type]

    for obj in selected_objects:
        for mSrc in active_object.modifiers:
            mDst = obj.modifiers.get(mSrc.name, None)
            if not mDst:
                mDst = obj.modifiers.new(mSrc.name, mSrc.type)

            # collect names of writable properties
            properties = [p.identifier for p in mSrc.bl_rna.properties
                          if not p.is_readonly]

            # copy those properties
            for prop in properties:
                setattr(mDst, prop, getattr(mSrc, prop))

main()

It copies all modifiers from active object, to every other selected objects of similar type. What modifier properties to copy is determined by checking is_readonly attribute of all items in the modifier's bl_rna.properties. This way, we can ensure that only writable properties get copied.

In the API Reference, some readonly attributes like Dynamic Paint's brush_settings have no other method of access, so they can be set only through the UI.


Creating glass material - Glass shader or Principled give black/dark or mirror render in Cycles

Idk if this is the result you're looking for but this is the material I use.


What are the intentions of the different forms of Armature/Bone Parent/Child relationships?

Parent Child Relationship and Keep Transform

There are different ways to create a Parent/Child relationship in Blender or parent.
Keep Transform stealthily does the appropriate math with matrices to preserve child placement.
Some ways have [immediate] effect in placement, others (Keep Transform) [delayed].

In the two object parent and armature parent menus above we see (Keep Transform) as a valuable option.
The [Keep Transform] genre intentionally preserve child placement at the time of parent assignment, then you move the Parent for different results.
You should choose the one the best suits your context.  If the [immediate] effect is not what you want today, then the suggestion is to view it as a feature that you may use in the future for a positive Blender User experience.
Both parent menus above have many different options so you may expect this as a feature.  All of those options may be useful to Blender Users in some particular cases.
Via Control-P use Keep Transform for the case in question.  Manually filling in Parent does not necessarily [Keep Transform].  If the parent has any (non default) Scale, Rotations, or Translation the new Child will be transformed accordingly.  Expect this designed behavior.  It is a feature not a defect.
This was intended as a short explanation.  See more here at BSE or the online Blender Manual


Is there a way to remove all colliders at once?

This script removes all colliders from the active view layer :

import bpy

for obj in bpy.context.view_layer.objects:
    if obj.rigid_body:
        bpy.context.view_layer.objects.active = obj
        bpy.ops.rigidbody.object_remove()

How to run a script


bl_space_type = 'NODE_EDITOR' not working

If your Panel's code is just what you posted, then you're missing some parts of a Panel's requirements.
Here's a small template for 'Shader Editor' to mess around:
import bpy

class SuperSimplePanel(bpy.types.Panel):
    bl_label = "The label of this panel"
    bl_idname = "NODE_PT_ThisSimplePanel" # This is new
    bl_space_type = 'NODE_EDITOR'         # This tells where to show
    bl_region_type = 'UI'
    bl_category = 'OH ANOTHER TAB'     # if it doesn't exist, it will be created

    @classmethod
    def poll(cls, context):         # This tells when to show
        return (context.space_data.type == 'NODE_EDITOR' and
                context.space_data.tree_type == 'ShaderNodeTree')

    def draw(self, context):       # This tells what to show
        layout = self.layout
        layout.label("I'm a label in a Panel")

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

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

if __name__ == "__main__":
    register()
```


This is from wiki:

  At the very moment of establishing a hierarchical relationship between
  objects (parenting), the transformation coordinates of the child
  object remain unchanged, and yet this object doesn't change its global
  transforms visually (location, orientation or scale), though its
  reference "world" has changed from global origin (zero transforms) to
  the global transforms of the parent.

  Origin of unparented objects is the global origin: global (0,0,0)
  location, zero rotation, and unity scale. After being parented, the
  new origin should be that of the parent. And it is. But a correction
  matrix is applied to the child, so that the new reference point is not
  the global transforms of the parent, but the global origin. This
  correction matrix is applied to the global transforms of the parent
  before applying them to the child.

This correction matrix called Parent Inverse

You can do this operations with Parent Inverse:

Alt + O (clear origin) - this operation clears Parent Inverse and makes object go to the parent location.

Ctrl + Shift + P (Make parent without Inverse) - it's like what you do in properties -> object -> Relations: Parent. Or like Ctrl + P and Alt + O and Alt + P Clear Parent Inverse in one comand

Alt + P Clear Parent Inverse - Like Alt + O but for rotation and Scale.

Why Blender using Parent Inverse?

Let's try 2 objects  with Parent Inverse:

and without:

As you see, transform matrix, applied on parent object without inverse, makes child object distorted. If you want this effect - you are welcome, but mostly, we don't want it


Aligning plane normal vector side to face a point : Python

The function precisely for that is to_track_quat
Works much like track to constraints. Gives more than rotation difference.

to_track_quat(track, up)

This uses the Vector to point with the specified track axis, (Z for normal) and a secondary "up" axis (x or y, never same ...).

Code would be:

def align_plane_to_point(obj, point):
    dir = point - obj.location
    return dir.to_track_quat("Z", "X").to_euler()

if obj:
    obj.rotation_euler = align_plane_to_point(obj, point)

Of course you can extra check for obj rotation type, the function giving a quaternion, I convert it here to euler assuming the usual kind. Or may use it for rotation matrix, like:

rotMatrix = dir.to_track_quat("Z", "X").to_matrix().to_4x4()

(as quat to matrix produces a 3x3 matrix)

If u need more control, but more complicated, you can have the second dir (up be controlled by another vector) you may look into this, if it helps.

I build there the rotation matrix directly out of 1 vector and a second that is not necessarily perpendicular.

First I make the second/third vector perpendicular by the cross functions, with some exceptions. I'll not copy that here ... Then can build a 3x3 matrix (only rotation) by putting the 3 vecs into columns

mat3x3 = mathutils.Matrix().to_3x3()"
mat3x3.col[0], mat3x3.col[1], mat3x3.col[2] = mx, my, mz"
eulerRotation = mat3x3.to_euler()

where 3 vecs,  mx, my, mz,  mz would be the point - obj.location, the other 2 being determined as in the linked code

if u use directly such matrix (to 4x4 ok) you'll have some difficulty controlling the scale for some exceptional cases (may fall to 0 on some axes), so to euler or to quaternion is the way, even if u further convert back to a full matrix


How to setup custom expression in Blender?

If you want both A and B to be completely dynamic, without having a constant relationship between them, this requires a bit of work (otherwise a simple driver would suffice).

To get this to work, you need to define both properties in a propertyGroup, so that you'll be able to assign "B" with an "update function" - a function that is called whenever B's value changes.

That function then needs to parse your expression and assign the correct value back to B.

Here's the code for getting this to work:

bl_info = {
    "name"        : "Test",
    "author"      : "TLousky",
    "blender"     : (2, 74, 0),
    "version"     : (0, 0, 0, 1),
    "location"    : "3D View > Toolbox",
    "description" : "Test 123",
    "category"    : "Test"
}

import bpy
import re

class samplePropertyGroup( bpy.types.PropertyGroup ):
    def update_b( self, context ):
        ''' Update function for property "B". This function is called whenever B's value is altered '''

        # Regular expression pattern for parsing the typed in expression:
        # (?:duration)? --> The word "duration", which might or might not appear
        # (?:\s+)?(?:\+)?(?:\s+)? --> The plus sign, which might exist or not, with or without spaces before or after
        # ([\d\.]+) --> the actual numerical value in the expression, which could have a decimal point or not
        pat = "(?:duration)?(?:\s+)?(?:\+)?(?:\s+)?([\d\.]+)"

        if "duration" in self.b:                # If the word "duration" exists in the manually assigned value
            m = re.match( pat, self.b )         # Then parse the string to extract the numerical value out of it
            if m:                               # And if parsing was successful
                numVal = float( m.groups()[0] ) # Get the value from the regex match object's capturing group
                self.b = str( self.duration + numVal ) # Then assign the value plus the duration prop's value back to "b"

    duration = bpy.props.FloatProperty(
        description = "This property is a simple float prop that doesn't support expressions",
        name = "duration" # Recommended not to use caps at the beginning of var names as a habit
    )

    # This one needs to be a string to be able to accept strings such as the other prop's name
    b = bpy.props.StringProperty(
        description = "This property also accepts strings and might actually use them",
        name        = "b",
        update      = update_b # This is the important bit here, a reference to the update function
    )

class samplePanel(bpy.types.Panel):
    ''' Sample Panel '''
    bl_label       = "Sample Panel"
    bl_idname      = "sample_panel"
    bl_category    = "Test"
    bl_space_type  = 'VIEW_3D'
    bl_region_type = 'TOOLS'

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

        P = context.scene.sample_props

        col.prop( P, "duration"      )
        col.prop( P, "b" )

def register():
    bpy.utils.register_module(__name__)
    bpy.types.Scene.sample_props = bpy.props.PointerProperty(
        type = samplePropertyGroup
    )

def unregister():
    bpy.utils.unregister_module(__name__)

You'll need to install this as an addon to test it, as it creates a new tab in the tools panel called "Test", where you will find both your properties.


As you stated in your question you have different objects for the parts and parented them to the bones. So they are not deformed at all anyways. You have to make one model and parent that to the armature (not a bone) with automatic weights, then that option would probably work but I actually never used it


Why are the renderlayers rendering black?

This is because the Scene layers corresponding to your renderlayers are not enabled:

If you enable the right scene layers (or all of them), then it works as expected.

Note that by default the 3D view layers are linked to the scene layers. You may want to turn this off by toggling Lock Camera and Layers in 3D view > Header:

Also note that there is nothing on the Lines renderlayer; perhaps you meant to select this layer instead?


2.83 - Cycles - CUDA error: Out of memory in mem_alloc_result, line 815

Denoising the entire 1920x1080 image at once caused the out-of-memory issue. Disabling Progressive Refine and making the tile size reduced the number of pixels denoised at once, eliminating the issue.


Should I create a large map as a single model or in sections to export to Unity?

There are many ways to create large maps depending on the game project. You can finds lots of intricate information on YouTube searching for "GDC terrain" for example. The awesome AAA examples are often low-level implementations with many optimization techniques tailored to the specific games. Unity has their own optimized terrain system featuring texture painting, collider and foliage but not everyone opt to use it.

Most terrain systems featuring an async continuous loading do it in square chunks. The game world is divided by the world coordinates and the terrain system keeps the nearest 4, 9, 16 or so terrain chunks around the camera position loaded. Choose your chunk size considering how far the player is able to see in general and in programming parametrize chunksize so that you can easily try different numbers to see which performs and works best for your game project.

Finally when it comes to Blender and modeling the terrain, consider what you want to store in the mesh data. You probably need a material with UV coordinate or you could use the world position XY in shader. You probably need multiple materials. You could do it with a splatmap texture or you could use vertex colors or even material slots if you don't need seamless transitions between materials. UV2 you should keep for lightmapping when working with Unity unless you have an alternative plan about lighting.

When transforming the terrain mesh remember that you don't want to disturb the chunk seams. Many games including WoW only transform the terrain in Z axis and any more complex geometry comes from additional meshes on top of the terrain. If you establish smooth rolling terrain using subdivision modifier, you can also get simplified collider for the terrain chunk by reducing subdivision level. This could be a clear starting point for a system to build up from.

Unity has vertex limit of around 64k per mesh so that might also limit your chunk size. I wouldn't split the mesh until exporting, you could set up a python script to do it for you where you could input your desired chunk size to tie in with what you want to use in Unity.

In the end this is a very open ended theme that depends heavily on your game idea and ties closely in with your game development environment.


Update StringProperty on object selection change?

This is the full script for selection and update, where emped the update function in our custom selection tool, the last function replaces the shortcuts of the old select with this operator so no damage is done and when unregistering the addon the shortcuts are reset to the previous state. run the script and open the Tools panel ( T in viewport ) and select an objectto see the string update

import bpy
from bpy.props import BoolProperty, IntVectorProperty

class MyGroup(bpy.types.PropertyGroup):
    bpy.types.Scene.my_string = bpy.props.StringProperty(name='my_string')

# Define operator to change string property.
last_selection = []

# the selection operator with the update func :
class SelectionOperator(bpy.types.Operator):
    """ Costum selection
    """
    bl_idname = "view3d.select_costum"
    bl_label = "costum selection"

    extend = BoolProperty(default = False)
    deselect = BoolProperty(default = False)
    toggle = BoolProperty(default = False)
    center = BoolProperty(default = False)
    enumerate = BoolProperty(default = False)
    object = BoolProperty(default = False)
    location = IntVectorProperty(default = (0,0),subtype ='XYZ', size = 2)

    def execute(self, context):
        #select the object
        bpy.ops.view3d.select(extend=self.extend, deselect=self.deselect, toggle=self.toggle, center=self.center, enumerate=self.enumerate, object=self.object, location=(self.location[0] , self.location[1] ))
        #change the property
        global last_selection
        if bpy.context.selected_objects != last_selection:
               last_selection = bpy.context.selected_objects
               bpy.context.scene.my_string = bpy.context.selected_objects[0].name

        return {'FINISHED'}

    def invoke(self, context, event):
        if context.space_data.type == 'VIEW_3D':
            self.location[0] = event.mouse_region_x
            self.location[1]  = event.mouse_region_y
            return self.execute(context)
        else:
                self.report({'WARNING'}, "Active space must be a View3d")
                return {'CANCELLED'}

def replace_shortkey( old_op_name, new_op_name) :

        wm = bpy.context.window_manager
        keyconfig = wm.keyconfigs.active
        keymap = keyconfig.keymaps['3D View']
        items = keymap.keymap_items

        item = items.get(old_op_name, None)
        while item :

                props = item.properties

                extend    = props.extend.real
                deselect  = props.deselect.real
                toggle    = props.toggle.real
                center    = props.center.real
                enumerate = props.enumerate.real
                object    = props.object.real

                item.idname = new_op_name

                props.extend    = extend
                props.deselect  = deselect
                props.toggle    = toggle
                props.center    = center
                props.enumerate = enumerate
                props.object    = object

                item = items.get( old_op_name, None)

# Draw property and operator.
class HelloWorldPanel(bpy.types.Panel):
    """    """
    bl_label = "active object Panel"
    bl_idname = "OBJECT_PT_my_panel"
    bl_space_type = 'VIEW_3D'
    bl_region_type = 'TOOLS'

    def draw(self, context):
        layout = self.layout
        layout.row().prop(context.scene, "my_string")

# Register.
def register():
    bpy.utils.register_module(__name__)
    replace_shortkey( 'view3d.select', SelectionOperator.bl_idname )

def unregister():
    replace_shortkey(SelectionOperator.bl_idname, 'view3d.select')
    bpy.utils.unregister_module(__name__)

if __name__ == "__main__":
    register()


Maybe you are viewing/rendering in another layer? Or the Cup is the one in another layer? I have circled the layer boxes, if you are wondering where the layers can be found.


In the animation editor, position the 2D cursor to the frame you want to use as the "origin" for your scale operation (probably the first frame of the animation) and set the pivot point to "2D Cursor".

Select the keyframes you want to scale. Press s to scale, x to scale on the x-axis (time), then type 66, and press Enter. Then press s, x, then type 110/ to scale by 1/110, and press Enter to apply. This will scale your keyframes' timekeys by a factor of 66/110.

The keyframes will probably not align perfectly with entire frames. Blender's interpolation system can handle this just fine. If you want, you can snap them to entire frames by pressing Shift+S and choosing "Nearest Frame".


In layman terms loop cut will only work on geometry with 'clear edge flow' meaning in most if not all cases you should ideally be able to look at it and tell where the cut will go or it should divide your mesh equally into more sections that can be cut again. So it won't work for triangles (3 vertices) or ngons (mesh with more than 4 vertices), What is non-manifold geometry?. There is a simple work around however. Create a cone by adding a cylinder and scaling the top as small as possible without actually letting the vertices overlap, when zoomed out, this is unnoticeable.


How to invert gloss on a procedural texture?

In your node setup, the roughness (a.k.a. glossiness) comes from a color ramp:

So the simplest solution seems to be replacing black with white and white with black on that color ramp. At least if you properly diagnose your problem as being the opposite to what you want - because inverting those colors will invert the roughness.


Cannot translate vertice/edge will duplicate

Paul Gonet solved your problem in the comments, but here is how you can spot the problem yourself, and a bit more detail for future reference.

You are not making a new vertex but rather moving only one vertex when there are two in the same place.

You can easily spot that problem, double vertices,  by looking at the selection color of the edges. In your image below I highlighted in red the edge you should watch out for. It is not selected, that means that it is not connected to the vertex you do have selected (and thus there is a double vertex hiding there).

Whenever you select a vertex all the edges connected to it should be the selected color (the default is orange) around the vertex (the whole edge will not change color, the selected color fades out along the edge).

You can select the second vertex that is hiding there, change the shading mode to Wireframe in the 3D view header or by pressing Z. Now select one of the vertices that are there, then hold Shift and select the second.
You can also use border select B, circle select C, or lasso select (hold Ctrl and drag with the LMB
 held) to easily select double vertices.

To get rid of the problem you can use the Remove Doubles operator or Merge them. Both are accessible in the Tools tab of the tool shelf and many other ways.

Remove Doubles (W then R) will go through every vertex that is selected and see if there are any within its merge distance if there are, then it will merge them.

Merge (AltM) can be thought of as a manual version of the remove doubles command, but with much more control. For a scenario like you have where the two vertices are in the exact same place, any of the first three options will work fine (and do the same thing).


Once you activate the Inset tool  Disable "individual"


How to export multiple NLAtracks to a single .fbx file in blender 2.80?

I'm not sure what your use case is, but I'm using this to import animations into Unity game engine. The NLA tracks thing doesn't seem to work with 2.8 and Unity, but you can have several actions created in the Dope Sheet --> Action Editor, and when you export, select "All Actions":

One thing that messed me up was that you have to completely delete the .fbx file and create a new one in order for Unity to recognize it properly and update the list of animations. Reimporting or refreshing doesn't work if you just replace the file that was already there.


Camera position when scaling entire scene

Method by Parenting

Create an empty at the scene's center.
Parent the Camera to the Empty. Select  RMB the Camera, ⇧ Shift RMB the Empty and press ⎈ CtrlP > Object.
Select all objects (including the empty) except for the camera and scale them as you intended.


Creating curved grid with triangle windows

The shading issue is coming from the subdivision modifier trying to average out all those cuts into the surface. The explanation for how to resolve that issue is a bit lengthy so please bear with me.

I've assumed you're trying to build these windows and attach them to the outside of the curved surface. If you intend to use the Boolean modifier to cut these windows into the curved surface, there's another world of hurt coming.

Also, the final model isn't 100% perfect, there are still some minor shading issues which could still be cleaned up.

I've made this by modelling a window as its own, separate object and using an array and mirror modifier to duplicate it.

The window itself is rather simple. I took a plane and inset it (the shortcut key is I. From there, I cut out the center triangles and applied a Solidify modifier. Since I intended to use the Simple Deform modifier to bend the window, I needed there to be sufficient geometry for the bend to work properly. To add that geometry, I used the Subdivision Surface modifier.

To maintain the shape of the window cutout while using subsurf, I added a few support loops and a slight bevel modifier. To keep the face shading from getting messy, I marked the edges of the outer/inner perimeter of the window frame as sharp (you can do this in Edit mode by selecting the edges, pressing Ctrl+E and selecting Mark Sharp. This will cause the edges to appear blue by default in Editing mode, but is not shown in my wireframe screenshot).

As mentioned earlier, I used the Bevel, Subdivision Surface, and Simple Deform modifiers to bend the window shown below.

In the process of replicating the window, I need to move the origin which screwed up the Simple Deform modifier. I would thus need to apply the modifiers, but before doing so< I saved the original window without the modifiers applied and hid it. Backing up your models before applying destructive editing can save your life if it turns out there was a problem with the model before applying those modifiers.

Noting that your model has a forward-facing window than a horizontally flipped window, I took the object and added a Mirror modifier with an object offset before applying the Simple Deform modifier. Doing it after the fact would mess up the mirror line.  Admittedly, this could have also been done by hiding all the modifiers, duplicating it and rotating the duplicate 180 degrees.

At this point, I applied all the modifiers. To duplicate the object and rotate it around the curved surface, in my case an open cylinder, I used an Array modifier with just an object offset (make sure you disable the relative offset). The object, in this case, add an Empty Axis at the origin and use that as the target object.

When you do that, you'll find that all the array modifier isn't working yet. Move the 3D cursor back to the origin (Shift+S - Cursor to World Origin), select the window, right-click and Set Origin > Origin to 3D Cursor.

Now, select the empty axis and rotate it on the Z-axis only, and each additional window from the Array modifier will be rotated that angle around the origin. Rotate it so that the windows line up just right.

Finally, just to keep things neat, parent to the empty axis to the window so that you can move the windows around without messing up the array modifier then hide the empty axis.

I've included the blend file below.


Render Image renders, closes, renders again

In the Properties editor, Render Layers tab, you can click on the plus sign under Scenes, and then Render Image will render once for each layer.  Could you have been in there and clicked on the plus sign, creating extra render layers?


why is the foot skin still kinda sticking on the ground?

It's your Weight Painting.

Select the mesh, key Ctrl + Tab to enter Weight Painting mode, and key T to toggle open/close the Toolshelf. Go to the 3D Viewport > Toolshelf > Brush > Weight: value and enter 1. Drag the brush over the problem spots. They should change from blue to red and rejoin (jump to) the rest of the mesh (foot).


Another way you can do this is with Proportional Editing (O):

Steps taken in the gif

Add a cylinder (⇧ ShiftA> Mesh > Cylinder)
Enter Edit Mode (↹ Tab)
Select the top and bottom faces (⎈ Ctrl↹ Tab> Face to set the selection mode, then ⇧ Shift RMB to select)
Inset (I)
Select just the top face and inset again (I)
Add loopcuts (⎈ CtrlR, then  MW to adjust number of cuts)
Select the middle ngon
Turn on Proportional Editing (O) and set the falloff type in the header
Move the face down on the Z axis (G, Z. Use  MW to adjust the falloff)
Add a subsurf modifier (⎈ Ctrl1, where 1 refers to the number of subdivisions in the modifier. Can be any digit from 1 to 5)
Add supporting loopcuts (⎈ CtrlR) to control the subsurf.


Minecraft Animation: My grass has black texture after render. How Do I Fix?

It looks like your light bounces are low for that many transparent images.

Try increasing your transparency light bounces under
Properties > Render > Light Paths > Max Bounces > Transparency


Filling large gaps between curved geometry using faces?

In case like this it might be easier to continue using curve object for modeling and convert it to mesh once the wave is completed.

Bezier curve objects can be filled to become flat surfaces. It's possible though to do that only when their shape is set to be 2D, i.e. positon of control points is constrained to their local XY axes. You still can rotate curve in Object mode though.

So grab your curve which was used for wave creating, set its Shape option to 2D and rotate as needed in Object mode. Note - it is important to do that in Object mode as rotating in Edit mode will actually create straight line because movement of control points is constrained by 2 axes.

To give curve thickness use Extrude option in the Properties editor > Object Data tab > Geometry rollout. To control resolution use Preview U option in the Shape rollout.

Once you use everything possible of the curve you can convert it to mesh. Note that most likely you'll need to retopologize the mesh as converted curves often have topology not suitable for anything like later subdivision or beveling.


Assuming that 'goal' is where the boids should end up, and the pyramid is an obstacle to climb over, this is the desired outcome. In this case, the pyramid should not be a goal for the boids.

The key to get the boids to climb over the pyramid is to make it 'sticky' using the stickiness collision parameter for the pyramid and plane.

If the stickiness is set to 0, then the boids will flow around the pyramid like below:

The basic setup to get this result is as follows:

Create a scene with a plane, a pyramid, a particle emitter (an icosphere in this example), and a goal object (the text).

For the icosphere, add a particle system. Set it up as shown.

Add collision physics to the plane and pyramid, set the stickiness as shown.

Play the animation...

The blend for the animation above is here:


How to check if the active object is using no material

Get all the materials

materials = bpy.context.active_object.data.materials

Count the material slots

nMat = len(materials)

Check if a material slot is empty (in this case, the first slot)

isEmpty = not materials[0]


What image file do I use for dynamic text?

There are two methods to show dynamic text with the BGE.

Textobjects

They are easy to setup. You add the textobject, set the text in edit mode and start the game. Changing the text in game can be done via setting the attribute "text" in Python:

import bge
textObject = bge.logic.getCurrentController().owner
textObject.text = "my new text"

or if configured by setting a property called "Text":

The faces of the resulting object consists of several quads. The texture is rendered from an font while the game is running. You do no have access to the quads nor the textures.

Bitmaptext

This was the method before introducing the text objects (see above). A bitmap text object is a plain plane object.

You need a specific material setting Game Settings/enable Text:

Addional you need a special image as texture. It has meta informations regarding each single character encoded in the top line of the texture.

These data should never ever be changed. This also means you need an image format with lossless data compression such as .png or .tga (never jpg).

The UV mapping of the quad should fit the first character in the texture which is an @ character. This is the maximal bounding of an character. The BGE will derive the size of all other characters from this setting.

You can generate such textures with a tool called "FTBlender" from fonts of your OS. Alternative you can search the internet for bitmap text images.

This method allows you to manipulate the image of each single letter as long as you leave the metadata unchanged. This way you can get very artistic and colored characters.

I hope it helps

PS: here is a sample image- baloon.png:


Sculpting Issue: Mesh disappears into another one

In Sculpt Mode click Sculpt (to the right of where Sculpt Mode is shown) and now > "Show All".
For some reason, Alt + H doesn't unhide properly between edit-mode and sculpt-mode for me. So if I hide vertices in edit-mode and switch back to sculpt mode, the connecting faces are gone. Going back to edit-mode, pressing Alt + H reveals the hidden vertices in edit-mode, but they are gone again when I switch back to sculpt-mode. Only in sculpt-mode I can Show All to un-hide those vertices again.


To align the vertices, just scale them to zero along the perpendicular axis.

To scale multiple lines at once, set Pivot to Individual Origins.


Is there a node like MixShader but for the displacement slot?

You can use the factor of a Color > MixRGB to switch from an image to another, and plug the MixRGB into the Displacement node.


Why is the resulting UV map stretched out when unwrapping my object?

The solution is:

In Object Mode: Apply the scale first.

Now you can unwrap it.

See the image below:

Edit: It is a good practice to Apply any transformations (scale, rotaion...)before using any modifier or/and Unwrap.


You can copy nodes with Ctrl+c and paste them with Ctrl+v in the Node Editor. This will work with one material or multiple materials,lamp node trees as well as compositing nodes and World node tree. You cannot copy and paste compositing nodes into material node trees and material nodes into compositing node trees, but it seems you can copy/paste between material,light and World node trees.

If you need multiple objects to have the same material, you can select them all with the one with the desired material being the last selected(active) and hit Ctrl+l -> Materials. They will then have the same material that will change on all of the objects if edited. If you want to edit the material of an object separately, you need to make it unique(single user) by clicking this number icon identifying how many users the material has:

or you could select multiple objects in the 3d viewport, hit u and choose "Material+Tex".


is there a way to speed up the render process?

If you're able to, start thinking about how you can break your project down into manageable parts.
You say you have a large city. Does every building need to be an actual object? Maybe think about making billboards (a plane with a texture on it), with buildings on them.
Is every building super detailed? Think about making LoD (level of detail) variants that are less detail and less poly count. So the further away something is from the camera, the less detail it has. Which means overall your scene is less heavy. Kind of like how video games work.
Also, try and make sure your buildings aren't super messy in terms of geometry (extraneous loop-cuts, floating verts, etc.). It's a small thing, but multiplied by the amount of an entire city's worth of messy geometry, it can have an effect.
Do you have multiples of the same building? Are they duplicated? If you've got a bunch of objects that are duplicated with shift+d, each of those objects are treated as individuals. If they're all exactly the same, it's a waste of memory and can also cause problems with scenes. Instead, instance those objects with alt+d. Which means each instanced object shares the same data between those objects. Which lowers memory cost.
Do you have heavy effects like volumetrics? Are they necessary? Sure, everyone loves having atmospherics and stuff in their scenes. But if you just need some slight fade in the distance to make your scene have an atmosphere, do you really need to use something like volumetric absorption/scatter? You can get pretty much the same effect with a low-strength emission node in the volume output instead. It's essentially free in terms of render times.
Also, making sure that your tile-size in render settings is correct, is important if you're using GPU. 256x256 is generally the most optimized when it comes to GPU rendering.
Lastly, if it's still not having an effect, look into distributed rendering solutions like SheepIt. It'll render multiple frames on other people's computers, which should give an output in a more reasonable time-frame.


The most likely culprit is the object draw mode (Properties Window > Object Tab > Display > Maximum Draw Type)

Set it back to Textured if you want to be able to go to textured view (and to Solid if not).


I don't have a tool that does this for you, but you can manipulate the shape yourself. Here's how I would do it:

go to edit mode (either press Tab or go to the left corner, change it from Object Mode to Edit mode) you know that you are in Edit Mode if you see the vertices of the cube as dots

now select 4 vertices while holding Shift (the selected vertices appear orange and the one you selected last is white)

press S (for changing the scale) and then press Y (to scale it along the Y-axis, but you could also press X to scale it along the X-axis or Z)

to scale it you just need to move your mouse in the direction you want to scale it
if you are still in the scaling mode (you see a dotted black line coming from the center of your object), you can switch between the axes by pressing X, Y or Z and continue scaling along them

Hope this helps
(if you just want to move one vertex at a time, just click on the one you want to move and then press G to move it in space or G and then Z to move it along the Z-axis)


Out of nowhere, my frames became connected, and now I cannot edit my frames! Any changes I make apply to all of them

When you have two keyframes with no change in their values, a dark yellow line connects them. When the values are different the line goes away. It is meant for you to know if there is a pause or a "hold" on the motion or whatever animated parameter you are displaying.

on the image all of the keframes are selected (showing as yellow). To edit just one deselect all and then just select the one you want to change.


How can I find the camera viewplane size?

Using the compositor to do this is probably a better alternative. Something like this would do the trick:


Character start distorting when I moved the body rig

I would personally merge all the character's part to make one object, it would make things easier in my opinion. But first select the armature, display the layer with the deforming bones:

Then shift select the mesh and check the bones, you can see that some have influence when they should not:

Select these parts in Edit mode, in the Properties panel > Object Data > Remove From All Groups, then reassign to the right group (the one that has the name of the bone that is supposed to control) with the Assign button. Or do the corrections with a brush (in Mix or Subtract mode) in Weight Paint mode.

For the smoothness yo could add a Subdivision Surface under your Armature modifier, but you should add edge loops where the bending is happening (by the way, no need for so many horizontal edges in my opinion, especially if you add a Subdivision Surface):


How to loop an animation in Animation Nodes?

You can use the Ping Pong option of the Repeat Time node as follows.


How to remove this "edit mode" shadow thing?

Adding a subsurface modifier to the mesh worked for me.

Before:

After:


How do I avoid deformations while rendering?

Under Object Properties > Shading > Shadow Terminator Offset


How to draw Inputs from Geometry nodes modifier in a panel

The modifier input value is treated like a custom property.
If you right click over the data field in the modifier and select "copy datapath", pasting will reveal
modifiers["GeometryNodes"]["Input_5"]

Indicating it is a custom propoerty of the modifier named "Input_5".  A custom property naeed "prop" on object ob is shown in UI as
UILayout.prop(ob, '["prop"]')

Hence in this case.
    def draw(self, context):
        layout = self.layout
        row = layout.row()
        row.label(text = "Geometry Node inputs here")
        row = layout.row()
        gm = context.active_object.modifiers.get("GeometryNodes")
        if gm:
            row.prop(gm, '["Input_5"]',  text="Density")

Note
Check out the style guide under which the modifier instance variable would be named akin to geom_modifier (I like using gm to reduce the verbosity) Camel case is used for class names. A variable named GeoNodesModifier will consistently be a type in any official blender UI code


Why can't I smash these 2 fractured objects together?

Check the "Animated" box in your physics settings. As it's name states, it will allow you to animate the objects with keyframes.


Why am I only seeing vertices in edit mode?

Update: Fixed it! Apparently all I had to do was show hidden with Alt +  H I'm not sure how exactly I managed to hide only faces in edit mode, but I've resolved the issue regardless.


Boolean operation section cut pattern black

The solution is to apply the material of the cut plane to the objects you want to cut below their original materials. Here this dark brown material is applied to the cut plane as a primary material and to the box as secondary material. Then the boolean operation colors the common faces with the material of the section plane.


Cycles menu doesn't have setting required

If you can’t select the GPU in the render options, go to Edit > Preferences, then I think it’s System. There you will have boxes like CUDA, OpenCL etc. If you have a graphics card, it will be under one of those options. Make sure you check the box for it. Then you can go back to the render settings and you should be able to select your GPU.

Also, enabling the GPU won’t neccesarily give your renders less noise. It will just render faster than the CPU, which allows you to use higher samples for less noise.


Adding smudges/fingerprints to a glass material

You can add smudges and fingerprints to glass by varying the Roughness with the following material :

Most of the above material is concerned with positioning the fingerprints on the bottle (ie, the upper branch from the Texture Coordinate node through to the first Multiply maths node). This takes the fingerprints image :

and positions it onto the glass by way of using the Object coordinates of an Image Empty - moving and rotating the Image Empty will control the location of the fingerprints within the following scene :

The Value node controls the 'strength' of the fingerprints and the Is Glossy Ray of the Light Path is used to prevent the fingerprint from producing glossy reflections from any light sources. This is fine tuned using a Power node (you could just as easily use a Color Ramp to allow manual adjustment) and fed into the Roughness.

This will result in anything viewed through the surface smear/fingerprint becoming distorted.

This can produce the following results (note the fingerprints and smudges on the closest bottle) :

Blend file attached.

EDIT : The above example is using a simple Glass shader for the glass and as it stands this will cast shadows. This is why the interior of your building is considerably darker in your example. In my example this wasn't too much of a problem but in your example the windows are effectively blocking the light from entering the interior space. You should mix in a Transparent shader based on the Is Shadow Ray light path property so as to make the glass transparent when determining shadows.

Your original material included this mix but the new one does not. Hopefully this will resolve your problem.


Bmesh.ops.mesh_to_bmesh usage returns cryptic error

The proper function to be used is the  bm.from_mesh(me) function where bm is the bmesh object being transferred to and me is the mesh. Also for the reverse operation we can use bm.to_mesh(me) which will load the bmesh data back into the mesh.

For code example see the template bmesh_simple.py which is included in blender text editor.

some of the bmesh operation didn't work yet like bmesh.ops.bmesh_to_mesh , mesh.ops.mesh_to_bmesh and bmesh.ops.object_load_bmesh, the only note is that the DOC says :

  this bmop is private


You need to imagine drawing a circle with a centre at the pivot. As your pivot is above the plane, that circle starts in the way you are seeing. Move the pivot parallel to the plane you are extruding and you will get the behaviour you are after.


Script only running on Active Object, not whole Selection?

Set the active object in the loop, as it appears bpy.ops.mesh.customdata_custom_splitnormals_clear only works on the active object. Not on all selected.

import bpy

context = bpy.context
scene = context.scene

selected_mesh_objects = [o for o in context.selected_objects if o.type == 'MESH']

ao = context.active_object

for o in selected_mesh_objects:
    scene.objects.active = o
    r = bpy.ops.mesh.customdata_custom_splitnormals_clear()
    print(o.name, r)

# change ao back to original
scene.objects.active = ao

Note added print statement with name and operator "result".  A {'FINISHED'} set will indicate object had custom split normals and they have been removed.


No, it is not possible.
The deformation of the mesh is created by the different positions of each vertex. If you delete vertices, you will lose information thus losing the original shape.

There is no way for the software to know where you would want the face to bend, and as a matter of fact the preferred way to tell that to the software is to add vertices and move them accordingly.


How do I model the express key of a wacom tablet?

Add a Circle mesh and select half of the vertices.

Press Y to separate the selection, and move it away along whichever axis it faces.

Select all (A) and press F to fill the shape with an n-gon.

In Edge Select Mode (2), select the two longest edges, press W and select Subdivide.

Select the new edge and press ⎈ CtrlB (Bevel Tool). Scroll  MW up once or type 2 to get two segments.

Select everything and press E to extrude the shape.

Select the center edge and move it down.

Delete the faces on the bottom.
Finally, select all the sharp edges and bevel them to your liking.

I'd recommend shading smooth at this point. ;)


Make sure the Eevee render engine is turned on, and make sure you're using the rendered view and not solid view. the light should affect the cube after that (although if you want reflections or anything you need to turn that on in screen space reflections)

If this doesnt work it may be due to hardware limitations


How to cut sphere with sphere? Topology problem

It's possible to avoid much work here with simple inset. It won't provide great topology straight away, it will add loopcut all over the corners where sharpening is needed in order to add Subsurf.

When you have a letter just after the Boolean chances are it looks something like tris, lack of continous loops etc. Select the part with indentations (the one you'd like to sharpen out):

Invert the selection (most likely face selection will be the most comfortable). It's also possible to use Outset option by pressing O while Inset is active; then insetting will happen outwards and this step should be skipped:

Then inset with I. There will be some areas where inset will create self-intersecting geometry, some cleaning work will be needed. However it might not be necessary to do it for all the letter (although it all depends on the final result as always):


converting parametic equation using python

I figured it out here's a snippet
#loop_pos = 0 # not enabled yet look at eq_2 in other python script 1 gives  full connection
n = loop_num #is the number of turns per winding.
m = loop_windings #is the number of helical windings.
u = 2*math.pi*(i/(num_x-1-(loop_pos*(num_x+1))))  #loop_pos = 1  eq_2 in other python script 1 gives ou full connection
lamda = 1 #-1 or +1 for winding directions right +1, left -1

x = math.cos(u)*(uval_R_bg - uval_r_sm * math.cos(2*math.pi*helix_offset/m + (lamda*n*u)))
y = math.sin(u)*(uval_R_bg - uval_r_sm * math.cos(2*math.pi*helix_offset/m + (lamda*n*u)))
z = uval_r_sm*math.sin(2*math.pi*helix_offset/m + (lamda*n*u))


How to scale objects vertically depending on proximity to an empty?

Can do it using a "shrinkwrap" modifier driven by a "vertex weight proximity" modifier.

Each cube is a separate object like this with a vertex group (only the top vertices are attached to this group with a 0 value):

Each cube as the following modifiers:

"vertex weight proximity" that influences the vertex group values, using the empty proximity in "object" proximity (so that all vertices of the group will have the same weight)

"shrinkwrap" to a plane placed above in "project" mode along Z. Tune the "offset" value to vary the height influence

If you need to set the modifiers to several selected objects from the active one, use CtrlL then "modifiers".


Someone answered me elsewere.

Turns out you need to have your SLI "DISABLED" which is very confusing since you need to enable that to have better performance in everything else.


Scale about true center with Mirror modifier

Snap Cursor to Selected.
In the Properties shelf, for the mirrored axis, subtract the Median location from the 3D cursor location.
Set 3D Cursor as Pivot.
Scale.


What is the difference between scene camera and data camera and how to set the FOV?

I'm not that familiar with the structure of Blender's type hierarchy, but according to the documentation for Blender's Object type there is a distinction between the object and the objects's data block.

# From Blender's Documentation:

# Create new lamp datablock
lamp_data = bpy.data.lamps.new(name="New Lamp", type='POINT')

# Create new object with our lamp datablock
lamp_object = bpy.data.objects.new(name="New Lamp", object_data=lamp_data)

Likewise, bpy.context.scene.camera is a Blender Object type which has its camera specific attributes stored in it's data block of Camera type, which can be accessed with the attribute data.

camera = bpy.context.scene.camera
camera.data.angle_x = math.radians(69.4)  # angle_x and angle_y take radians

The properties panel in the user interface is arranged the same way. Values like location, rotation etc. are set in the Object tab, type specific values like the Field of View of a camera or shape keys for a mesh are set in the Data tab.

You could also have more than one camera in the scene, in which case the cameras could either be accessed as objects in bpy.data.objects['<name>'] (with the camera data accessible from the objects's data attribute again), or you access the data block directly bpy.data.cameras['<name>'].
bpy.context.scene.camera would only refer to the active camera of the scene, just like the corresponding entry in the properties panel under the Scene tab.

N.B.: I assume angle_x and angle_y can't be set independently but instead are coupled by the aspect ratio. If you set angle_x, angle_y will follow suit.


Is there an easy way to set the speed in units like km/h for an object travelling along a path?

I think I finally have a working solution:

    import bpy, mathutils
from mathutils import Vector

le = 0

#Speed in m/s
targetSpeed = 10
obj_name_original = bpy.context.active_object.name

def getLenght():
    ob = bpy.context.active_object
    if ob and ob.select and ob.type == 'CURVE':

        em = (ob.mode == 'EDIT')
        bpy.ops.object.duplicate_move()
        bpy.ops.object.mode_set()
        bpy.ops.object.transform_apply(scale=True)
        bpy.ops.object.convert(target='MESH', keep_original=False)
        ve = bpy.context.active_object.data.vertices
        global le
        dd = le = 0
        for i in bpy.context.active_object.data.edges:
            dd = ve[i.vertices[0]].co - ve[i.vertices[1]].co
            le += dd.length
        le = round(le,4)
        bpy.ops.object.delete()
        print(le)
        if em: bpy.ops.object.mode_set(mode='EDIT', toggle=False)

        global obj_name_original
        bpy.context.scene.objects.active = bpy.context.scene.objects[obj_name_original]
        bpy.context.object.select = True

    else:
        raise Exception("The selected object is not a curve")

targetC = 0

def findC():
    global obj_name_original
    for ob in bpy.data.objects:
        if ob and ob.type == 'MESH':
            for c in ob.constraints:
                if c.target.name == obj_name_original:
                    global targetC
                    targetC = c
                    #print(c)

def setO(scene):
    global targetSpeed
    global targetC
    global le #scene.render.fps    ((le/targetSpeed))*(scene.frame_current/(scene.frame_end*targetSpeed))
    targetC.offset_factor = scene.frame_current/((le/targetSpeed)*scene.render.fps)

getLenght()
findC()

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

def unregister():
    bpy.app.handlers.frame_change_pre.remove(bpy.app.handlers.frame_change_pre[-1])

if __name__ == "__main__":
    register()

The way it works is that it approximates the length of the curve, and then changes the offset of the object following it every frame - essentially animating it. It does require that you select the curve before running the script, otherwise, it will purposely crash.

If you want to use km/h instead of m/s you just need to divide the speed by 3.6, which will convert it to m/s.


I had this problem, export as obj, reload start up file, import the obj then export as fbx.


With pivot set to '3D Cursor', assuming the length of your baseball bat is in Z, and with the 'Loop Tools' built-in Add On enabled ...

Select a transverse edge loop near the bottom of your tape winding
ShiftS 'Cursor to Selected'
Select a vertical set of vertices spanning the height you will want your spiral

ShiftD duplicate that span (in real life,
right-click to leave it where it is, on the surface of your object)
W > Subdivide the selection. In the tool region, adjust the count to create as many vertices as you will eventually want on your spiral... (total turns * vertices per turn).

With the vertices in the profile selected, use W > Loop Tools > Space to distribute them evenly along your profile.
O .. switch on Proportional Editing. Set the Falloff Type to 'Linear'... Select the bottom vertex of your profile alone ... hit RZ.  Using the scroll-wheel, adjust the range of your proportional edit to include the top vertex of your profile.

With each wind of your mouse around the 3D cursor, you will introduce a new turn on your spiral, conforming to the surface of the bat.

Instead of doing this interactively, you could assign a Simple Deform > Twist modifier to the profile, which does the exact same thing. Set Axis to Z, and  Angle set to 360 * your number of turns. That way you can go back and adjust it later, if you need to.


Does anyone know what happened to my render?

The object used as the focal point for Depth of Field was probably removed in the boolean operation and thus the focus distance was set to 0. Choose a new focal point object or set the distance manually.


What happened to the selection and camera toggle buttons in the Scene Collection Window?

You can turn them on and off at the top under the Filter button where it says "restriction toggles".


Give the images an emission shader set to 1 (I assume you are mapping the images onto planes). This value causes the image to ignore shadows or lights and display its true colors, thus making it shadeless as you wanted.


I just needed to put it on the Z axis, apply then rotate it. Found the answer on this video (at 3:45) while searching for a solution.


Blender is snapping with the "negative Z axis" of the origin point.
Adjust you origin rotation and it will work.

Enable Transform Only Origin option and Face snapping
Snap the origin to a face - it'll inherit it's direction (Z+ axis)
Rotate the origin 180° along local Y axis (so it's Z-)

Snap origin and rotate it 180° along local Y axis