When moving the object along a given axis, the coordinates change along others axes

The coordinates you're reading are referred to the bone's local space: if your bone were exactly aligned to the world coordinates (in edit mode, during the rigging) you would have your translation matching; if, more commonly, the bone is oblique, a translation along one axis is, relative to the bone local space, a movement along more than one axis.
This is the reason why it's common, during rigging, add "extra control" bones aligned to the world coordinates, to act as parents of real control bones, making editing easier, expecially with the graph editor.


Object does not show in render (Cycles) (Blender 2.82)

Alright, I hope I can save someone's time and fix their problem if they ever come across the same issue.
Select the object that doesn't render, go into object properties, scroll down to Instancing, select None and then Render Instancer.
I don't know why it changed the setting by itself, I never clicked on this nor did this ever happen to me before after duplicating part of an object. Whatever


Set 3D cursor position while left-click selection is enabled (2.8)

You have to click on the cursor icon on the left-hand corner


Create loop cut with CtrlR, keep them selected, bevel with CtrlB.


Why is blender's boolean so touchy compared to most cad programs?

The short answer is that Blender is not a CAD program, it is a 3D modeling program, and the two domains have very different goals and constraints.
Boundary representation
CAD programs are designed to create specifications of physical objects. They must be physically accurate, because when a CAD-designed part is actually manufactured, there is no room for cheating. Parts must be machined to high tolerances with exact dimensions and geometry; there is not much room for error when fitting screw threads to a hole. This means CAD tools choose internal representations of geometry that express the shape as directly and accurately as possible.
Specifically, most CAD programs use what’s called boundary representation (B-rep). Boundary representation is a generalization of constructive solid geometry (CSG), which is fundamentally a compositional description of how to obtain a solid volume from operations on simpler primitives. One of the essential concepts behind B-rep is that it is symbolic; a perfectly smooth curve can be described using a mathematical description of a spline, which can be differentiated at arbitrary points.
Mesh representation
In contrast to this, Blender uses a mesh representation of geometry, which is far more discrete. A mesh cannot represent a spline exactly, because a mesh must be composed of some finite number of straight edges. Therefore, a mesh can only approximate a spline using some discretization scheme that provides sufficient resolution from a certain viewing distance.
To compensate for this, computer graphics uses lots of tricks (or “cheats”) to hide discretization errors. One of the most obvious ones is “smooth shading,” which interpolates normals across faces. Smooth shading is a meaningless concept in the context of CAD, because when a part is physically realized, all that matters is the geometry. Faking normals only makes sense when one is generating a 2D projection of a scene, as occurs in 3D rendering.
Of course, the obvious advantage of this approach is speed: the discrete mesh representation is much closer to what graphics hardware can actually usefully consume, so when rendering B-rep on a computer screen, it must first be discretized into a mesh anyway. An advantage of B-rep is that the discretization is performed internally, on the fly, by the CAD program, so it can be performed adaptively at any viewing resolution. No information is ever lost, since the user edits the abstract, symbolic description of the shape they are trying to model, which serves as an “infinite resolution” source of truth for the discretization process.
Boolean operators
What does any of this have to do with Boolean operators? After all, a mesh does still mathematically define a boundary, just one made entirely from straight edges. And that’s true, but there’s an important difference!
Since B-rep is a symbolic representation, Boolean operations are similarly represented internally using a symbolic, mathematical description. Because each operand to the Boolean is an “infinite-resolution” mathematical description of a volume, the result of the Boolean can also be interpreted mathematically with “infinite precision.” Just as discretization of a spline can be adaptively performed at any resolution, discretization of the result of the Boolean can be similarly reevaluated using any technique at any resolution necessary, again with no loss of information.
With a mesh, Boolean operations are destructive, and their operands have already been discretized. You cannot union a sphere with a cube, you can only union an approximation of a sphere with a cube, and what you get back will necessarily be a new, modified mesh. Of course, if you leave the modifier unapplied, the operation will be dynamically recomputed as each mesh changes, similar to the behavior in a CAD program, but once you apply it, the mathematical structure is permanently committed to the mesh.
In a CAD program, there is no way to “apply a Boolean operator” in the sense that you can in Blender. The representation is fundamentally always a non-destructive, mathematical specification of the volume, and the discretization is performed behind the scenes, in real time. This of course means you do not get any direct control over the discretization, but that’s okay for CAD, because you care more about what will happen when the model is interpreted by CNC or a 3D printer, not a graphics card. Even if the same kind of non-manifold mesh you get in Blender is internally generated by your CAD program, you can never directly see or interact with the mesh, so the illusion is never broken. When you modify the parameters of your CAD specification, the Boolean is simply reevaluated on the fly to get a new mesh.
In other words, Blender is using a representation that is fundamentally lower-level than B-rep is. This gives you far more control, and it can be far more performant, but it also means you have to suffer the consequences of destructive modeling and manually manage discretization. In a CAD program, you never care about “bad topology” generated by Boolean operations because “mesh topology” is an implementation detail needed only for visualization, and it doesn’t have to be efficient. In 3D modeling, you do care, and you therefore have to deal with the consequences.


How to add a range of separate images to VSE without merging them in one video strip?

Add images as usual strip and then use Separate Images to make each image as separate strip.

From manual:

  Y Converts the strip into multiple strips, one strip for each frame. Very useful for slide shows and other cases where you want to bring in a set on non-continuous images.

With strip selected press Y (or open Strip > Separate Images) and choose how long (in frames) each resulting strip should be.

Then you can grab resulting strips as desired.


Yes. While in Edit mode, have a look in the 3D View's Properties region (N). There's a panel labelled "Mesh Display", and within it, a section labelled "Overlays". There you have an array of checkboxes to toggle the visibility of various overlays. If you want to disable sharp lines, left-click the Sharp checkbox and you should be good to go.


Executing Python commands in a blender subprocess

Invoke blender with the --help option to get all available options.

In your case you might simply use the --python option to load a script.
Note: The order of the arguments are given in is important.

.\blender.exe Subprocess.blend --python your_script.py

or

subprocess.Popen([blenderPath, , "Subprocess.blend", "--python", "your_script.py"])

This way the blended is loaded first and then the python script is executed.

Blender 2.78 (sub 0)
Usage: blender [args ...] [file] [args ...]

-P or --python
    Run the given Python script file

--python-text
    Run the given Python script text block

--python-expr
    Run the given expression as a Python script

Argument Parsing:
    Arguments must be separated by white space, eg:
    # blender -ba test.blend
    ...will ignore the 'a'
    # blender -b test.blend -f8
    ...will ignore '8' because there is no space between the '-f' and the frame value

Argument Order:
    Arguments are executed in the order they are given. eg:
    # blender --background test.blend --render-frame 1 --render-output '/tmp'
    ...will not render to '/tmp' because '--render-frame 1' renders before the output path is set
    # blender --background --render-output /tmp test.blend --render-frame 1
    ...will not render to '/tmp' because loading the blend-file overwrites the render output that was set
    # blender --background test.blend --render-output /tmp --render-frame 1
    ...works as expected.

By the way, I think you don't need the -r option.

-r
    Silently register blend-file extension, then exit (Windows only)


Export BGE Soft-body Distortions to 3D view?

It does not appear to be possible.  You'd probably have to write a script to export it, but:
"There are no python bindings to control soft bodies, and no logic brick support, except for apply force and add object actuator. " - http://wiki.blender.org/index.php/Dev:Source/GameEngine/BulletSoftBody

(I can't yet reply to your question to clarify.  What are you trying to accomplish?  You have another question about multiple soft bodies colliding, is the problem related? like I said, combining them into one object works, but a drawback is they have to all have the same settings... but with more detail to your problem, there may be a way.)


Snap bone back to an offset relative to another bone

Consider adding another Child Of constraint, but put this one on the hand itself, and for the target, make an empty or bone that has been placed near the hand rest position (and which is also parented to the gun). Keyframe the influence slider for this "hand rest" Child Of constraint so that the slider is in the fully off position when the hand is currently reloading, and then keyframe the same slider so that it is fully on when the hand needs to be at full rest under the gun. The influence slider will interpolate smoothly when keyframed, so the hand will gradually become more and more the child of the empty or bone under the gun as time progresses. If this looks wonky animation-wise, you could leave the influence off until you have keyframed the arm manually returning to the gun, at least until the hand is very near to the gun. Then you could keyframe the Child Of constraint influence slider to be fully on only at that point. You will still get the advantage of knowing for sure that the hand will end up in the final rest position, where it belongs.


It's very easy to animate the growth of the pipes if they were simple curves with a bevel shape. You would then animate the Bevel Factor End value to have the shape grow. This would not give you the ball joints you show in the image. You would have to treat them separately.

Another option would be to create the pipes as mesh objects and then use the Mask Modifier in combination with a Dynamic Paint object to reveal the mesh over time. This would give you more flexibility on the shape of the pipe you want to use.

To do this you would:

Create a pipe mesh object.
Create a mesh object to paint with (like a sphere) and position it at the beginning of the pipe.
Animate the brush object on a path that travels from the beginning of the pipe to the end.
In Physics tab, add Dynamic paint to the pipe object, set it as a Canvas and add new canvas. Set the Surface Type to Weight. You'll see a name appear in red in the Dynamic Paint output Vertex group box. Click the plus sign beside it to activate it as a vertex group for the object.
Add Dynamic paint to the brush object. Choose Brush as the type, add brush.
Play the animation, you should see the weight colour of the pipe change as the brush object travels across it.
You can then add a Mask Modifier to the pipe object and choose the vertex group you created in the DynPaint panel.
You will probably need to add SubDiv mod to the pipe to create more vertices to play with so the reveal transition is smoother.


Strange artefacts when using Decimate modifier

The fix was actually very simple, and I did not need to remove the Decimate modifier. All you need to do is just x> "dissolve vertices" in Edit mode on every point where the issue occurs and it will fix the problem.


How to I change the Interpolation Type in the Map Range node like the documentation says?

Make sure you are on the shader editor. In 2.9.12  the interpolation options are there:


What's a good strategy for texturing large objects?

You should only use as little as possible textures (regarding the number) per object for games. Explanation below.
Textures should always be in a power-of-two square size: 512x512, 1024x1024, 2048x2048...
You should always aim for a texture resolution as high as possible, downscaling can be done within the game engine via quality settings or as a batch process, e.g. with a free software like Irfanview. Upscaling is hardly possible. On the other hand, the higher the resolution, the more human resource goes into the creation process.
Textures should not only include a diffuse channel, but also normal & bump as well as Ambient Occlusion. (Depending on the game engine even light/shadow maps, reflexion maps etc.) Most game engines will utilize the unused Alpha channel of a texture, so your put your diffuse channel into RGB and the bump map into the Alpha channel, for a smaller number of textures.
E.g.:

Diffuse+Bump.png

|_RGB = Diffuse

|_Alpha = Bump

A texture of 2048x2048 for a whole house may work for a game, where the camera is far away, e.g. Anno type games. If you have a first or 3rd-person camera this resolution will be very blurry when getting closer to the house.

If it's not possible to cover a large object like a castle with one texture you can use multiple textures. However this shouldn't change your strategy to use as little textures as possible over using small, recyclable textures for multiple objects.

Use single, per-object textures for the following reasons:

Project organization: Handling textures per object is much easier regarding changes, integration and management of your project
Game engine integration: Depending on the game engine you may have to assing textures manually to each object
Level design & workload: Handling many files is always slower than handling fewer, bigger files. Using multiple-object-textures over different game levels will nullify the advantage of less disc & memory space.

You can also create a free account on Turbosquid.com and look up their "Game Ready" specification, sadly this document seems not to be available ATM without login in:

http://support.turbosquid.com/entries/171903-Game-Ready-Certification-Specification

Here's an overview of texturing in Unreal Engine 4:

https://docs.unrealengine.com/latest/INT/Engine/Content/Types/Textures/index.html

As well as materials in Unreal Engine 4:

https://docs.unrealengine.com/latest/INT/Engine/Rendering/Materials/IntroductionToMaterials/index.html

Pay attention to the image under "Material Expression Nodes and Networks" to get an impression how UE4 handles UV's and textures.


How do I use a cached/baked smoke simulation with command line rendering?

This worked for cloud rendering via command line, as for a local computer or render-farm, I don't know.

Change the cache baking location with the file path " // ". It should auto-name it if it doesn't accept a custom name.

Save the .blend file, bake the simulation and it will appear where you saved the .blend. Therefore blender will "look" in the same folder, a dedicated location.

How do I re-Load Fluid Sim Cache?


The Resolution $X$ and $Y$ settings for the Render Dimensions determine the render size in pixels.
But when you use percentage control, the number of pixels will be reduced if you use a smaller number than 100%.
In this example, a 1920 x 1080 image is rendered at 1%, yielding an image measuring of only 19 x 10 pixels.
Hardly enough pixels to make the sense of the original scene.


Dissolving textures to animate blink - What am I doing wrong? (Face animation with shaders)

Ok so as you're using a MixRGB, you can indeed mix the 2 Image Texture nodes into the MixRGB, then you need to plug the MixRGB into a Diffuse, then the Diffuse into an Output:

MixRGB is used to mix 2 colors and/or images, but you need to tell Blender what kind of shader it is supposed to be, between Diffuse (which will be affected by light and shadows) and Emission (which emits light). In your case I guess you need Diffuse.
Another equal solution would be to use the Mix Shader, in that case you need this setup, as Mix Shader doesn't directly accept images or colors:


How do I rearrange the list of render layers?

Render layer order doesn't actually effect the render (aside from maybe changing the order in which the layers are rendered).

However, for organisational purposes it can be nice to reorder them. For this reason I created a script, available on Github, which adds up and down arrows to reorder the render layers:

https://github.com/RayMairlot/Move-Render-Layers

Note: Untested in the latest version of blender, not guaranteed to work, save before using etc.


Workflow automatization question (macro recorder/command playback)

I use the free command recorder addon for this very thing and it works well.  It has apparently been changed to action recorder and is developed by the same author.  I haven't tried this new version yet though.  You can find details here.
Action recorder


You changed the Time Remapping. It is found in the lower right of the Dimensions section in the Properties Panel.Make sure, the Old and New values are both the same, e. g. 100 and 100.


Bevel will not work correctly on geometry with vertices too close to each other. Either it will overlap awfully if beveling without clamping or as you discovered there won't be any overlaps with Clamp Overlap but bevel effect will be almost invisible.

There are ways to work this around - either retopo the mesh using any of existing ways so far (manually or using any created solutions be it addons or other programs) or build bevel using curves possibilities.

To go with curves first selected vertices of the butterfly profile were duplicated and separated into another object (P > By Selection). Then that object was converted to curve via Alt+C in Object mode. Curve was cleaned in Edit mode afterwards - type of splines was set to Bezier, handles - to Auto so that shape is smoothed by default as much as possible.

Next step was to extrude and bevel the curve object. Easiest way is to set curve type to 2D in curve object settings, Fill option to Both and Extrude to something other than 0, depending on desired depth.

However if beveling intersections appear in the corners where curve handles are too near to each other due to details.

One way to compensate that is to decrease Offset value to the same amount as Bevel was set to, but negative. In this case Bevel was set 0.5 and the Offset to -0.5.

Some extra curve handles in the corners were removed and others were adjusted to get rid of remaining overlaps.


What is the index in the select_linked_pick command?

For the operator bpy.ops.mesh.select_linked_pick(deselect=False, delimit={'SEAM'}, index=1729)  the index is taken from the closest element to the mouse cursor and it is calculated as follows :

For Vertices : index = vertex.index.
For Edges    : index = len(vertices)+ edge.index.
for Faces    :  index = len(vertices)+ len(edges) + face.index


The anwser is YES you can! You can install any software on any of the drive you have. I have my 2nd harddisk on partition. So that means I have my physical harddisk virtually cut up into 3 portion. I have D:,E: and X:. I install all my program on X: and save all my data on E: , as my C: is an SSD with only 120GB of disk space.

As it happens Blender is no exception. In fact blender comes in Zip format flavor which does not even require any conventional installation at all.

Note Change your title to "Installing blender on another drive other than C:" at least it makes the question not sound like an OS one :) cheers.


Problem with Subdivision Surface after Bevel

It looks like you've only applied SubSurf to one set of faces. Try applying the solidify modifier, if you can, then bevel your edges and apply the SubSurf.


If you need all the normals to point upwards it's quite simple.

Create a new plane.
Enable Auto-Smooth on your main object.

Add a Data Transfer Modifier to your main object.
Set the Plane as source Object and check Face Corner Data and enable
Custom Normals. Your object will now copy the normals from the Plane.

If you want different normals to point in different directions you can do the same using Vertex Groups.

Create a new plane and angle it to the direction you want your normals to point. Create a new plane for every direction you need. Name them accordingly.

Create a Vertex group for each direction. Name them accordingly. Assign the vertices  you need to their desired vertex group.

Enable Auto-Smooth
Add a Data Transfer Modifier for each Vertex group. Set the desired Plane as source Object along with its Vertex group. Check Face Corner Data and enable Custom Normals.


Flame attribute for cycles smoke not working

Figured it out!

The problem was that I was changing the Smoke Domain object to Flow Type: Fire + Smoke instead of the emitter object, the UV sphere.


Trouble baking normals from a high poly mesh to low poly mesh using Blender and Substance Painter

I figured out that by selecting "Relative to Bounding Box" in Substance fixed the issue for me. I am kind of mystified why this worked, but it did. If anyone knows why this happens it would be a great help.


You can use the compositor for this.

Normally I add 2 materials to the object. One for the case and one for the screen. The faces for the screen I assign to the screen material.

When the screen material is selected under settings you can set the pass index to 1 (default is 0). With this pass index you can extract the visible parts in the compositor

for the screen make sure that the UV coordinates are correct.
make sure you select "material index" and "UV" in the render passes

In the compositor you can then extract the mask and apply a different texture using the UV Map node

Normally in these cases you can render out to OpenEXR Multilayer, and load the prerendered images directly in the compositor.


How to change order of F-curve's modifiers?

The only way I can find to achieve this (without resorting to scripting) is to use the Copy and Paste facilities to duplicate all the modifiers and then delete the ones that are out of sequence.

Clicking Copy followed immediately by Paste should clone all of your modifiers :

I started with a Noise followed by Generator, clicked Copy then Paste to result in Noise, Generator, Noise, Generator.

Now simply remove the ones that are no longer required - in my example, removing the top Noise and the bottom Generator leaves Genertor followed by Noise - ie, the modifiers have effectively been reversed.


This is occurring since Blender has a system of "Normals" for calculating the outside part and the inside part of the faces. If you Tab into Edit Mode, go to "Shading and UVs", then click on a button that says "Flip Normals". Those dark bits you are seeing will be reversed to the other side.


EEVEE seem not to benefit from multiple GPUs for rendering

Multi GPU support for EEVEE is a really hard goal to atchieve because of the nature of the technology. It is not being worked on at the moment and it is not planned for any time soon. EEVEE might benefit from SLI or Crossfire setups. It would be logical to wait untill it's realeased to test that though. I believe it is safe to assume that EEVEE will definitely not be able to use multiple GPUs that are not connected with SLI/Crossfire for real time rendering when it is released or any time soon after.


Whats the hotkey for changing viewer rotation?

There is a solution to this, but it's a work around.

You can set an empty at the center of your focal target, and parent your camera to it.

To do that select the Camera 1st, then while holding the Shift key select your Empty.

Then on your keyboard Ctrl+P to parent.

To get the turn table effect go into camera view Numpad 0, then select your empty and rotate it about the Z Axis.

Then use middle mouse as your trackball.


Blender 2.8 How do I find out which version and build I am using?

Either go to the Blender menu on the top left and open the Splash Screen entry,

or go to Help > Save System Info, browse your file system and save the file. Upon opening it with any text editor it will reveal your complete system info, including build version.


How can I merge the last elements of an Array that fits a curve?

The first-last merge is being requested before the array is deformed: at that stage the first and last are nowhere near each other..
It may not be ideal for you, but in this case you could do the rotation in the array, by using an object-offset, target: say an empty, rotated by (360/sides) in Z. Then the merge works.

This example has a bevel-by-angle modifier after the array.
Edit: Since this answer, the Weld modifier has become available, and can be used to stitch vertices together in this, and other situations.


Beveling with a bad topology of an imported model ?

You don't only have edges crossing your external faces, you also have several inner faces that should not be here, so maybe if you delete them it will fix your problem.


Do Custom normals work in Animation Nodes?

You can get access to loops normals using the following expression:

[loop.normal for loop in [obj.data.calc_normals_split(), obj][1].data.loops]

Which calculates the split normals data and returns the normals. To set vertex normals to a mesh, you can use the setVertexNormals method, which take a single vector list representing the normals.


About your second problem, I could not reproduce it with the file you’ve shared, but maybe apply the scale (even though it should not scale the child when you parent)?
About your flap :
First thing, you were animating the rotation of the empty, but as it is not aligned with the global orientation anymore you may have bad rotation results : Rotations, once keyframed, do not consider the object’s own local orientation but the global orientation. So when you are supposed to animate an object that is not aligned with the global axis, the solution, before desaligning the object from the world orientation, is to parent it to an empty (or any other object), then orientate the empty the way you want in your scene, then animate the object, not the empty. As the object is parented to an empty, its new global orientation is not the world anymore, it is the parent local space, so any keyframed rotation will happen on the parent's local axis, if the parent is orientated the way you want in the 3D scene, the child object will rotate the way you want relatively to the world space.
This is also why your Limit Rotation constraint on local space didn’t work: Local Space will consider the object’s parent local space, but the empty has no parent, so the constraint won’t affect it. You need to give the constraint to the flap.
So, to fix the problem:

In Edit mode align the flap with the global orientation, and put its origin on its axis position:

Parent it to an empty:

Move and rotate the empty until it fits to the wing:

Give a Limit Rotation/Local Space to the flap (not to the empty):

Open the N panel, animate the flap on the X axis:


what triggers extend non manifold errors?

Selecting Non-Manifold parts of your mesh, will select vertices or edges that are not part of a solid shape.

The extend option will add the chosen verts/edges to the current selection. As you have selected all before doing the search, this will just keep everything selected while turning it off will select only non-manifold edges, which could mean no selection.


Summary still there in animation dope sheet

I don't believe it can be cleared. But it's of no consequence. The Summary is simply an expandable section which gives you a general, at-a-glance view of your keyframe data. It really has no purpose until you have keyframes. So maybe it shouldn't appear until you do. But it's always there regardless. In any case, once you have keyframes, they can all be collapsed under the Summary section. It seems to only exist in the Dope Sheet and the Timeline. If you're seeing it in the Dope Sheet, the top row of keyframes comes from the Summary section. It is very useful, because it lets you move every keyframe from a certain time location at once, irrespective of whatever channel any of those keyframes are actually found.


Transfer a Rig from Motionbuilder to Blender

Re target copy rig with new rest pose.

Similarly to this answer,

Select rig, and run the following script (takes a minute-ish).  You will get a new copy rig, with rest pose the same as the T-pose in frame 1 of original, and animation adjusted to fit new rest pose.

import bpy
from bpy import context

remove_constraints = True
scene = context.scene
scene.frame_set(1) # TPOSE frame
rig1 = context.object
# copy the rig and armature
rig2 = rig1.copy()
rig2.data = rig2.data.copy()
scene.objects.link(rig2)
scene.objects.active = rig2
bpy.ops.object.mode_set(mode='POSE')
# apply the pose in frame 1
bpy.ops.pose.armature_apply()
if not rig2.animation_data:
    rig2.animation_data_create()
# remove animation from dupe
rig2.animation_data.action = None
# add copy transform constraint to each bone
for pb in rig2.pose.bones:
    ct = pb.constraints.get(pb.name)
    if ct is not None:
        ct.influence = 1
        continue
    ct = pb.constraints.new('COPY_TRANSFORMS')
    ct.name = pb.name
    ct.target = rig1
    ct.subtarget = pb.name

action = rig1.animation_data.action
f = action.frame_range.x
# add a keyframe to each frame of new rig
while f < action.frame_range.y:
    scene.frame_set(f)
    for pb in rig2.pose.bones:
        #pb2 = rig1.pose.bones.get(pb.name)
        m = rig2.convert_space(pb, pb.matrix, to_space='LOCAL')
        if pb.rotation_mode == 'QUATERNION':
            pb.rotation_quaternion = m.to_quaternion()
            pb.keyframe_insert("rotation_quaternion", frame=f)
        else:

        # add rot mode checking
            pb.rotation_euler = m.to_euler(pb.rotation_mode)
            pb.keyframe_insert("rotation_euler", frame=f)
        pb.location = m.to_translation()

        pb.keyframe_insert("location", frame=f)
    f += 1

# set constraints to zero or remove entirely.
for pb in rig2.pose.bones:
    ct = pb.constraints.get(pb.name)
    if ct is not None:
        if remove_constraints:
            pb.constraints.remove(ct)
        else:
            ct.influence = 0


How can I offset the start of a fluid simulation

You should use the offset field in the domain's settings:

What you would normally want is a negative offset. For example, if the camera switches at frame #240 (10 seconds at 24fps), the offset should be -240. Blender will skip the first 240 frames. It only starts doing the simulation at frame 240.

Here is an example of an offset at frame 350 (60fps):

Frame #349:

Frame #350


How to mathematically round positions of all vertices to nearest integer?

Use the following script:

import bpy

obj = bpy.context.scene.objects.active

for vert in obj.data.vertices:
    vert.co.x = round(vert.co.x)
    vert.co.y = round(vert.co.y)
    vert.co.z = round(vert.co.z)

Let me know if you run into any problems :-)


Joining additional objects breaks armature

I had several problems.

There were multiple stray & empty Containers, which I examined and deleted.

The object hierarchy was incorrectly nested.

I may have been selecting objects to join in the incorrect order.

While none of the other Stack Exchange-suggested questions were exact duplicates they did help me to think about this correctly and solve my problem.


Turn on "clipping" in the mirror modifier stack. Adjust the threshold or go into edit mode and select the mesh, move it until the centre vertices snaps in place.


The preview render its not the same as the final render

Delete Hidden Lights Because Blender renders even unchecked  lights


How to texture a complex mesh/multiple meshes?

There are a number of ways to approach this problem. To begin with, you can choose to use materials for everything (totally viable), to use textures for everything (also totally viable), but I think the best option is to use a mixture of both.

Often, the best approach is to use materials for anything that can all be the same, and use textures for anything that needs to be placed carefully (like a label or logo).

In your case, I'd recommend that you join all the parts that will be the same material into the same object (like all the individual components that make up the slide, for example). All of those meshes don't have to necessarily be connected to each other, they'll just be in the same object. Then you can give the object one material that looks like anodized steel (or whatever). I suspect you'll have an object for the slide, another for the grip and lower receiver, another for the magazine butt, another for the magazine itself, another for the extractor, another for each of the controls (safe selector, magazine release, slide lock/release), and a few others. Note that meshes can be in the same object even if they're not close to each other. For example, the magazine release and the safety might be in the same object, if they're supposed to be the same material. That way you can set up the material for both at the same time.

Once you've done that, determine if there are any parts that should be textures. If you're going to be adding the manufacturer's mark, that's probably a good candidate. You also might find it easier to make the nerling on the grip as a normal map than try to model it.

Those are some basic ideas that will get you a little closer, but beyond that we're getting into making a tutorial, which is outside the scope of this website ;-) I wish you the best of luck, and do remember to check back here when you have specific, answerable questions. Happy Blending!


How to simulate a dented surface for metal

First of all you should mime the glossiness of the two helmets. By examining the spreading of light near the highlites you can notice how the object on the right has sharper reflections.

Build a simple material based on a glossy shader with low roughness lit by a nice HDRI iage.

In order to get make the object less smooth we should deform its surfaces. This can be done "physically" by sculpting ridge and vallys or "faked" by altering the normal vector of the faces for example by plugging a noise texture with appropriate scale in a bump node and then in the normal socket of the shader (or wih the displace method as you already introduced).

Each face reflects light toward the camera based on its orientation. If you bend the face's normals, they will start to reflect light the way it would look if the surface was truly deformed. By examining the edges, a viewerwill probably be able to discover the trick, but at a first glance should look good enough amd will help to kee your polycount low.

A second thing to notice is that the object on the right has some little scratches that yours is missing. One of the possible way to reproduce a similar effect could be to use a texture to drive the roughness of the smooth shader.

You could have used the displace/normal method also in this case: they are some kind of surface deformations too, but as the effects has a very small scale I find taking advantage of roughness variation more appropriate.

Final step is to balance the two effect in order to get the wanted result.


Is there any way to add backgrounds in Blender 2.8?

It can be found in the camera's properties, but the behavior is still not correct.


I'm new myself but have you tried:

Is the correct image selected on the left side. At the top of the page you can select what image to display (next to the buttons for view, brush, image).
Do you have rendered view selected on the right and Blender has to render everytime you change something?

Again I'm new myself but this is what I thought of.


Video clip only imports first image in sequence

The answer to my question in case anyone else runs across this problem, was the sort order of the images

Image 1 shows I clicked on the display icon
Then I changed the display mode from sort by date to name of the images.
Not sure why date order did not work, but because it was in the wrong sequence only one image was imported.

In image 2 you can see all 81 frames (1/81) were imported. Compared to my original post where it showed only 1/1 frames


Combining Curve modifier with Follow Path constraint

Ah! Displace modifier before the Curve modifier with the same axis:


How to control the timing of Absolute Shape Keys?

Controlling the timing of absolute shape keys

You can add keyframes for the "Evaluation Time". The easiest way in the UI is to hover over the Evaluation Time slider and press "i". This will map your defined shape keys to particular frames in your animation.

Attempted answers to your other questions

The "frame" for absolute keys does seem to be separate from the usual meaning of "frame" in Blender and not related to keyframes. Not sure why it increments by 10 or why it's not editable, but it ends up not mattering much because of the fact that you can set the eval time and make keyframes for it.
Resetting timing seems to be an organizational tool. If you delete one of the shape keys, you'll have a gap of 20 in the eval time from one to the next, and resetting lets you get back to a list that increments by 10. If there's a deeper reason, I don't know it.
As far as I can tell, the best way to loop is, as you suggest, duplicating the basis keyframe for the final keyframe. I tried setting a final keyframe with evaluation time set to zero, and the result was my object rapidly undoing all of its shape changes, one at a time, on its way back to the basis shape key. To connect the loop after making a keyframe for your final shape key, I'd try making one more keyframe for your basis shape key in the very next frame to stop the intermediate values of eval time from getting animated. (If you want to avoid the doubling of a frame, you could also set eval time to a fractional value corresponding to what the shape of the object would be at that frame if it were continuously morphing.)


World map as displacement map on a sphere distorted

I would use a different approach.

Rather than using a displacement texture, I would use a material and use your image a bump map

Since the sphere doesn't have a UV map, using the Generated output of a Texture Coordinate as the Vector input of the Image Texture will position the map.

The Image Texture file is your image.

Because you are using the Image Texture for a bump map, the first drop down should be set to Non-Color Data.

Because you are projecting to a sphere, the 3rd drop down should be set to Sphere.

The Image Texture Color output is then used as the Height input to a Vector Bump node.  You can control the height of your terrain by setting the Strength value of the Bump node.

The Diffuse node can be replaced by a Principled node, and the other image maps fed to its inputs, as in the tutorial.

There is an alternative way, using the Displacement input of the Material node, rather than the Normal input of the Diffuse BSDF, but it varies depending on the version of Blender you are using.


Select all faces and assign them to the same material. It is likely that your two objects had different materials on them, and that you added the texture paint slot to your first object's material. Now that all the geometry is in the same object, what previously was the second object is still using its material, which didn't get the texture.


Add Custom Menu at Specific Location in the Header

There is probably a more elegant way

Actually there is not. We can only append and prepend. If every stock entry was a draw callback in draw._draw_funcs, it would be possible to insert inbetween. Until then, there are only two hacks, which I wouldn't recommend for everyday use (rather stick to
iKlsR's solution):

Wrapping all UILayout calls - wiki link
Injecting modified layout code the hard way - included in addon code

Note that 1. works for a single addon only at a time, and 2. only works as long as there's just one addon replacing the code object of a certain bpy type.

Content from Blender wiki, by ideasman42:

This page shows how to intercept every draw call in blenders python ui which can be used for some UI tricks.

First heres an example of how to do just that.

Tested to work with Blender 2.70

Intercept UI draw/poll

This is a simple example of how to intercept poll and draw functions, without making any behavioral changes.

classes = ["Panel", "Menu", "Header"]

def draw_override(func_orig, self_real, context):
    print("override draw:", self_real)

    ret = func_orig(self_real, context)
    return ret

def poll_override(func_orig, cls, context):
    print("override poll:", func_orig.__self__)

    ret = func_orig(context)

    return ret

import bpy

for cls_name in classes:
    cls = getattr(bpy.types, cls_name)

    for subcls in cls.__subclasses__():
        if "draw" in subcls.__dict__:  # dont want to get parents draw()

            def replace_draw():
                # function also serves to hold draw_orig in a local namespace
                draw_orig = subcls.draw
                def draw(self, context):
                    return draw_override(draw_orig, self, context)
                subcls.draw = draw

            replace_draw()

        if "poll" in subcls.__dict__:  # dont want to get parents poll()
            def replace_poll():
                # function also serves to hold poll_orig in a local namespace
                poll_orig = subcls.poll
                def poll(cls, context):
                    return poll_override(poll_orig, cls, context)
                subcls.poll = classmethod(poll)

            replace_poll()

Override layout & functions

This is the extended from the above code but extended to subclass the layout type used within draw().

In this example operators and properties are filtered out based on their names, but all sorts of things are possible with this - modifying args to functions, changing text etc.

classes = ["Panel", "Menu", "Header"]

import bpy

UILayout = bpy.types.UILayout

op_blacklist = [
    "render.render",
    "object.modifier_add",
    "object.forcefield_toggle",
    ]

prop_blacklist = [
    "Object.location",
    "Object.scale",
    "Object.rotation_euler",
    "RenderSettings.display_mode",
    ]

def filter_operator(op_id):
    if op_id in op_blacklist:
        return False
    return True

def filter_prop(data, prop):
    prop_id = "%s.%s" % (data.__class__.__name__, prop)
    if prop_id in prop_blacklist:
        return False
    return True

class OperatorProperties_FAKE:
    pass

class UILayout_FAKE(bpy.types.UILayout):
    __slots__ = ()

    def __getattribute__(self, attr):
        # ensure we always pass down UILayout_FAKE instances
        if attr in ("row", "split", "column", "box", "column_flow"):
            real_func = UILayout.__getattribute__(self, attr)

            def dummy_func(*args, **kw):
                print("    wrapped", attr)
                ret = real_func(*args, **kw)
                return UILayout_FAKE(ret)
            return dummy_func

        elif attr in ("operator", "operator_menu_enum", "operator_enum"):
            real_func = UILayout.__getattribute__(self, attr)

            def dummy_func(*args, **kw):
                print("    wrapped", attr)
                if filter_operator(args[0]):
                    ret = real_func(*args, **kw)
                else:
                    # UILayout.__getattribute__(self, "label")()
                    # may need to be set
                    ret = OperatorProperties_FAKE()
                return ret
            return dummy_func
        elif attr in ("prop", "prop_enum"):
            real_func = UILayout.__getattribute__(self, attr)

            def dummy_func(*args, **kw):
                print("    wrapped", attr)
                if filter_prop(args[0], args[1]):
                    ret = real_func(*args, **kw)
                else:
                    ret = None
                return ret
            return dummy_func
        else:
            return UILayout.__getattribute__(self, attr)

        print(self, attr)

    def operator(*args, **kw):
        print("OP")
        return super().operator(*args, **kw)

def draw_override(func_orig, self_real, context):
    if 1:
        class Wrapper(self_real.__class__):
            def __getattribute__(self, attr):
                if attr == "layout":
                    ret = self_real.layout
                    return UILayout_FAKE(ret)
                else:
                    return super().__getattr__(self, attr)

            @property
            def layout(self):
                ret = self_real.layout
                print("wrapped")
                return ret
        print(1)
        self_wrap = Wrapper(self_real)
        ret = func_orig(self_wrap, context)
    else:
        # simple, no wrapping
        ret = func_orig(self_wrap, context)

    return ret

def poll_override(func_orig, context):

    ret = func_orig(context)

    return ret

for cls_name in classes:
    cls = getattr(bpy.types, cls_name)

    for subcls in cls.__subclasses__():
        if "draw" in subcls.__dict__:  # dont want to get parents draw()

            def replace_draw():
                # function also serves to hold draw_old in a local namespace
                draw_orig = subcls.draw

                def draw(self, context):
                    return draw_override(draw_orig, self, context)
                subcls.draw = draw

            replace_draw()

        if "poll" in subcls.__dict__:  # dont want to get parents poll()
            def replace_poll():
                # function also serves to hold draw_old in a local namespace
                poll_orig = subcls.poll

                def poll(context):
                    return poll_override(poll_orig, context)
                subcls.poll = classmethod(poll)

            replace_poll()

Relevant code from my experimental addon to inject an own menu after the Templates menu below.

It essentially determines the path of the file which defines the original layout getattr(bpy.types, "TEXT_HT_header").draw.__code__.co_filename, looks for a hard-coded piece of code row.menu("TEXT_MT_templates") starting from …draw.__code__.co_firstlineno - 1, gets hold of the draw function code and inserts its own piece of code which adds the custom menu (it has to adjust the indention to be valid).

Then it executes the new code (string) in isolation exec("".join(lines), {}, l) with locals backed by an initially empty object l = {}. The compiled draw function can then be accessed by l['draw'] and the original draw function can be substituted: getattr(bpy.types, "TEXT_HT_header").draw = l['draw'].

A reference to the original draw function should be stored so that it can be restored if necessary.

class DrawFuncStore:
    bpy_type = "TEXT_HT_header"
    bpy_type_class = getattr(bpy.types, bpy_type)
    draw = None

def insert_menu():
    insert_after = 'row.menu("TEXT_MT_templates")'
    insert_code  = '        row.menu("TEXT_MT_snippets")\n' \
                   '        from bpy.app.translations import pgettext_iface as iface_\n' # meh...
    DrawFuncStore.draw = DrawFuncStore.bpy_type_class.draw
    #module = bpy_type_class.__module__

    filepath = DrawFuncStore.bpy_type_class.draw.__code__.co_filename
    if filepath == "<string>":
        return
    try:
        file = open(filepath, "r")
        lines = file.readlines()
    except:
        append_menu()
        return

    line_start = DrawFuncStore.bpy_type_class.draw.__code__.co_firstlineno - 1

    for i in range(line_start, len(lines)):
        line = lines[i]
        if not line[0].isspace() and line.lstrip()[0] not in ("#", "\n", "\r"):
            break

    line_end = i

    # Unindent draw func by one level, since it won't sit inside a class
    lines = [l[4:] for l in lines[line_start:line_end]]

    for i, line in enumerate(lines, 1):
        if insert_after in line:
            #print("FOUND INSERT LINE")
            lines.insert(i, insert_code)
            break
    else:
        append_menu()
        return

    # Debug output
    #f = open("D:\\s.txt", "w").writelines(lines)

    l = {}
    exec("".join(lines), {}, l)
    #print(l)

    #bpy_type_class.draw.__code__ = code_object # Doesn't work, since a single func is not a module

    DrawFuncStore.bpy_type_class.draw = l['draw'] # exec defined our custom draw() func!

def append_menu():
    bpy.types.TEXT_MT_templates.prepend(draw_item)

def remove_menu():
    if DrawFuncStore.draw is not None:
        DrawFuncStore.bpy_type_class.draw = DrawFuncStore.draw
        DrawFuncStore.draw = None

    else:
        bpy.types.TEXT_MT_templates.remove(draw_item)


How do I copy selected faces on a rigged character to a new file?

Go into Edit mode, select the faces you want to separate
Duplicate the faces, separate them into new object with P
In Object mode select object with the separated faces. Rename it accordingly
Save your file
In a new file execute Append from file, choose the renamed object from the file you saved before


Unexplained and unintentional mirroring behaviour of vertices with various actions

Thanks for the nudge in the right direction. After much searching I found that X Mirror had been enabled in the options tab. Hope this goof can help others. TOM


Blender gpu renders turn completely gray

So I have an AMD Radeon HD 7800 series video card. It worked wonderfully for rendering gpu in Blender up  until 2.78 came out. Once 2.78 came out, I lost complete ability to render with GPU up until 2.78b. It kept giving me errors when I would try to render it. Once 2.78b came, the errors stopped, but I had the same gray render that you have. I decided to boost the light significantly, and try rendering again. It works, you can now see the object with the boosted light. You'll have to boost your lighting to use current version GPU for AMD, and it'll have significantly more noise. It will also be way over exposed if you render this same scene with cpu with the boosted light settings. I hope they fix it soon.


How can I access displacement modifier z coordinates in the shader editor?

Your modifier displaces the geometry by +/- 1000 units (I suggest setting the midlevel back to 0.5 by the way), but your color ramp only effectively differentiates colors in your geometry between 0 and 1 units.
You could also set the midlevel to 0, and set your plane origin to geometry so that the displacement only raises the geometry.
I'm saying that because you should use the "Object" output which Z coordinate will be negative if it is located under the object origin. That way you can deal with this information only by dividing the Z coordinate by the strength of your modifier. That will give you the full range of height of your mesh, normalized between 0 and 1, perfect for a color ramp.
In short : Use the object output, but move the origin of the object lower (or raise your geometry in edit mode) and plug a math node set to divide by [the same strength as your displace modifier] between the separate XYZ and the color ramp node.


Scale with S then press X and then 0. This will bring all of your vertices into the middle and all aligned. This works with all axis: X, Y, Z.


Only render particles on silhouette of model

Cycles Render with Particles

In the above image are numerous undesirable issues.  Some might disappear with a little thought.  Convex sphere works easily.  Concave Box with visible inside and outside is more difficult. The simple cube can have difficult glancing angles.  Surface Normal testing is not enough in the general case.  Material Nodes.

Alternatives

Compositing.  Alpha Over Node. Transparent Background. Optional Render with Emission BSDF glowing particles. Composite Blur Node - Gaussian. Blurr bright glow colors. Dilate Node to increase blur size.  Multiple layers composited if particles are used in final composition. Object ID or Material ID can be use to select desired pixels in the compositor.  Stylized Blur.
Freestyle and Compositing.

Volume Shading with Emission

Below image.  Quickly contrived Volume Shading.  Meshes that Shrink/Fatten in a visually acceptable manner make this possible. Convex, Sphere, Torus Meshes.


Why are my low poly objects being rendered smooth?

It looks like it's because you have a  multiresolution modifier applied to your objects. If you remove the modifier or turn "render" in the modifier options to 0, your scene should render the same as it looks in the preview.


Making a light source invisible to everything except shadow rays

There are two ways to do this.

Materials nodes:

Ray visibility:

Using these ray visibility checkboxes instead of nodes will speed up render times a little, however you lose the flexibility of nodes.


It looks to me like there are vertices in your mesh that are not attached.  See the video below.

Double check all of the vertices around your twisted area and merge those that aren't connected by press Alt+M on the keyboard.


There is no poll function for Properties.

HOWEVER:
You can skip the property in the layout or (even better) block the layout (layout.enable=False) so it can be seen but not used.
You can also fake the behaviour within the update-funktion, but you'll need a second property.
Finally you can define getter, and setter functions for your property.

BLOCK THE LAYOUT:

row = layout.row()
row.enable = False
row.prop(self, 'MyBool') #this will appear grayed out

GETTER & SETTER:

def get_MyBool(self, context):
    return self.MyBool_internal
def set_MyBool(self, context, value):
    if not self.dont_touch_MyBool:
        self.MyBool_internal = value
MyBool_internal = bpy.props.BoolProperty() # This is where its actually stored
MyBool = bpy.props.BoolProperty( # This is for your user-interface
         name='MyBool', get=get_MyBool, set=set_MyBool)

ABUSING THE UPDATE-FUNCTION: (Documentary only. Avoid if possible.)

def update_MyBool(self, context):
    if self.dont_touch_MyBool: # condition to check if changing mybool is allowed
        self.MyBool = self.MyBool_Backup
    else:
        self.MyBool_Backup = self.MyBool
MyBool = bpy.props.BoolProperty(name='MyBool', update=update_MyBool)

You can read more about bpy.props here

BLOCKING CERTAIN INPUT:

Let's say you'd like to define an integer that may NOT accept multiples of 2 or 3.

# this will only be called if a valid entry is made
def upd_MyInt(self, context):
    print('Entry accepted')
# This is where its actually stored
MyInt_Internal = bpy.props.IntProperty()

# This is for your user-interface
def get_MyInt(self, context):
    return self.MyInt_internal
def set_MyInt(self, context, value):
    if value%2 and value%3:
        self.MyInt_internal = value
MyInt = bpy.props.IntProperty(get=get_MyInt, set=set_MyInt)


There was some good input from Nathan Vegdahl on this exact subject in the bf-animsys mailing list last year. This is all subjective, of course, but it makes it easiest for animators if the axes throughout your rig are consistent first and foremost. This is a copy/paste from his email(s) to the list:

  The main rules-of-thumb that I try to follow are:
  - The x-axis should be the "primary" axis of rotation for any given control.
  - Rotation in the "primary" direction on the x-axis should result in a
  positive rotation angle (meaning that if it were euler, the x component of
  the rotation would be positive).
  - For bones that are free-floating and/or don't have any particular
  relationship to other controls (the root control is a good example), align
  all of their axes with the world axes.

  In the first two rules, "primary" is often subjective or ambiguous,
  depending on the control, so you just have to use your best judgement and
  experiment what it feels like to use it as an animator.

  It's important also to note the reason for doing any of this at all.  In
  all 3d animation software, keeping bones aligned well helps keep the rig
  better organized for the rigger.  It's also important for animators when
  e.g. working in the f-curved editor.  But in Blender it's particularly
  important for animators, because one of the major interaction models for
  tranforms is via hotkeys, using the x, y, and z keys to specify axes.

  Oh, I should also say: the choice of x vs z axis as the "primary" rotation
  axis is arbitrary.  I choose x because it's the first letter in "xyz".  But
  z is just as good.  What matters is consistency within the rig (or within
  the project if it's a larger project).

I generally follow Nathan's conventions when I rig in blender, although the same principles follow in any software I use. Again, this is all subjective, so your mileage may vary and you might find a better convention for your particular rig. It is also important to take into account your rotation orders on your controls. XYZ might be better suited for a primary axis of Z+ in your rig, whereas an order of YZX might be better suited with X+ as primary axis.

bf-animsys January 2014


Subdivision surface causes problems on connected edges (bridged edge loops)

From what i know about 3D printing, you design the object without the support and filling, no connecting of inner and outer edge-loops either, the result you got there is to be expected, subdivision does not work without artifacts if you do that.

Rather you build and design the object first as it is supposed to look, export it to the slicer software and in there you should be able to set up filling and support.

Also, thickness in the bottom should be achieved by giving the object thickness, like we usually model a vase or glass, inner and outer wall connected through the lip at the opening and the inner bottom more distant from the outer bottom, thus giving it volume.

But regarding modelling with subdivision surface modifiers, i can tell you that the problems you got there, are normal considering what you connected, as you are not supposed to use it that way.

Solution: Model normal without anything other then the model in mind, then export and add those support or filled areas in the software to prepare for the 3D print.

Regarding the infill, as i checked up now and even downloaded a slicer software just to be sure, the 3D object from Blender or any other 3D software does not need to concern itself with that. That does not mean that thin parts of the object can be filled, so giving the object a certain "hollow" thickness for the slicer software to fill is still recommended.

Here a picture of the infill options of "Slic3r" a free software:

So i would believe that most slicer software offers this as well.

I'd like to add this link as well 3D Slicer Settings, as it explains under "4. Fill Density" what i mentioned.


How to modify width of "wire" material type

Apart the Z offset setting shown in another answer, there are at least other 2 ways to render that wireframe: freestyle and wireframe modifier.

The first draws stylized lines over the resulting object after all rendering finish. You can customize the lines styles and where to apply them, like:

The second method can be used with two copies of the object: one gets the usual colored material, the other has the wireframe modifier, and gets another material just for the wire mesh to display, and you have some degree of editing for  the wireframe "style"

here you see how the wireframe is really a separate object, I scaled it up a bit...


This is a subdivided icosphere, generated from a basic icosphere via a subdivision surface modifier.

Of course the blender logo was then carved out of it via a boolean modifier.


Try this:

Go into Edit mode and hit P (Separate) > By Loose Parts. This will separate the pieces of your object.
Pick one of the objects, for example the first one. Add 3 Boolean modifiers to it.
Switch the Operation to Union on all the modifiers.
Set each modifier's Object to be one of the other pieces.
If you get strange results in wireframe mode, switch the Solvers to Carve instead of BMesh.
Hit Apply on each modifier, and  delete the other pieces. You don't need them anymore.

Note that this may destroy your topology. It will keep the shape, but the arrangement of faces may be different.


Is it possible to set which material output node is used?

I bet there's no way as simple as Greg's addon, currently. If you still chasing for another possible answer, try using Add Shader, hit M to mute one to show another. (Select them both then hit M will do a quicker switch)

Personally, I would recommend Greg's addon. Whatever, if this is what you want.


There may be couple of things to check on.

You should apply the screw modifier as non applied modifier don't take effect in some simulations.

The inflow velocity dons't match the orientation of your obstacle,In your case it would be -0.5 in Y and -0.1 in X for instance.


How to display properties when selected from enum

Include an if-then statement in your draw function, like this:

import bpy
from bpy.props import IntProperty, FloatProperty, EnumProperty

def initSceneProperties(scn):
    bpy.types.Scene.MyInt = IntProperty(
        name = "Integer",
        description = "Enter an integer")
    scn['MyInt'] = 17

    bpy.types.Scene.MyFloat = FloatProperty(
        name = "Float",
        description = "Enter a float",
        default = 33.33,
        min = -100,
        max = 100)

    bpy.types.Scene.MyEnum = EnumProperty(
        items = [('Eine', 'Flash', 'One'),
                 ('Zwei', 'Fountain', 'Two'),
                 ('Drei', 'Split', 'Three')],
        name = "Manuevers")
    scn['MyEnum'] = 2

    bpy.types.Scene.FlashDistance = FloatProperty(
        name="Flash Distance",
        min=1.0,
        default=1.0)

    return

initSceneProperties(bpy.context.scene)

#
#    Menu in UI region
#

class UIPanel(bpy.types.Panel):
    bl_label = "Property panel"
    bl_space_type = "VIEW_3D"
    bl_region_type = "UI"

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

        layout.prop(scn, 'MyInt', icon='BLENDER', toggle=True)
        layout.prop(scn, 'MyFloat')

        layout.prop(scn, 'MyEnum')
        row = layout.row()
        row.enabled = False

        if scn.MyEnum == "Eine":
            layout.prop(scn, 'FlashDistance')

        layout.operator("idname_must.be_all_lowercase_and_contain_one_dot")

#
#    The button prints the values of the properites in the console.
#

class OBJECT_OT_PrintPropsButton(bpy.types.Operator):
    bl_idname = "idname_must.be_all_lowercase_and_contain_one_dot"
    bl_label = "Print props"

    def execute(self, context):
        scn = context.scene

        printProp("Int:    ", 'MyInt', scn)
        printProp("Float:  ", 'MyFloat', scn)
        printProp("Enum:   ", 'MyEnum', scn)

        return{'FINISHED'}

def printProp(label, key, scn):
    try:
        val = scn[key]
    except:
        val = 'Undefined'
    print("%s %s" % (key, val))

bpy.utils.register_module(__name__)


Why there is no light coming inside from the window

Besides the glass issue pointed out by @Timaroberts your model has lots of problems The most important one is that Materials created in blender internal will not work on cycles, you need to create new materials using cycles shaders.

Then: Unconnected nodes have no effect.

Never connect nodes on a redundant loop (see the red line?)

Then you have a big box with a solidify modifier surrounding all of the "room", so that even if your materials were correctly set, that box would not let light through the glass anyway...

Fix all of that before you can have volumetrics... to set it up read this post:

Atmospheric lighting in cycles


Deforming a mesh in realtime (Game Engine)

Firstly you'll need to use the bge module, bpy data access wont work since the game engine stores its own data.

For this you will need to use KX_MeshProxy, In the link there is an example for changing a meshes vertex color, but from the API docs you can see how you could change location.

eg:
    from bge import logic

cont = logic.getCurrentController()
object = cont.owner

for mesh in object.meshes:
   for m_index in range(len(mesh.materials)):
      for v_index in range(mesh.getVertexArrayLength(m_index)):
         vertex = mesh.getVertex(m_index, v_index)
         vertex.XYZ = 1, 2, 3 * v_index

Note

that this isnt really optimal from Python, for a high poly mesh the Python script may slow down execution a lot, if the motion isnt so fast you could move N verts per script execution, so at least you dont get jerky playback which would happen if you simply execute the script less often.
You may want to look into GLSL vertex shaders, this is quite invovled but has the advantage that moving vertices about is offloaded onto the graphics card.


There's a weird setup which can make it work. We stumbled across that by accident here in the studio and initially wanted to report it as a bug, but it came in useful at times.
How the weirdo thing has to be set up
The thing is that when you put a plane between the camera, assign a transparent shader to it, and enable the Shadow Catcher option at the same time, any ray that passes through that plane seems to be altered somehow, resulting in the stuff behind the plane to be treated as a shadow catcher object. In this screenshot, I have put a small rectangle in front of the camera. Where it covers the scene behind it, objects become shadow catchers, in all other areas they remain unchanged:

The shader on the plane is really simple:

You can mix it with a diffuse shader if you want. The Mix Factor will then act as a strength slider. This way you can control the strength of the shadows!
Now, put that plane on the render layer where you need the override. Scale it so it covers the entire camera view area. If you have animated the camera, also parent the plane to the camera:

You can set the Max Display mode of the plane to Wire, so you can see through while working in the viewport.
This is how that layer looks rendered:

And here is that very .blend file to play with:


Why won't the rendered image be my current active camera view?

You might have a different camera, or object set as active camera.
To find the active camera go to the scene tab in the properties window. The active camera can be selected there.

Or you can set the active camera (or object as camera) in the 3D viewport.
Select a camera (or object) and make it an Active Camera

The shortcut is Ctrl+Numpad 0


Imported images no longer reflect on glass or glossy shader

I figured it out. For some reason the material was set to a mix shader. So the image was showing up in the view port, but not when rendered. I disconnected the mix shader and just made it a diffuse shader with the image.


importing (appending) materials from File

The downloaded files from that old site do not appear to be blend files, which is why appending does not work.

While there have been a few different material library addons, there are two options that are currently working (and included) with 2.80. The first addon is listed as Material Library and was previously called "matlib vx", the other is a new addon called BlenderKit which provides a much wider library of resources that includes models, scenes and brushes.


Using Cycles, you can obtain this on a curve:

The material node setup is the following:

1- From texture coordinate input node use UV

2- Separate the UV coordinates

3- Keep the 'U' (= X) coordinate and set it as input in a color ramp (add the wanted colors to it)

4/5- Set the result in your shader

Finally, go to the curve properties and set the texture space to use 'UV for mapping'. 'U' (=X) is along the curve and 'V' (=Y) is transversal to the curve.


Make animated particle object start animation from the beginning when emitted?

I'm sorry to say that this feature, which was started on in 2011, was "nearly complete" in 2013 yet still seems like a distant dream. Some of the changes necessary for these updates were dependent on the dependency graph update, though. The depsgraph branch has had a lot of progress lately. Perhaps reading about dependencies will explain why things like this don't presently work out of the box; e.g. why you still can't "animate everything" as the 2.5 project advertised.

The latest update I can find in the same vein is that Lukas wrote a patch that allows you to use a particle's age to update a shader.

The best thing you can do to participate right now with in-progress projects like this is to get in contact with the specific developers that are working on the relevant infrastructures, and show them the problem you're trying to solve. Let them know you're interested, try their test branches, test out experimental versions, etc, and if you're feeling bold,  look at their code.


Mirror Modifier does not work on where ther are no faces

All modifiers have several options that alter the way they are displayed. Not all modifiers have every option available. The buttons for these display choices are shown at the top of each modifier -

The first two options  are available to all modifiers and make the modifier visible in final render or viewport display. In object mode in the viewport with this enabled you will see the edges created by the mirror modifier.

When available the other two options effect what modifier data is shown in edit mode.

While in edit mode and with the third option disabled you will not see any of the mesh created by the modifier.

While in edit mode and the third option enabled you will see only faces drawn that are created by the modifier. This is the default for many modifiers.

The final option allows the full edit mesh to be displayed. With this enabled you can select parts of the mesh on the mirrored side. Be careful with this option as all movements are done on the real geometry only, as you select mirrored vertices and move them they will move 'backwards' to what you expect.

Also remember that with the mirror modifier, if your mesh is centred around the point of the mirror, the duplicated mesh may be located in the same place as existing mesh data.


What is the best free software for converting photos to maps?

Free online Normal map generator: http://cpetry.github.io/NormalMap-Online/
Generate Maps from Textures and 3D models: https://shadermap.com/home/
Create Bump maps easily: https://www.crazybump.com/

Hope this meets your requirement! :)


How to make weight paint mode use x-ray selecting

Yes, you can do that in weight paint mode:

Select the bone
Activate 'vertex selection masking' (or face selection masking with the button next to the left)
Now you can select vertices like in edit mode, using A or box selection or circle selection
Also you can use (if you need) Z to select behind/non visible parts (like toggling mesh/solid in edit mode, or like enabling/disabling 'limit selection to visible')


Blender Cycles Jagged Edges On Basic Shapes

For future reference, the general preference here is to use Blend Exchange

I think this is a combination of anti-aliasing and the very fine angle and sharp contrast. Which is why even at high quality settings of 300% and 1000 samples in your file, it is still happening.

Here I see it (when zoomed out a bit):

Here I don't (100% scale). Or at least it is hard to detect without my eyes going funny:

I would suggest that the filter (anti-aliasing) needs adjusting for this sort of scene. Have you tried playing with the Render/Film/Pixel Filter values? I found that 2.0 looks better and 2.5 is the best. More than that and it starts to get fuzzy.

Quality is sufficient at maybe 64 render samples, which makes testing lot quicker than with the 1000 that you have. Using a Render Region (under Scene/Dimensions panel) to restrict rendering to the bit you are interested in also helps a lot with speed of testing.

This is 300%, 64 samples, pixel filter = 2.5, viewed at 100% (press 1 in render window):


In Compositor, is it possible to change multiple node values simultaneously even though there is no input socket?

Just add a Value node and use it with a driver.
That counts as within compositor, right? :)

Add a Value node
In value field RMB > Copy as New Driver
In Distance field RMB > Paste driver


Can anyone tell the difference in material setup for a chocolate solid and a chocolate liquid

The Roughness of the material is the only difference. Here I use the same material but only slightly change the roughness:


Why does my texture looks pixelated? And How can I fix it?

Texture looks like it is fine but it looks more like it is a shading problem.
In edit mode select all the faces and under the Shading/UVs click smooth.
Your texture could be pixelated because of image compression JPG are bad PNG are good


Do I need the camera object and the light object?

you can delete them now and readd any number of those later on if you'll need them.

also you can hide them - there is a list of scene objects in the upper right part of the UI, click on the eye icon next to those things to hide them.


I think that in the rigid body settings of the cone, you should set the Shape to "Mesh".
That will cause the physics simulation to use the actual geometry of the mesh, instead of an approximation of the shape.


Best way to join objects for texturing and game engines?

The correct workflow is to wait as long as you can before joining anything. Having separate objects is useful for UV mapping, baking normal, and texturing in general. For this reason you should aim at joining your object only when it's time to model a low poly version of it, and in the case where you don't have a low poly version you should only join them just before exporting your mesh to your game engine.


If I make W > Remove Doubles it does remove doubles. So you have a lot of vertices overlaying. Also, there are a lot of edges crossing faces but that are actually not part of these faces, that's why when you drag some vertices some edges stay still. I guess when you modeled your mesh you used F to fill the gap between two vertices, but as they were already part of a face, instead of cutting through the face, it has created an independent edge over the existing face, you should have used J to join these vertices. Or maybe you had a vertices grid and you pressed F to fill and it created faces over other faces? Anyway, the best way to fix all this mess is to delete all your faces and keep only vertices, remove doubles, and correctly fill the faces.


Changing an object size/rotation doesn't update information in Transform window

This situation can occur if you select 2 objects, and then hide the last selected one.
With the last selected object hidden the rotation will center around the only available one now and it looks exactly like this.

Here the procedure to get to the same situation:

Solution: Make sure the object you work on is the active selected one, yellow outline.


how to display loaded objects during session of batch load .obj file in Blender using script

You can use bpy.ops.wm.redraw_timer(type='DRAW_WIN_SWAP', iterations=1)


Is there a caveat to using drivers on node properties?

If you want the driver on the mapping node to work correctly you need to add it via the outliner, not the node editor as you might expect.

See this tutorial http://vimeo.com/40389198 starting at ~18:30 for directions on how to make it work.

It don't know if this is considered a bug but the behavior certainly isn't very user friendly.


Rotate an edit bone
To define a rotation require the angle to rotate, the axis to rotate around and a point that the axis goes thru.  To code transforms in 3D the sooner we get our heads around linear algebra, ie vectors and matrices the easier it becomes.
Following test script rotates the edit bone (in edit mode) named "Bone" 30 degrees around the bones local X axis, using its head as the pivot point.
One translation matrix moves such that the head is (0, 0, 0) our pivot point. Rotate this with rotation matrix. Move back with negated transform matrix.
import bpy
from mathutils import Matrix
from math import radians

context = bpy.context

bone_name = "Bone" # change to suit

ob = context.edit_object
arm = ob.data

#bone = context.active_bone
bone = arm.edit_bones.get(bone_name)

if bone:
    # local axes of the bone
    x, y, z = bone.matrix.to_3x3().col
    # rotation matrix 30 degrees around local x axis thru head
    R = (Matrix.Translation(bone.head) @
         Matrix.Rotation(radians(30), 4, x) @
         Matrix.Translation(-bone.head)
        )
    #bone.matrix = R @ bone.matrix
    bone.transform(R)

adjust the angle, the axis, the pivot point  to demo how it works. Using y for axis should "roll" the bone.


So lets go on buddy...

...as You could see on the picture above, we have a few steps ahead.

1) Activate MIST in the Render Layers / Passes as could bee seen in the center of the image.

2) Choose the camera and activate MIST in the Camera / Display section. Now You are able to see the yellow line near the camera which shows start and end of the mist.

3) Now select the values for START and DEPTH in the World / Mist Pass. The line of the camera will follow accordingly.

4) Render your image.

5) Finally, open Compositor in Node Editor and build the nodes like me - the important changes are in the RED rectangle. The Node I added is the Add / Color / MIX.

6) Render your image AGAIN.

Hope it helps, buddy - sincerely, Jan


How can I make a coil with relief (volute)?

There are probably many different ways to achieve it. I used Extra Objects and F2 add ons.

Start with adding a Spiral (Add-->Curve-->Spirals). Play with its settings in a Tool Shelf (T)

Convert your curve to the mesh (press Alt+C-->Mesh from Curve). Then select the whole mesh (A) and extrude it (E) as pictured below.

Being in Edit Mode add a Circle with the equal number as the Spiral's steps number. Extrude the Circle and use the snapping tool to snap its edge loop to the bottom vertex of a curved mesh. Now use the knife tool (press K,LMB, next C for a straight cut and then Z to cut through) as pictured below. Delete vertices above and below added cuts.

Fill the gaps with F (enable the F2 add on). You may also use the bridge tool to do it.

If you want to sharpen edges with edge loops (Ctrl+R) retopologize the top part as pictured below. This kind of geometry'll also smooth the end of the curvature.

Here's my final topology (with no tris and n-gons), that allows me to crease the edges.

Use proportional editing with a Sharp falloff type to adjust volute's proportions as you like.


This is non-trivial.  For an arbitrary animation, you would basically have to evaluate the data_paths at every frame and insert a keyframe.  For a rotating cube you would have to give it both rotation and location keyframes.

For an example of how sticky this can become, consider the similar http://web.purplefrog.com/~thoth/blender/python-cookbook/snapshot-keyframes-as-mesh.html, which I do not include inline because it does not actually solve your problem, it is just an example of how things can get messy when you have to step frame by frame and coerce blender to apply (for lack of a better word:) stuff.

For the special case of rotations, you can use sinusoidal easing (on the t menu of the fcurves editor) to animate the location of the cube as long as it always rotates in 90 degree sweeps.

Another trick for the limited case would be to change the origin of the cube's mesh to be where the empty used to be and then rotate the cube.


Spotlight with Halo applied is creating rings around light

That is a dithering problem. Which is not really a problem at all, but rather what physically must happen. That occurs any time there is a small change in color spread over a large area.

One of the ways to get rid of the banding is to make a stronger contrast, such as a pure black background.

The best way to deal with it. Is under the Render tab in the Properties window. Set the dithering amount up a bit until the color banding is not visible.


Why is the loop cut tool stopping at one face?

I don't fully understand your question, but keep in mind that loop cutting only works in quads. What you seem to have there is an "ngon" ==> An ngon is a face or polygon that is made up of five or more sides or edges connected by five or more vertices. Anything over a quad (4 sides) is considered an ngon. So notice in your screenshots that the loop cut worked perfectly where you had faces with 4 vertices and (if what I am seeing is correct) where the interruption happens you have a face with 7 vertices. Try joining the 2 vertices above the ?pipe? by selecting them and pressing "J".


make fails because of Python version, but I did not realise that Blender comes bundled with it's own Python package. So in the latest make update the code / scripts came bundled with latest Python version that they should be built against.
The following article gave me a hint for the solution.
Building Blender with a different Python version
I edited ./build_linux/CMakeCache.txt
changing  the all of the Python version number references
to that of the new version found in
./lib/linux_centos7_x86_64/python/bin/

I could then successfully built Blender from source again.


here is a 1024x1024 example.

go to shader editor and make the first option in image texture to cubic or smart.


How to delete an image that was drag and dropped instead of added with Images as planes?

Press N
go to Background Image
delete image
END


Similar to a subsurf modifier, the multires modifier has settings that determine what level of detail is used for object mode, sculpt mode and rendering. If you only see a cube in object mode then you most likely have the preview set to 0, simply increase this to see your sculpt detail.

Note that the detail shown from the preview setting is used when you apply the modifier, which must be done while in object mode.


The problem appears to be due to negative values being used in the Mix factor resulting in artifacts where the 'negative' of the orange colour is becoming evident.
Each channel from the Normal is in the range -1.0 through to +1.0 and so the 'add' can result in negative values. Normally a 'mix' factor will automatically clamp the values at 0.0 and 1.0 but in this case that doesn't seem to be happening. By enabling 'Clamp' you are limiting the output of the Add maths node to strictly the 0.0 to 1.0 range so that the mix is behaving consistently.


The Hide in Viewport option is just applied for the current view layer, whereas Disable in Viewports is global and applies to all view layers and viewports.

The change for Hide in Viewport is limited to the view layer as seen below

Activating Disable in Viewports in View Layer also affect View Layer.001 and all other view layers.


Is there a way to delete bone constraints by name?

Delete the constraints with name "Action" or delete the constraints from bone which contain "Action" in bone's name? I will assume the later one in my following answer:

Use bone.constraints.remove(constraint) instead of operator. armature - delete bone constraint in python

Directly use what you get from for loop

import bpy

for bone in bpy.context.selected_pose_bones:
    if 'Action' in bone.name:
        # Iterate over all the bone's constraints and delete them all
        for c in bone.constraints:
            bone.constraints.remove(c)  # Remove constraint

import bpy

for bone in bpy.context.selected_pose_bones:
    for c in bone.constraints:
        if 'Action' in c.name:
            bone.constraints.remove(c)  # Remove constraint


I guess what you're looking for is just to change the Pivot Center to Individual Origins:

Now when you scale up your objects they stay in their position:


"Time remap" or slow speed of cloth particles driven by a force

Final:

Overview:

This is pretty easy solution surprisingly. Only thing you need to do is keyframing Cloth > Speed > Multiplier value.

  Slow down speed is exaggerated in this example just to be more
  visible. For slowing down by 15% use values 0.75 instead of 0.1.

Steps:

Set frame to 1 and press I hovering mouse cursor over Multiplier value 1 to set keyframe.
Select next frame which should be starting point for slow down, change Multiplier to something like 0.1 (smaller value, slower time) and set keyframe.
Select frame which should be start of the end of slow down and set another 0.1 Multiplier keyframe.
Lastly set a keyframe which will be definite end of the slow down with Multiplier value 1.

If you want so more help, please put it in the comments as I really don't know what else to explain, it's really simple setup.

Edit:

As @risingfall stated in his comment, you will need to add new cache to Particles and set Cache step to 1, than remove previous one and do the same with Cloth (without changing step, as it isn't present).

Edit 2:

It seems that doing this only with Cloth cache is enough. Even in my gif under final you can see that on the timeline sim is baked only at certain frames. Adding and deleting cache for Cloth is fixing this. To be sure, re-add both caches.

I don't know why this is happening, I'm gonna investigate it further, but at a first glance it seems to be bug/corrupted cache.


The scene has to be active in order for objects within it to receive and process messages.

Instead of removing the overlay scene to hide the inventory, you should just move/rotate the camera to look away at some empty space.


Align internal parts of several meshes to the exact same "height", for 3d printing

It's certainly an awkward task, but doable if I understand the situation correctly.
In short I would develop an alignment mechanism with an armature:

Snapping the head and tail of corresponding armature bones to each hole of a bone model.
Parent each bone model to it's respective armature bone.
Duplicate another armature bone per existing armature bone to serve as a target for a damped track bone constraint.
Enable "affect only locations" in the viewport and scale all of your bones in Pose mode to zero in the z-axis.

Here's a brief video of the process.


Blender only paints to one image at a time.

One solution may be to set the texture brush mapping to stencil and align them visually. If your brush textures align and you don't move the 3dview then the two textures will just line up after you change brush settings and active layers.

When you enable stencil mapping, the texture is overlaid on the 3dview. Use  RMB to move the texture into place, ⇧ Shift  RMB to scale and ⎈ Ctrl  RMB to rotate, then use  LMB to paint it onto your texture image.


Blender cycles and blender internal look the same and my materials are too shiny even on diffuse

In your screenshots only the OpenGL viewport "preview" shading is being used; to see what your materials actually look like when rendered with BI or cycles, switch from Solid shading to Rendered in 3D view > Header (or press ⇧ ShiftZ)

You can adjust the way a cycles material is rendered in solid view via the options in Materials > Settings:


How would I make these curved indents in this water bottle? Picture in description.

Start by making the main outline of your bottle. Once you have that, hover over the section you want to add the inset to and press Ctrl+R. Use the scroll wheel to select exactly how many you want.

Now use Ctrl+Tab+E to switch to edge select mode. Holding Alt+Shift, right click on the newly added loop-cuts. Press Ctrl+B to bevel and roll the scroll wheel one click to add another loop cut in the middle.

Now select the inner loop-cut on each of those rings. Now press Ctrl+. (period) to change to the Individual Origins pivot point. Scale the selection down as desired.

Now go into orthographic mode, and press Numpad 1 and select the center vertices as shown. Move them up as desired. Go ahead and press Numpad 3 and do the same thing. Enable a Subdivision Modifier, and bevel the edges using Ctrl+B.

Final result:


Associating photos to the faces of a cube

You need to:

Create 6 different materials (Since you have 6 different images you need to create one material per image).

Have each of the materials use an image as texture.

In Edit mode you need to select a face and assign a material to it.

Repeat that to all of the other faces until each one has a material and each material is using the texture you want.

For greater control on how the textures are mapped on the mesh, you need to unwrap the mesh to create UV maps.


How to make an very extensive Squash and Stretch rig?

Yeah, I guess the universal stretch to -bone is one solution... maybe

With two stretchers it's way better, though:

Oh, but Bendy Bones might be even better for the main core rig.
This was an essential addon to make those bbones, then I just joined them together.

Oh yeah, progress:


I am not sure, I have never seen that shortcut used before, However, You can move the origin down to the location you want it in object mode, tab into edit mode, and move your object back up to its original location, this should produce the same result.


Fade in action applicable to all objects (in cycles)

You could use a node group to do this:

Add a mix shader and create a new node group by selecting it and pressing CtrlG
Add a transparent shader to the node group:

Add this node group at the end of all the materials you want to simultaneously fade in/out:

This process can be made a little bit faster with copy and paste:

Select the node group and press CtrlC
Select each object/material and press CtrlV to paste the node group.

Adjusting the Factor of the mix node inside the node group will set it for all instances of the node group

With the factor set at .5 and .8 (click for larger image):


How to export texture into a file that unity can read

You can bake normal maps from geometry in Blender. Unity works very well with normal maps. Follow the instructions here, but instead of baking a displacement map, bake a normal map.
How to make a displacement map from existing 3d geometry

Displacement maps work great on models with high levels of geometry. They work by displacing the models vertices based on the texture value. dense geometry does not work great in video games, because that means more faces that the computer has to render 60 times per second (usually). Instead a normal map represents lighting information for each pixel within the texture. Without deforming the actual geometry, the texture itself can receive detailed lighting information, creating the illusion of depth.


Where is this grey camera shape coming from?

I accidentally selected Alt + B. Selecting Alt + B again did the trick.


The file you're trying to import has the extension .obj.py.  It is not a .obj so you can't import it like a normal object.  Go into the text editor view in blender, Press Alt + O, or go to Text>Open Text Block and open the .py file, then simply press Run script or press Alt+p


How to get rid of white edge artifacts when using alpha texture?

What's the cause of the problem

The problem with this is how the transparent texture was created. Some pixels of the image are fully opaque (0% of transparency), some are semi-transparent and some are fully transparent (100% of transparency).

However even the 100% transparent areas have color. Because each pixel of image (when it has alpha channel) has color defined by 4 values = RGBA.

So let's say first color would be rgba(255, 0, 0, 0) and the second would be rgba(0, 255, 0, 0). They are both fully transparent, however the first is red and the second is green.

And the compression algorithms in most programs and game engines take into account also color of transparent areas. Mostly around edges where it is used for anti-aliasing, filtering, ...

Most graphics editors (like Gimp) put completely white color to fully transparent areas, which causes artifacts like in your case.

Solution

To solve this problem there is a pretty cool plugin for gimp. Download it from here (it is part of this thread). Save it into your .gimp-2.x/scripts folder (In my case the folder is located here C:\Users\Stefan\.gimp-2.8\scripts). Restart Gimp, open your texture, and select Layers > Transparency > Bleed Colour into Transparent Areas .... Leave the default settings and wait til it finishes. Now export the result to PNG. And that's it, now the artifacts are gone.

Sources

This answer was inspired by another answer here. Check it for more detailed explanation and alternative for Photoshop users.


There are two events for keyboard keys: When you push the key down and when you release it.
event.value is 'PRESS' or 'RELEASE'.
Run this code in Text Editor, put your mouse over 3D View and hit Spacebar.
Search for Simple Modal View3D Operator and run it, then press some keys.
import bpy
import blf

def draw_callback_px(self, context):

    font_id = 0  # XXX, need to find out how best to get this.

    # draw some text
    blf.position(font_id, 15, 30, 0)
    blf.size(font_id, 20, 72)
    blf.draw(font_id, self.key)

class ModalDrawOperator(bpy.types.Operator):
    """Draw a line with the mouse"""
    bl_idname = "view3d.modal_operator"
    bl_label = "Simple Modal View3D Operator"

    def modal(self, context, event):

        mod = []
        if event.shift:
            mod.append("Shift")
        if event.alt:
            mod.append("Alt")
        if event.ctrl:
            mod.append("Ctrl")

        if mod:
            mod = "[%s]" % "+".join(mod)
        else:
            mod = ""

        context.area.header_text_set("%s %s - %s" % (mod, event.type, event.value))

        if event.unicode:
            self.key += event.unicode
            context.area.tag_redraw()

        elif event.type in {'RET', 'NUMPAD_ENTER', 'BACK_SPACE', 'DEL'}:
            self.key = ""
            context.area.tag_redraw()

        elif event.type in {'RIGHTMOUSE', 'ESC'}:
            bpy.types.SpaceView3D.draw_handler_remove(self._handle, 'WINDOW')
            context.area.tag_redraw()
            context.area.header_text_set(None)
            return {'CANCELLED'}

        return {'RUNNING_MODAL'}

    def invoke(self, context, event):
        if context.area.type == 'VIEW_3D':
            # the arguments we pass the the callback
            args = (self, context)
            # Add the region OpenGL drawing callback
            # draw in view space with 'POST_VIEW' and 'PRE_VIEW'
            self._handle = bpy.types.SpaceView3D.draw_handler_add(draw_callback_px, args, 'WINDOW', 'POST_PIXEL')

            self.key = ""

            context.window_manager.modal_handler_add(self)
            return {'RUNNING_MODAL'}
        else:
            self.report({'WARNING'}, "View3D not found, cannot run operator")
            return {'CANCELLED'}

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

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

if __name__ == "__main__":
    register()


If you want depth values that are parallel to the image plane, change the camera to orthographic projection. This will give accurate values in the Z-pass.

Edit:

Your error was having the file output node set to Float (Half) instead of Float (Full). Each file output node as its own settings! The reduced bit width resulted in the loss of precision.

Here is a little script for checking the values and displaying the normalized image. It requires OpenCV.

import cv2
import argparse

def image_values(path):
    """
    Print the pixel values of the column at the image center and display the normalized image.
    :param path: Path to image
    """
    print(path)
    img = cv2.imread(path, cv2.IMREAD_ANYDEPTH)
    (h, w) = img.shape
    print("image ({}, {})".format(h, w))
    img2 = cv2.normalize(img, None, 0., 1., cv2.NORM_MINMAX)
    for y in range(h):
            print("({},{}): {}".format(int(w/2), y, img[y, int(w/2)]))
    cv2.imshow('image', img2)
    cv2.waitKey(0)
    cv2.destroyAllWindows()

if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Analyze image values")
    parser.add_argument("--src", type=str, help="Image to load.", required=True)
    args = parser.parse_args()
    image_values(args.src)


I'm not sure it's the best method because it has some flaws but anyway:

Model all the big stripes on your mesh in Edit mode.
Give your object a Multires modifier, subdivide 5 times.
Switch to Sculpt mode and sculpt all the folds (Crease brush seems to work fine for this job).
Don't apply the Multires modifier, bake the normals using the method explained here by Pixxo, so that you can keep a rather low-poly object.


Is it possible to convert game hair cards into hair particle systems?

There is no method like that. Your only option is to delete all the hair cards and replace them with hair.
It isn't worth it. I would just say go with the hair cards and set all the hair card to any hair texture you like.


Mapping of metal rust textures on UV sphere

Here is some more explanations about what I proposed in the comments.

The changes in the nodes setting:

All come from 'generate'
Texture nodes are set to 'box'
A blend is tuned to avoid to see the 'box borders' (maybe, you should prefer to link them all with a single value)
The UV map is removed from the normal map node to keep coherency regarding the texture

So when the material is changed to that:

But the blending of the 'box' mode looses a bit of the quality.

Edit: some explanations following the comments

The sphere cannot be unwrapped equally (respecting model vs. UV map proportions) without seams.

But if you have seams, that will be visible at the junction on the 3D model (even if we have seen a solution here Realistic Rusty Chain, the problem is your texture is repainted so is no more generic).

So we don't want seams. But without seams no respect of proportions...

The box mapping (as I imagine it works):

It is a cube envelop projected on the surface. And... that makes seams.
But we have the ability to use the blend factor, which is some way extends the envelop so that parts overlap but are blended.

So all seems to be good... except the point I mentioned before: we loose a bit of quality due to this blending.


Join blocks at the corners (Starter Block)

You can set what type of snapping you want in the snapping pop-over.