Split long thin faces into less elongated ones

I've done some research and tried a number of methods, so I'll document them here. Feel free to improve on my rather basic Python!
First some code that identifies the long edges, and bisects them (adds new vertices along the long edges:
import bpy
import bmesh
from mathutils import Vector

...

# There's only ever one object in the data I'm processing. Could also specify by name
# e.g. bpy.data.objects['surfboard'].data
me = bpy.data.objects[0].data
bm = bmesh.new()
bm.from_mesh(me)

EPSILON = 1.0e-3

...

longFaces=[]
edgesToCut={}
for vert in bm.verts:
    if abs(vert.co.x-0.05) < EPSILON:
        for edge in vert.link_edges:
            leng=edge.calc_length()
            if leng > 0.4:
                for face in edge.link_faces:
                    longFaces.append(face)
                cuts=int(leng/0.2)-1
                # Categorise according to number of cuts, for efficiency because
                # bisect_edges can cut more than one edge at once.
                if cuts not in edgesToCut:
                    edgesToCut[cuts] = []
                edgesToCut[cuts].append(edge)

for cuts, edges in edgesToCut.items():
    bmesh.ops.bisect_edges(bm, edges=list(set(edges)), cuts=cuts)

This focusses on the edges connected to the x = 0.05cm line, which are the issue for me, and assumes that if a face has a long side, it must be thin, which is true for the cases I'm dealing with. This could be altered to suit, e.g. to actually measure the width and make cuts based on how thin the face is. But the idea is to find the problem faces and add extra vertices where they will be useful.
I use list(set()) to weed out duplicates.
Next, I could use
bmesh.ops.triangulate(bm, faces=list(set(longFaces)))

which will automatically split each face into triangles. However for me, that just creates lots of long and even thinner triangles than the faces I split, which actually makes the unwrapping worse. So I devised a manual solution by scanning the vertices on each of the faces and measuring to the nearest vertex on that face. If they're not already connected, then I can mark them for connection:
# For each face, test if each vertex is connected to its closest sibling
longFaces = list(set(longFaces))
vertsToJoin = []
for face in longFaces:
    edges = face.edges
    # Make a mapping of the vertices on each edge
    connectedVert = []
    lastVert = False
    firstVert = False
    for vert in face.verts:
        if lastVert:
            connectedVert.append((vert, lastVert))
            connectedVert.append((lastVert, vert))
        lastVert = vert
        if not firstVert:
            firstVert = vert
    # and join to the beginning
    connectedVert.append((firstVert, lastVert))
    connectedVert.append((lastVert, firstVert))
    for vert in face.verts:
        # What's the closest other vertex?
        minLength = 9999
        minVert = False
        for vert2 in face.verts:
            if vert != vert2:
                vec = Vector(vert2.co - vert.co)
                if vec.length < minLength:
                    minLength = vec.length
                    minVert = vert2
        if minVert\
                and (vert, minVert) not in connectedVert\
                and (vert, minVert) not in vertsToJoin\
                and (minVert, vert) not in vertsToJoin:
            # Only join if they're the closest and they're not connected already
            vertsToJoin.append((vert, minVert))

At this point I tried bmesh.ops.connect_vert_pair; it seemed logical! However it's actually quite slow; even though I give it two vertices on the same face, I suspect it may be pathfinding elsewhere too. If I set faces_exclude to [all faces minus the one I want it to use], it deletes the face and doesn't connect anything. I'm not entirely sure what the exclude parameters do; there are very few examples of their use. But I did find this tiny nugget in the source code regarding them:
/* tag so we won't touch ever (typically hidden faces) */

So I wrote the following code to take each pair of vertices and join them, thus splitting the faces, checking that there's exactly one face in common with each vertex pair:
for vertTuple in vertsToJoin:
    # Could use bmesh.ops.connect_vert_pair but it takes a couple of minutes.
    # This takes about 45 seconds.

    # Find the common face, which may not be the one we had earlier
    commonFaces = list(set(vertTuple[0].link_faces) & set(vertTuple[1].link_faces))
    if len(commonFaces) == 0:
        print('Vertices not on same face?')
        continue
    elif len(commonFaces) > 1:
        print('Vertices on multiple shared faces!')
        continue
    face = commonFaces[0]
    firstFace = []
    inSecondFace = False
    secondFace = []
    for vert in face.verts:
        if inSecondFace:
            secondFace.append(vert)
        else:
            firstFace.append(vert)
        if vert == vertTuple[0] or vert == vertTuple[1]:
            inSecondFace = not inSecondFace
            if inSecondFace:
                secondFace.append(vert)
            else:
                firstFace.append(vert)
    bmesh.ops.delete(bm, geom=[face], context=3)
    bm.faces.new(firstFace)
    bm.faces.new(secondFace)

That last code block takes by far the longest (of the identify faces / bisect edges / split faces process), but is faster than the other face splitting methods except triangulation.


Activate the Node Wrangler Addon.

With the sphere unwrap

Click on add material with the selected default material just change the diffuse material to Principled BSDF.

Before u go to next step u must save the image with the name (normal, spec, Ambient, disp.) Note : without name it will not work so just the normal name should be to the images so that addon find out correctly.

With the Principled BSDF Node Selected Press Ctrl+Shift+T

A window target select the file which are saved with the name

Click ok and render


When painting, you need to choose which image is active by selecting it in the Slots tab of the toolbar. Normal maps work on colors that represent xyz axis for normals, and bump maps use black to white gradient for in and out displacements. Reordering the textures in the Properties texture stack won't affect it unless both are set to 'color' and then the one on the bottom of the stack blocks out the one on the top of the stack.


Is it possible to snap objects to faces in the Blender Game Engine?

Starting with the rig that is in this answer, Making a grid snapping system is actually very simple.

First, select the ground plane and scale it to be relatively small.

Replace the script on the ground plane to this

from bge import logic

def main():
    scene = logic.getCurrentScene()
    cont = logic.getCurrentController()
    own = cont.owner

    mouse_over = cont.sensors["Mouse_Over"]

    if mouse_over.positive:
        tracker = scene.objects["Tracker"]
        tracker.worldPosition = own.worldPosition
        tracker.worldPosition.z += 1

You need to also use this logic setup on your plane

Now, when the mouse is over that plane, it will move our arrow to the world position of the plane.

However, this is not much of a grid - yet.

First we should move the plane to one corner. Your current setup should look like this.

To create the grid, we can use the array modifier on the ground plane.

Enter edit mode by pressing tab

With all of the faces selected, we can press p Note that we must be In edit mode, if we were in object mode, this would start the game engine.
Select separate by loose parts

We now have all of the planes now as different objects. If we press play we can see how it will work so far.

For some reason it is not working. Good thing is that I'm writing this answer and I happen to know why it isn't working. (This is really easy to fix :-)

Our problem is that all of the origins are in the same place. The system actually Is working, but quite simply, the world positions of all the objects are in the exact same location so there will be no noticeable change.

However, with all (most) problems, there is a solution. Select all of the grid objects, and press Ctrl+Shift+Alt+C  This will allow you to change the origins of all the grid objects.

You could select Origin to Center of Mass or Origin to Geometry

Since they are infinity square planes there is no difference.

Now, Each grid section has it's origin centered over itself, so when it snaps the arrow to it's origin, it will work like a grid snapping system Translation: everything works and everyone is happy

Now we have a basic grid snapping system.

The basic idea for making a world building system is being able to stack cubes and place them next to each other. This is not Very hard to do, we only need to add the Boolean property Ground to the cube that is being added (Building), and we also need that cube (still named Building) to be running the script.

There are a few more minor adjustments we need to make to the grid objects.
First, because our cubes are 2x2x2  the grid planes should all also be 2x2 . Also, If two cubes are stacked, there is a space of Two  between their origins. we must adjust the script.

Also, because the cubes are being added Two  above the plane, we need to move the origins down one unit.

The end result can be seen working awesomely.

Working blend with world building system.


Objects appear in the viewport and preview render, but not in the outliner or final render

As mentioned in the comments, you most likely have the eyes set as not visible in the render. This is shown in the outliner with the camera to the right of the object, the eye is for viewport visibility, which also effects viewport preview rendering while the camera only affects the final render.

To find an item in the outliner you have a few options, if they are named well you can search for them -

If you haven't named things, you can select it in the viewport and the item will be highlighted in the outliner, with a large list of items press . with the mouse over the outliner to zoom to the item, this will expand any parent objects to show the item.

Once you locate the object in the outliner, click the camera to make it visible in the render.


How to export multiple objects/materials to Substance Painter?

I think you need to assign different materials in blender for each part of the mesh you want a different texture set.


Shared Network install / config priority

Blender searches three places for a startup file in the following order -

local  - located next to the blender application.
user   - located in the users home folder.
system - located in a shared system location (like /usr/share)

When you save your settings it is saved to the same location as it would be read from at startup.

This works well with the way blender allows you to have multiple copies on your machine, each can have their own config settings unique to that copy.

In your situation you have the local settings in a shared location that you consider a system location.

One option is to compile your own version that ignores the local copy.

Another is to copy your initial startup file into place on each machine.

Maybe the users could start a small setup script instead of blender (or appears to be blender) that checks existence of user config and copies your initial setup to the users machine from the network drive, obviously not located in the proper startup location and then starts blender.


Set a camera to free fall like a Rigid Body?

No python needed.

Simply add a Copy Location constraint to the camera. Set the Target to an object with an active rigid body. (I simply duplicated one of my colorful cubes and moved it back from the rest of the bunch. Remember to turn the visibility off). That will get the camera to fall down with gravity.

To get the nice camera shake when it hits the ground we need two more constraints. A Copy Rotation constraint and a Track To constraint.
The Copy Rotation is copying the rotation of the same cube the camera is glued to, that gets the real shake from the impact with the ground. (I have the Influence of that set to 0.5 just to tone it down a bit.)

The Track To is to keep all my cube in frame. (you can see how much the cubes tumble, and without this constraint the camera would do that too.)

These are my constraints on the camera. Do note the object "Cube.001" is the cube I moved off screen for the camera, and the "Cube" is simply one in the middle of the pack.


How to create this painted metal material?

I would suggest to use the Principled BSDF shader, which allows you to create a metallic material with a clear coat. You can add a procedural noise as bump map for the small surface irregularities.

My setup in the screenshot below uses a Musgrave texture, which is connected to the Bump node which in turn is connected to the Clearcoat Normal socket of the Principled BSDF. The Principled BSDF has the Base Color set to nearly black, Metallic to 1.0, Clearcoat to 1.0 as well.


All options are greyed out and inaccessible in the node editor

You need to add a new material.
Press "New" in the bar below the node-editor window.

make sure the "use nodes" is ticked.


Distorted exported .fbx model when objects are under parent

I'm not sure if this problem has been resolved or not, but for future reference, I also frequently work with Unity and when FBX exports are distorting for me, it usually involves one of two things:

1) As mentioned in comments, I have a mesh that has an unapplied transform to it, and the FBX exporter is getting confused.

2) I have an animation doing something wonky on its first keyframe, which needs to be replaced or removed. This can result in distortions which look nothing like the animation itself, particularly if there was unapplied scaling or rotation involved at some point.

This may or may not solve the issue, but I'd bet that it's an animation. Perhaps the model has an entry for the leaves rustling or blowing with the wind?


How to make a model cast shadows onto the world texture/background?

CYCLES ENGINE
Shadow Catcher
Starting from version 2.79 any mesh object can be set as Shadow Catcher.
Select object (like a Plane) and check this option.

2.79 located in Properties Editor > Object > Cycles Settings
2.8+ located in  Properties Editor > Object > Visibility

Issue of current Shadow Catcher
Shadow Catcher can receive only shadows (limits are nicely summarised in this DevTalk) So I will keep Shader method, that can be used to "catch" also emission, indirect light or reflection that gives more sense in term of merging CG into image. Comparison ...
Example of Shadow Catcher issues -/- comparison with Shader solution

Edit 2021-05-05 Finaly movement :) Initial implementation of improved shadow catcher. Anyway here is shader solution for now ...

Shader for HDRi Environment

This material for ground plane object can also receive lights, indirect light or reflection.

This material gives you precise feedback if the HDR image lights correctly. If not, ground plane will be brighter or darker (or will tend to be a different colour tone) depending on image color deformation.

Material for ground (plane) is Diffuse shader with assigned Environmetal (Equirectangular) HDRi texture. The same texture used for World. The trick here is to use "Reflection" texture coordinates with negative Z value (-1). For smaller color differences between found and environment use RGB node.

Showcase https://vimeo.com/159234378
For more examples and tests check out this Blenderartists thread.

Lighting by HDRi
is another topic, so just a quick tip if HDRi doesn't light properly. Use this World node setup, in most cases just increase/decrease Fac value of the first "Mix" node solves. Second "Mix" node affects "Exposure" of the HDRi.

If lighting seems to be ok, but shadows are still too blurry you will have to fix the HDRi image manually. Open the image in an image editor that supports 32 bit images, select small circle in place of sun and increase exposure. Sorry can't find the tutorial link.
Rendering – Be sure "Multiple Importance" is enabled in World Properties panel (value like 840), it should be checked by default.

Shader for Backplate (2D image)
In case you want to merge your CG with the backplate, simply use "Window" texture coordinates for shadow / light receiver. This material doesn't have a geometry limitation. In this example, a plane is used also, but it can be any shape. Scene is lit only by a sun with strength that brings ground image to background colours. Both previously mentioned benefits (shadow/light receiver and in this case general feedback of correct lighting) works here too. Disadvantage of backplate (compared to equirectangular HDRi image) is lighting inaccuracy and missing reflections.
Note: the same node tree is used for the world.

Note:
There exists OSL shader QUIP and QUIPCam for this purpose that gives you the ability to have a bit of movement in the environment too. But OSL isn't supported for GPU calculation and takes quite a lot of time to get a clean render.


how do I build a list-multi-select widget using a box with operators?

Ok, so after some reviewing and paying around with stuff...

The short answer is forget about it...
blender's api just doesn't have enough thought put into it, and what's needed simply doesn't exist.

The long answer, build a collection property and wrap it with a pointer property for use in a template_list.

Here's my code for it with an example showing it in action:

Sorry my code is an image...
phone's can only do so much...

So I think that makes me the first to do something like this :)

Now if only I could get active selections to have a blue background rather than white text. >_>


Why does object in viewport shading render view suddenly disappear

I suppose Gorgious might be correct with his guess. If you have an AMD graphics card you might have a look at this question:
AMD GPU material is entirely gray
Since you have Overlays disabled, there will not even be an outline of selected objects visible etc.
If it's not the graphics card, check if you might have disabled the Object Types Visibility for Mesh by accident (see left side of screenshot). Or maybe you have disabled the Ray Visibility for Camera in the Object Properties (right side of screenshot), but the latter you must have done on each object that's in the scene which I doubt.
If it's none of the above providing a blend file would be better to find out what it might be. Even if there would be no light in the scene, the world background shines a dim light on the objects so there must at least be something visible. Or do all objects have only a Diffuse shader set completely to white maybe?


Why does it appear like it is snowing in my animation?

that "snow" is caused by a particle system. Like you can see at the image you need to turn of HALO in that particle system that created the particles.

So find that particle system and turn of HALO


Why do fractured parts act like an explosion?

Basically it happens because when it simulates, the solver thinks meshes are intersecting with each other and it tries to separate them asap, giving the shards (sometimes) big speeds. Already mentioned Split Impulse might work and should in most cases, but there are couple more things you could try:

In Scene -> Rigid Body World increase Steps Per Second and Solver Iterations for more accurate simulation.
Try changing between Convex Hull and Mesh in Physics -> Rigid Body (for each simulated object) and adjust the Collision Margin parameter; it is not said which works better for any scene, Convex Hull simplifies the simulation so it may speed up the process, but mess the simulation even more,
Increase Margin when performing cell fracturing - this adds some space between the shards and may help a bit with simulation,
Scale whole scene up and apply scale for all objects - usually simulation performs much better for bigger objects; if you use this method, you might want to increase simulation speed in Scene -> Rigid Body World.

To copy parameters for all rigid bodies use Rigid Body Tools, select all objects you want to set parameters (like Margin for example) and copy from active Rigid body object (the one you have selected last).


How can i slow down particles after baking

Other applications like houdini and maya, softimage (ICE) have a re-time cache function. Such thing doesn´t exist in Blender.
The closest thing that could emulate your effect is if your simulation is CACHED in open VDB and you export the sequence. Then create a second particle emmiter (on a new scene) and retime the flow of the particles first, then from the previously exported open VDB, using LOAD CACHE options your new (retimed) emmitter should work with the previous VDB cached simulation.


Turn off Automatic finger Curling in Rigify

I realised somehow the fingers were set to tentacle. I just now learned the workflow of setting the rig type in the metarig at the base of each chain.
Setting the rigify type to basic.copy_Chain get me the plain FK finger setup I was looking for.
The problem illustrated above is a feature of the tentacle chain which is what it was set to. The tentacle chain uses rotation constraints to automatically rotate every bone according to its parents rotation. you can simply disable the constraint for every bone if you want to use a tentacle chain without the automatic curling.


How to show render-stamp for arbitrary values?

While Blender has no build-in support for this feature. You can do this using Python:
Add a script into your file, call it stamp_init.py (for example).

Press Run Script (only need to do once)
Enable the Register option in the text editor (so it runs automatically)

Here is a sample script.
import bpy

def stamp_set(scene):
    note =    "Samples: "         + str(scene.cycles.samples)
    note += ", ApertireBlades: "  + str(scene.camera.data.cycles.aperture_blades)
    note += ", Version: "         + bpy.app.version_string
    scene.render.stamp_note_text = note

bpy.app.handlers.render_pre.append(stamp_set)

To add more settings you can find the data-paths to them by right clicking and selecting Copy Data-Path.

Global Stamp (applies to any file you render)
Having to define a script in every-file could be tedious, if you want to use these extra stamp options in all your files, you can make this a persistent handler.
If you want to have the same stamp notes apply to all your renders (where the Note is enabled). You can add the same script into your startup file and
@bpy.app.handlers.persistent
def stamp_set(scene):
    .... same as before ...

String Formatting (further reading if you're new to Python)
Python has some clever ways you can format strings, see Python docs.
This uses the format method which some people may prefer.
def stamp_set(scene):
    scene.render.stamp_note_text = \
        "Samples: {samples}, Blades: {blades}, Version: {ver}".format(
        samples=scene.cycles.samples,
        blades=scene.camera.data.cycles.aperture_blades,
        ver=bpy.app.version_string,
        )

New Lines
As of 2.77 the note will be wrapped onto new lines, you can also add in explicit \n newline characters to format the text yourself.

Floating point numbers
A lot could be written on this, just a quick hint, if you have unwanted precision removed, eg:2.514000002324 displayed as 2.51, there are a few ways to go about it.

If you used "Text " + str(some.number) you can use round, eg:"Text " + str(round(some.number, 2))
If you use the format() method you can replace:{myvar} with {myvar:.2f}.

For more details see https://stackoverflow.com/a/455634/432509


UV texturing mesh object won't turn black in texture painting mode

It's likely that you don't have texture slot to paint on (warning about that and ways to correct are in the top of the T panel):

You have assigned material, set shading to GLSL, set Viewporrt shading to Texture and turned on Texture Paint. Thus the pink color - Blender's warning regarding to leak of texture, wasn't shown. If you switch back to Solid shading, you can see that the mesh is pink (tbh, this was the only way I could avoid of getting pink color in the beginning of the Texture painting). See why the textures are pink, or why the mesh is pink in Texture Paint.

I think it's quite handy to start this work being in the Solid Viewport shading. Then if image is missing you can notice that, while you'll see the texture in all details once it's added:


Edge collapse

As stated by the Blender reference manual's page:

  This takes a selection of edges and for each edge, merges its two vertices together

Despite the description look quite simple, the algorithm is capable of iterating the process upon several selection clusters.

The operator can be triggered by the option in the "deleting menu" that pop up after pressing X key as in the image sequence below


In order to apply a design on my object, should I texture it or model it?

Textures for Details
I suggest unwrap your object and create a black and white texture for all the details. This simple technique allows to apply different shaders to each part of the object and can be used for a normal map as well, while keeping the geometry nice and clean:

Further reading: Add different materials to different parts of a mesh?


Chebhou's response was correct. Make sure "Show Errors Only" was accidentally clicked.


Leaf images rotated wrong way on Sapling tree Gen

Well depending on what option you picked when you made the leaves for the tree you will have to fix this differently.

For both Rectangular and Hexagonal you will need to edit the UV map for the leaf object.

For the cube leaf the key is to get the stem of the leaf to line up on the bottom of the UVs in the center.
In the case of the Hexagonal leaf you want the bottom point of the hexagon to be right on the stem.

When you have the UVs set up that way the stem of the leaf will be right on the branch. If the leaf is not in the correct orientation from the branch you need to rotate the UVs. Start by rotating the UVs by 90° then see which way you need to go. (A UV Image Editor and 3D view open helps immensely here.)

For the DupliVert or DupliFaces options it is easier, you only need to align the origin of the leaf object onto the stem. A picture does a better job of explaining it:

Remember here you are moving the object in edit mode.


Cannot select individual bones of armature appeneded from 2.80 into 2.79

I think I found a workaround for this problem in case anyone else encounters it.

Create a new armature with a single bone in your project file (Shift + A Armature > Single Bone).

In Object mode, select your problematic armature (the one you can't select bones from in pose mode), Shift select your new single bone armature, and join the two (Ctrl + J ).

When I did this I was able to select all of my original bones in pose mode.


Graph Editor - Can I make proportional editing affect all the curves?

Select all with the letter A.  There is the Box Select.


Blender Bevel Object scale issues corners

You can control the radius of each segment of the curve separately:


How to create many clips in the NLA editor

The official documentation for the NLA Editor gives you the basics of operating the UI.

How to incorporate this technology into your workflow is a little more complicated.  Likewise choosing which keyframes belong in which NLA strips depends on your experience and understanding of the mathematics of the NLA system.  You're just going to have to experiment and fool around and make plenty of mistakes.

Do not underestimate the value of setting aside time just to play around and make mistakes and then try to fix those mistakes under no time pressure and with no milestones or assets at stake.

My explanation of how to split an action into two separate NLA strips probably will be somewhat confusing on first read, but after some experimentation you should have the necessary experience to understand it and absorb the concepts within.


The texture script there still works in 2.73, but there are a couple points that you may need to check.

Render engine needs to be set to Blender Render, the sample script is not setup to work with cycles.
The viewport shading settings. The texture will not show if the viewport is displayed in solid shading. In Textured shading you also need to enable GLSL instead of the default Multitexture. In Material shading the texture will show. These options will only show the image part of the texture, you will only see the full result of the texture in rendered display of the viewport or if you render an image (F12).

The Viewport shading mode can be found in the header of the 3dview -

GLSL shading can be enabled in the Shading panel of the properties sidebar (press N) -

If you want to adjust the script to work with cycles this question might get you started.


Edit texture as burned and dirty in Cycles

Looking at the texture in the picture, in addition to the curves suggestion above, I would apply the same texture as a specular map and a bump map. Here's an example set up with the specular map:

I didn't have a way to make a normal map on this computer, but that would finalize the effect, with some good lighting effects like your reference image.


Blender crashes when selecting object and I can't leave object mode

Reduce the number of subdivisions in your anvil subsurf modifier.

It has 6 subdivision iterations giving it an impossibly high poly count.
Not only is that unnecessary, it will give poor performance, consume large amount of RAM, and as you experienced already, possibly cause crashes on lower end machines.


You might just want to use python to convert the coordinates into a mesh.  There are many examples on the internet.  I'll include an excerpt from http://web.purplefrog.com/~thoth/blender/python-cookbook/triangle-donut.html because it has an accompanying narrative linked at the top:

import bpy
import math

def triangleDonut(name, nChunks, r1, r2, z1, z2):
    verts=[]
    faces = []
    for i in range(2*nChunks):
        # the first ring of vertices; we create them later in the loop
        v1=i*3
        v2 = v1+1
        v3 = v1+2
        # the second ring of vertices; these refer to vertices created next time
        v4 = v1+3
        v5 = v1+4
        v6 = v1+5
        if (i+1 >= 2*nChunks): # connect the end to the start
           v4=0
           v5=1
           v6=2
        # each ring is at a different angle from the center, eventually sweeping a full circle by the end of the loop
        theta = i*math.pi/nChunks
        if 0 == i%2:
            z=z1
        else:
            z=z2
        # basic triangle geometry here
        c = math.cos(theta)
        s = math.sin(theta)
        # append the coordinates for v1..v3 to the verts list
        verts.append( [r1*c, r1*s, 0] )
        verts.append( [r2*c, r2*s, z] )
        verts.append( [r2*c, r2*s, -z] )
        # build faces that go from the freshly added vertices to the vertices we will add in the next loop
        faces.append( [v1, v4, v5, v2] )
        faces.append( [v2, v5, v6, v3] )
        faces.append( [v3, v6, v4, v1] )

    mesh = bpy.data.meshes.new(name);
    mesh.from_pydata(verts, [], faces)
    mesh.validate(True)
    mesh.show_normal_face = True

    obj = bpy.data.objects.new(name, mesh)
    scn = bpy.context.scene
    scn.objects.link(obj)

triangleDonut("donut", 20, 3, 2, 1,1.5)

There are many other examples at that site and around the internet.  the from_pydata method is probably a good search term, although it comes up with startlingly few results on stackexchange

Blender Python mesh.from_pydata?
Python: Create Polyline and Polyloop


Blender Subsurface Scattering on Certain Area

One option is to use Vertex Colors:

Go to Object Data in the Properties panel and add a new slot for Vertex Colors. You can then go to Vertex Paint mode and paint wherever you want the subsurface to be.

Unlike Vertex Groups, Vertex Colors can be brought into materials with the Vertex Color node. (Shift+A > Vertex Colors > YourVertexColors).


Front ortho opposite way around to expected

You should accept the orientation presented by Blender.
You should not fight with Blender on this small matter
I think you should switch to each view and then use the grease pencil
I think it is more likely that you can work successfully with Blender on a second try ... rather than you have discovered a flaw in Blender.
You may want to see a tutorial on grease pencil


Rendered model is skewed and out of shape

You have the render's Aspect Ratio set to 3:2

resetting them to the default 1:1 will fix your issue


Face and Normal Constraint When Moving Vertex/Edge (Like 3DS Max)

You move the vertex and it moves the face. It doesnt make sense for blender because you're trying to snap to the face which you're currently editing. You may try any workaround you like from this list:

use Normal transform orientation and press Shift+Z twice during transform. The most unprecise method, because the vertex's normal is a single directinon, when faces connected to that vertex have multiple normal directions. So it actually doesnt use all faces normals but summary direction of them all.
duplicate an object to use it as a reference for shrinkwrap modifier.
duplicate any vertex and use face snapping. Move your topology to that vertex, using it as a guide point.

3ds max doesnt have that problem


Creating even more photorealistic rendering of this 3d print I actually made

everything is to nice.  render at a lower resolution, and use the compositor to make it look like it was taken with a cheap camera.  make the lighting more blown out.


Override the context

IMO At issue with code in question is not setting the active object, ie the one you want to copy modifiers from, to the others selected.

To set object ob as active

context.view_layer.objects.active = ob

which sets the active object, aka context.object and context.active_object to ob, but until selected it is not context.selected_objects[0]  Wrote this re using "first selected" for active object.  It causes confusion that relates to your issue here, you're only selecting, not "activating"

Anyhow, forget that, recommend overriding the context.  Build a dictionary of the context members needed and pass it to the operator. No messy selecting and setting active object.

Simple test script. It happens I am working on a tree that has a number of modifiers. I will make the tree object active. Add a cube to scene and override it as selected object.

After some testing have determined that the operator needs to override, screen, scene, object and selected_editable_objects

To test replace "Tree" with name of object with modifiers (source) and "Cube" with the name of target mesh to copy to.

Modifiers copied from tree to cube with neither selected and empty active

import bpy

context = bpy.context
scene = context.scene
cube = scene.objects.get("Cube")
tree = scene.objects.get("Tree")

override = {}
override["screen"] = context.screen
override["scene"] = context.scene
override["object"] = tree
override["selected_editable_objects"] = [tree, cube]

bpy.ops.object.make_links_data(override, type='MODIFIERS')

can see how this could be made into a little helper method, simply pass it context and the target and source object.


How to move an element symmetrically in edit mode

Perhaps the simplest and most surefire way is create a mirror modifier.
Split your object down the middle in Edit Mode by pressing Ctrl + r to generate a new edge loop going all the way around the object at its center. After activating this shortcut, float your cursor a bit along a horizontal edge near the top or bottom center of your object until you see a vertical division appear which snaps to the centerline of the object. Then left-click immediately afterwards one single time to commit to that division, then right-click one single time to cancel any further mode actions, which will then commit to this edit.
Now remove half of your model. Box select the half to be removed. Do this in an orthographic, wireframe front view, to make sure you don't miss any of the desired parts. Also do it with Face Selection mode active (so that you are sure to select faces and not edges or vertices). Then delete these faces so that only half of your model remains.
Finally, create a mirror modifier from the modifier tab (wrench icon) in the Properties Panel. Assuming your object's pivot center is properly aligned with the cut you made (which it typically will be by default), the mirrored half will be positioned correctly in relation to the original half, without the need for further settings changes. The mirrored half will perfectly mimic the other half whenever you tweak it in Edit mode.
When you are done modeling, you should probably apply the mirror modifier, which will make the mirrored results permanent, and give you two proper sides to the object afterwards. Note that you cannot do this apply function while still in Edit mode.


Playback skips and plays frames slowly with new audio?

Make sure that you have enabled AV Sync in the timeline window (different from VSE window)

This will tell Blender to skip video frames in order to play at the project frame rate.


Quick and Precise Angle Measurement in Blender?

When in edit mode  press N and then select Mesh display> angle.
Then take a vertex and move it.


How to align all vertices so that they would be lying on one plane?

Couple of ways you could do this:

Method 1

Select your face
Change the 'Transform Orientation' to 'Normal'

Hit 'S' to scale
Double-hit 'Z' to scale along the face's normal
Type 0
Hit enter

Method 2

Add a new plane (single face)
Rotate it as desired to define your belonged normal axis
Again change your Transformation Orientation to Normal
Create your custom orientation in the right-3dview-panel

Rename it and use it in the same way as 'Method 1'


Is there a way to change the emission number of a particle system, without affecting the emission number of the mesh it's separated from?

Your solution is really a solution; it's not a workaround.

The reason you can't change one without changing the other is because they are the same particle system, just used in two different places. This is just like when you use the same material in two different places; when you change the color of one, it changes in both places.

Deleting the particle system and making a new one with new settings is one way to "unlink" the two. Another way is to make the second particle system a "single user copy." Do this by clicking the number that's next to the name of the particle system. This will keep all of the original settings, but make it into a separate system so that you can change it's settings without affecting the other one.

I hope that helps!


Solution without drivers:
What about using a curve to define the length of your array ? You could then hook the last control point of your curve to your ObjRight. The solution isn't perfect as you would have a space between the OjRight and the Endcap but with a proper set up you could mask the problem (moving the ObjRight with fix increments snap to the grid for example).

Solution with drivers:
This solution (probably the best) would be to drive the ObjRight location (or an empty that you can use as a parent for ObjRight) by the array count.

Hope it makes sens. Let me know if you need clarification.


How can i enable composite node in python?

Set active node

Similarly to Set active image node with python

In the python console

C = bpy.context
D = bpy.data

>>> node = C.scene.node_tree.nodes['Composite']
>>> node.select = True
>>> C.scene.node_tree.nodes.active = node
>>>


I had proportional editing on. I didn't realize that had any effect in object mode!


weird white reflection in my glossy material

How do you know if an object is shiny? Because other things are reflected on the surface...

What things?

Whatever is in the environment. If there is a sun in the image used as environment or if there is a light on the scene you can expect it to be reflected on the surface.

Read: Why does an object with a glossy shader render in black?


How do I make the mat_name = all the materials on an object?

I think you are getting too focused on the details and need to evaluate the overall goal. Sounds like you want to do:
Premise:
Given an object
if no material assigned create new material
For each material in material_slots
ensure use_nodes = True
Add shader node 'ShaderNodeTexImage'
Set node location (0,0)
import bpy

ob = bpy.context.object

def add_image_node(ob):
    if not ob.material_slots:
        ob.data.materials.append(bpy.data.materials.new(ob.name))
    for mat in ob.data.materials:
        mat.use_nodes = True
        my_node = mat.node_tree.nodes.new('ShaderNodeTexImage')
        my_node.location = (0,0)

add_image_node(ob)

In which case he only name used is when creating a new material.
Edit added alternative code including linking example and some potential issues identified in comments to consider for your specific goals.
import bpy

ob = bpy.context.object

def link_texture(mat, nd_from, nd_to, ip_socket, op_socket):
    mat.node_tree.links.new(nd_to.inputs[ip_socket], nd_from.outputs[op_socket])

def add_texture_node(mat):
    tex_node = mat.node_tree.nodes.new('ShaderNodeTexImage')
    tex_node.location = (0,0)
    return tex_node

def add_mat_by_slot(ob):
    if not ob.material_slots:
        bpy.ops.object.material_slot_add()
    for slot in ob.material_slots:
        if not slot.material:
            new_mat = bpy.data.materials.new(ob.name)
            slot.material = new_mat
        slot.material.use_nodes = True
        # should there be a check before adding to prevent duplicates?
        if 'Image Texture' not in slot.material.node_tree.nodes:
            my_node = add_texture_node(slot.material)
        else:
            # reference existing node
            my_node = slot.material.node_tree.nodes['Image Texture']

        # potentially more than one bsdf which to connect to or all
        nds_to = [nd for nd in slot.material.node_tree.nodes if nd.type == 'BSDF_PRINCIPLED']

        # convenience variables to choose sockets by name
        ip_sock = "Base Color"
        op_sock = "Color"

        for nd in nds_to:
            # do you want to skip if link already exists to avoid over writing?
            if nd.inputs[ip_sock].links:
                continue
            link_texture(slot.material, my_node, nd, ip_sock, op_sock)

add_mat_by_slot(ob)


Boolean not working for 2 objects, not sure why. Tried many things as suggested on tutorial sites

Blender 2.91 and 2.92alpha
Problem is solved as it uses a more accurate boolean


What is the difference between matrix_basis and matrix_world?

matrix_basis is the 'input' matrix, so it's the thing that you set as the 3D artist, so it's relative to the object's parent. matrix_world is the 'evaluated' matrix, so it basically is matrix_basis with all the constraints applied and is multiplied by all the parent matrices (so it's in world coordinates).


Connect sculpted sub-terrain to create tunnels?

You may do it deleting some vertices for both sculpted elements and join them using faces (with the bridge tool or F2 e.g.), then resculpt the joint, but it may be time consuming. I recommend you to use a Direct Union option of a BoolTool add on.

Activate it in User Preferences (Ctrl+Alt+U).

In Edit Mode select a fragment of your element and separate it with P-->Selection.

Enter Sculpt Mode and join elements using Snake Hook brush e.g.

In Object Mode select both separated objects and press Shift+Ctrl+Num+ (or press Spacebar and type 'direct').

It'll merge your sculpted mesh, so it'll be ready for sculpting. Then you can smooth the joint's transition using Smooth brush e.g. and sculpt some detail there.


No, the conversion its self will be scan-filled (like the image you show), however you can cleanup the mesh after.

For more even distribution: Select the faces that have ugly tessellation. Select the menu item Mesh -> Faces -> Beautify Fill.
To remove redundant edges (and get an ngon), select the face area. Select the menu item Mesh -> Delete -> Limited Dissolve. set the angle very low to avoid loosing details of the shape, this will give you an ngon.


Ok.. there was no relation in the scene. The problem was that I somehow enabled the 'Proportional editing object mode' (Shortcut: O). I did not know this option in object mode. Thank you for the answers and sorry wasting your time.
It still do not get why objects that are closer to 'Body' did not move but only 'Border'...


For Blender Cycles

Go to the materials tab, create a new material, where it says diffuse click and press glossy BSDF. Set the roughness to ~0.

 For Blender Internal

Go to the materials tab, create a new material, tick the mirror box and set reflectivity to 1 or a high number.

This is for the most basic mirror which just reflects. To make a more complicated one, learn a bit more about materials for Blender Internal and for Cycles learn about the types of shaders and the mix node.


Incompatible operator return when checking animation data

Okay, I forgot that if you use  self.report({'ERROR'}, 'There is no animation'), you must add return {'CANCELLED'}.


For some reason I cant move this bezier curve on the y axis

Your curve is scaled to zero on the y axis.

The quickest way to solve that is to apply scaling for the object, wich will reset the scaling to 1 – with the curve keeping its shape of course.

To do that, go into object mode, hit Ctrl+A and select either Apply Rotation & Scale or Apply Scale


Shrinkwrap or Boolean for die stamp template

Avoid booleans, avoid shinkwrap, one will give you headaches with bad topology, the other will yield Z-fighting problems...
Use Instancing:
Create your basic shape.

Add a cube.

Select the cube, and select Instancing->Faces.

Deselect the cube and select your shape. With the shape still selected press and hold Shift, and select the cube.
Press Ctrl+P to parent the shape to the cube. Select "Parent to Object"
.

A cube with the basic shape on every face  will be created.

Then press Ctrl+A and select "Make Instances Real".

At that point you can go ahead and delete the cube.
The instances will become different objects but you can join them. Select all of them and pres Ctrl+J.


Add armor to the body without long weight paint

Enter edit mode, select one vertex of the armor, shift select a vertex of the other piece of the armor, Ctrl L to select all linked vertices, in the vertex group tab click assign with a weight of 1.0.

Another workflow: select a vertex from the body, Ctrl L to select all linked, H to hide the body, switch to weight paint mode and do all the paints you need (Face selection mode must be on, with all the vertices selected), Alt H to make the body reappear.


Capture video from cameras in blender game engine for Artificial Intelligence

I found the answer!

Thanks ThaTimst3r for his video on YouTube: /watch?v=e4KNstJhFeA&index=1&list=LLNnIYCXmFzdsaND3RsqYSdA

We need to add two planes which we will use for our "screens". These screens need different textures. So, we need to link the materials of screens and cameras. For this purpose, in each screen, we create two properties: the material and the camera.

The values of properties have to be the same as name of material and name of camera respectively.

Next, in our code we will link them:

camera_name = obj['camera_property']

and

matID = texture.materialID(obj, 'MA'+obj['material_property'])

Let's render texure from camera:

renderToTexture = texture.Texture(obj, matID)
renderToTexture.source = texture.ImageRender(scene, cam)

So, final we have the effect what we need. We can even set the resolution of images:

enderToTexture.source.capsize = [500, 500]

And convert images to arrays:

imageArray = texture.imageToArray(renderToTexture.source, 'RGB')

Thats all, I think.

If you have comments, I will listen them with pleasure =)

All source files.


How to make search folder script in add-on preference?

The example given is just a regular StringProperty added to the AddonPreferences. Notice that the subtype of the StringProperty is set to DIR_PATH:

import bpy
from bpy.types import Operator, AddonPreferences
from bpy.props import StringProperty, IntProperty

class ExampleAddonPreferences(AddonPreferences):
    bl_idname = __name__

    filepath: StringProperty(
        name="Example File Path",
        subtype='DIR_PATH')

    number: IntProperty(
        name="Example Number",
        default=4)

    def draw(self, context):
        self.layout.label(text="This is a preferences view for our add-on")
        self.layout.prop(self, "filepath")
        self.layout.prop(self, "number")

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

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

if __name__ == "__main__":
    register()

Further reading

AddonPreferences in the Docs
How to create a Folder Dialog?
How to create a custom UI?


The transform coordinates are referred to the world coordinates, expressed in Blender Units, while the UV coordinates are expressed in pixels, with 0,0 left bottom corner, and 256 x 256 as default (size changes according to a selected image in the UV/Image window), so it doesn't make sense try to match the two values. If you want to mantain the shape use a square texture and select "project from view" as UV Unwrap algorithm.

A workaround can be using your texture as reference, create a "cage" with the dimensions of the texture, then inset the face you need, choose Unwrap "project from view (bounds), then delete the faces you don't need.


Is it possible or desireable to allow a color to be assigned to vertex groups in edit mode

Edit Mode. Show Weights. In the panel
Consider hiding vertices from the menu choices.
Consider hiding vertices with a Mask Modifier


No, the viewport lens only effects the viewport when you are not in camera mode.
Yes, that's the idea.
Add a new camera to the scene. Shift + A -> Camera. Delete the camera. Now, select your original camera and go to the Object Data tab and change the Camera Data to the new camera's data (which is the default).


How do I make the domain bake the fluid object?

This is because of the fluid quality.
Working with higher resolutions and some other settings that I will explain can help you enjoy a much smoother and more realistic fluid simulation with Blender's fluid simulator.
Here are a few tricks:

1) Use subdividing on the domain AFTER baking the simulation. This will smooth out your simulation and fake the look of a high quality simulation on quality 120. It will not entirely work without-

2) Using surface smoothing. Adding a high level of surface smoothing actually improves your simulation by a ton when combined with a little bit of subdividing. Settings for this here:

Do not use the subdivision setting here or else baking will really be a time problem.

3) Setting fluid viscosity. Adjusting the viscosity of water just a very tiny bit will actually improve the simulation if you set it to be slightly more fluid-like.

4)Set the time on the fluid simulation accurately. Having correct timing and speed is a big factor in realistic fluid animations because without the correct time starting and stopping your simulation will be slower than real water. To correctly set this you must set the start time to zero, or if you want to start your simulation at frame 48 you must set it to 48/the framerate of your animation. Now set the end time to the length (in frames) divided by the framerate.

5) If you decide to make a very high quality fluid simulation (and have the hardware to do so), uncheck the remove air bubbles box. This will add a more real look to the simulation by adding small bubbles near the edges of the fluid, and where the inflow adds fluid. Here's a pic:

I hope these settings help you!


Here is the materials tab:

Note:
If you can't see it there, hover over the tabs and scroll with the Middle Mouse Button.

Also be sure that you have a mesh selected, if you don't blender will not show the materials tab.

Almost any video tutorial should show you were that is, so I'd recommend you research some more.


Problem appending a Node Group in Blender 2.71

I found the solution to the issue.
I was trying to add the node group in shader mode, and not in Composite mode, as I should be.
I thought I had set it to Composite, but I guess I hadn't. As soon as I changed to Composite mode in the Node Editor, everything worked as expected.


In 2.8 it is called Falloff in the Brush options.


How to get accurate colors with Filmic Blender

Cegaton has wisely hinted at the root of the discussion, which is that the framing and definition as to what is an accurate colour is a cause for much confusion and much misunderstanding. This is an answer that is long due in coming, and hopefully it will help elucidate some of the core concepts behind colour that might help in ascertaining a fleshed out solution.
This answer will not cover the complex notions behind albedos and other rendering nuances that are a part of this massive question.
What is a colour in a three light encoding model?
It is crucial to identify some sort of ground truth when discussing colour. Without getting into the nitty gritty colour science stuffs, we need two bits of knowledge to ground ourselves:

RGB is a relative encoding model.
All colour is anchored in the CIE 1931 experiment and model known as XYZ.

The former means that without utilizing the latter, the values in an RGB triplet are meaningless. The latter is our means of discussing colour accurately and scientifically. You can think of the CIE XYZ model as nothing more complex than another three light system, but with a concrete, scientific and absolute reference point. Where three random RGB values with no metadata are meaningless, three XYZ values are always well defined and absolute.
Harnessing the power of the XYZ model allows us to take the relative values from some well defined RGB triplet and convert those into meaningful values across all colour spaces.
How does a colour become unique in an RGB system?
A colour is defined by defining an intensity value for each of the three colours of the three basis lights. That is, each of the red, green, and blue basis primary lights have clearly defined and unique colours relative to CIE XYZ. A few rules of thumb apply to these basis primary "flashlights":

They never change their absolute defined colours relative to the CIE XYZ model, only intensity.
The range of colours that can be mixed is defined by ratios of these three basis primaries.
Bit depth does not change the colours of those basis flashlights.
Physical hardware determines the colours of those basis flashlights when dealing with the physical domain.

Key takeaways:

Ratios of the three basis primary lights are what defines a colour.
Basis primary lights aren't subtly different for different colour spaces, but rather radically different in both hue and saturation to borrow common application terms.

What is a colour in Blender?
In Blender, the internal reference space is configured via the OpenColorIO configuration. By default, it is based on REC.709 lights. REC.709 is a specification that clearly defines three primary light colours. This is the same colour of basis primaries that are referenced in the sRGB specification, and also very likely the colours of lights in the pixels that one looks at when looking at commodity display hardware. Modern televisions, Apple devices since 2015, digital cinema projectors, and a number of other more contemporary devices do not use the same coloured primaries.
When you render with Cycles, using Filmic or the "default" transforms, the internal reference primaries are always REC.709, as implemented via the OpenColorIO configuration.
Why do some colours look different when rendered under Cycles versus the "default" transformation if the reference primaries are identical?
Here is where we get into the complexities as to how a view transformation will alter the visual output on identical data. Consider the following display referred images. These were all "rendered" from identical scene referred starting points. That is, the underlying scene referred data was identical in all cases, and only the view transform was changed.

Note that in the above images, the two view transforms used were Filmic and "Default", which is the sRGB OETF.
Obviously there are clear differences in the dynamic ranges addressed within the encoded GIFs. But look closely at the actual colours in the imagery. What you'll see is that two colours, despite being generated from the original values, are entirely different.
If we look at the mountain GIF, we can clearly see:

The sky blue in the Filmic version is much more cyan in the sRGB OETF version.
The trees are blowing out to a pure yellow under the display referred sRGB OETF transform.
The colourful stained glass is losing the intended ratios across a range of colours under the sRGB OETF transform.

Why do colours look so different when comparing Filmic to the sRGB OETF variant?
If we remember above, we learn that what defines a colour is the ratio between the channels. For example, a pure REC.709 red primary would be expressed as 0.01, 0.0, 0.0 or 123123.34, 0.0, 0.0 or 0.8938, 0.0, 0.0. In all three examples above, the resultant output, although differing in intensity, would always have precisely the same colour. In colour science terms, we could say that the colours above would have identical chromaticities. Again, as per above, this means that the colour the values referenced are absolutely identical in terms of chromaticity according to the CIE 1931 XYZ model.
So what is happening in these sample images? Why are the colours so different?
The sRGB OETF is a hard cut view transform that was never designed for rendering. Ray tracing engines generate scene referred, zero to infinity values. This is the same value range according to HDRIs and other scene referred image encodes.
When we consider that the blue in the mountain range GIF is a ratio of the three primary light channels, we begin to see the problem; the sRGB OETF isn't showing you anything even remotely close to the intended colour. That is, if we consider the ratios between the scene referred source data, and the ratios expressed in the display referred output, the resultant colour (again, chromaticity) bears little to no semblance to the intention expressed in the original ratios.
Here's a simple image to demonstrate why:

The above image ignores the complexities of the transformation from the scene referred to display referred model, and instead provides the values as 0.0 to 1.0 on an aligned scale.
While some folks erroneously think the above differences are purely a saturation issue, the effects are actually much deeper. While the ratios are purely a fictional example for a single pixel, one can get a clear idea why the output ratios under the sRGB OETF are inappropriate and entirely inaccurate for a scene referred image. The original intention of the ratio expressed by the REC.709 primary lights is entirely incorrectly expressed.
The colours are completely wrong in the sRGB OETF version.
Once we realize that a colour in a three light system is a byproduct of the ratios of the three lights, we can understand what a correct colour is. In the above examples, a default hard cut will distort the ratios of the intended colours, leaving incorrect colours displayed. The cyan in the sky of the mountains? Incorrect colour ratios. The yellows in the leaves of the background trees in the tree image? Incorrect colour ratios. The magenta and reds in the stained glass? Incorrect colour ratios.
What most folks have been looking at all along via the default transform isn't "more saturated", isn't "more accurate", but plain and simply incorrect colour ratios that have long since lost the intention of the original ratios.
Moving forward
Filmic tries to get a closer representation of the original intention of the scene referred ratios. It does so in a manner that is much more close to what the intention of the original values are. That said, there is further room to improve on the result using more complex colour models and colour science. Hopefully the next iteration will demonstrate this, as well as other fancy and interesting things such as wider gamut rendering etc.
It is hoped that this answer isn't too sufficiently complex for a casual reader, and that the information provided herein makes enough sense to help folks use better language when discussing colour, as well as explain some of the qualia differences between their render versions.
It takes a village.


Rotate the curve till is coplanar with global X-Y plane.

Than apply Rotation by pressing Ctrl+A.

Now you can set the curve to 2D.


In object mode press W -> clear all restricted render. That will make all objects visible in the render. Also you can select and object and hit Ctrl+Alt+H to unrestrict render on the selected object. If there are objects that you have that you do not want rendered you can click the camera button next to the objects name in the outliner which is usually the top right window. This toggles camera visibility.
Version 2.80+ : Press F3 to bring in the search operator  and type clear all restrict render.


Make sure you export the mesh with rig rather that exporting them separately. Also in general make sure you've applies your rotation and scale etc and make sure mesh to rig parenting has been set up properly.


The difference between a parented bone with and without offset is that when using keep offset the two bones don't join together, they just follow the same rules as object parenting.

In the bone properties this is represented by the connected property.

Enabling or disabling the Connected property is the difference between choosing connected or keep offset when setting a parent.

Simply enabling connected will rejoin the two bones as if you had chosen connected to start with.

Unfortunately when enabling connected, the base of the child bone snaps to the parent bone and there is no record of the location used before enabling connected. So if you enable connected, unless you undo at the time you will need to manually place the end of the bone back at the position you want it.


How can I take these two meshes and properly mold them together proportionately like the reciever of a gun?

Now that I understand your goal, and I tested it, I think I found what you want.
Start with a cube scaled the way you need to have the top face be your rect. Then add a low poly cylinder on top. It's key to make sure that the cylinder is more than halfway submerged in the stretched cube, as this will create a better transition later on.

Add the boolean modifier to that cube, then select the cylinder as the object and set the operation to union. I found that it is necessary to apply this modifier after this.

After deleting or hiding the original cylinder, you might find there is an error with the polygons that make up the remaining rectangle. I found that on one side, the corner vertices were not properly connected, resulting in a u-shaped ngon. I fixed it by deleting that face, and selecting the edges I wanted, then pressing the F key to bridge them.

Add the subdivision modifier, and you get something I'm sure was not your intended shape. If it looks like this, you can rest assured we can control this.
Go into edit mode, and click button on the subdivision modifier to show the results in edit mode.
Select the edges of the top face of the box, and the vertical edges (Like a stick figure table). With all those edges selected, press Shift-E, and then pull the mouse away from it's starting point until the edges turn fully red. The result should look like this.
Creases won't help with the ends though. Creases are a less expensive way of controlling the smoothness, but the ends will require a more old-fashioned approach, known as control loops. While still in edit mode, create a loop with Ctrl-R. Click once while it is the center, then  you can drag the loop around, so drag it close to the end to tighten up the transition and click again.

I hope this is the actual result you were looking for, but if not, it was fun practice on better stack answering.


how can we remove the blurry effect that has been caused by denoising?

Denoisers are an imperfect, but useful tool.
I have this scene where there's light coming in through a window and I've given the room a volume to catch the light.  If we run a low amount of samples you can see the fireflies produced.

This is normal, the nature of a volume with lower density is that it will only affect some rays cast from the camera.  The denoiser gives us this ugly result:

with only little wisps of dust visible.  This is also normal, because the denoiser can only work with the information we give it.  I only ran this at 12 samples, and it is really interesting that it can produce this result.
Usually the answer is to run more samples, but even at 300 samples it comes out as this:

Which is part of the way there.  I cranked a small region up to 1200 samples to turn this:

into this:

That's a lot of samples, but you can probably see from the noisy image that it would take many thousands of samples to render this volume in a realistic and pleasing way.  Volumes with lesser density are just very noisy.  The grass will be a lesser case of this, where more samples will give each pixel more influence over itself.
I did find in doing this that volumes aren't contributing to denoising normal or albedo, probably by design, but I wonder if it isn't related.

You may want to play with Adaptive Sampling instead, run some experiments with a render region.


As mentioned in the comment, use a file output node or connect your output to the composite node. It's important to make sure that you're telling Blender to use nodes, in the compositor windows make sure "use nodes" is checked.


I believe you are mistaking "lamp rig 10" for the actual light itself. This is only a mesh made of edges that acts as a parent to the light, making it easier to select. When you are duplicated the lamp, you only selected the lamp mesh and the lamp rig but not the actual light itself. Try going into wireframe mode and box-select (b) the lamp, which will include the actual light. Duplicating this should not have any problems.


Is it possible to set all characters in a text object to capital regardless of input?

In your script after you have created your text object and are in edit mode for it just run these two commands.

bpy.ops.font.select_all()
bpy.ops.font.case_set(case='UPPER')

That will convert all the characters in that text object to upper case, but leave it all selected.

If you want to have your text unselected (still in edit mode) run this command after the two above

bpy.ops.font.move(type='LINE_END')

Documentation on the font operators.

Here is an example script that uses the operators above to get a string from an external text file, convert it to all upper case, and make a new text object in.

import bpy
data = ""
with open('path/to/file.txt', 'r') as file:
    rawtext = file.read()
f.closed

bpy.ops.object.text_add(view_align=False, enter_editmode=True, location=(0.0, 0.0, 0.0), layers=(True, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
bpy.ops.font.delete(type='ALL')
bpy.ops.font.text_insert(text = rawtext, accent = False)
bpy.ops.font.select_all()
bpy.ops.font.case_set(case='UPPER')

bpy.ops.object.mode_set(mode='OBJECT', toggle=False)

This script gets a string from an external text file, converts it to all upper case, and makes a new text object in blender; same as the script above, however this one does not use ops which will have better performance.

import bpy

#get letters from file
file = open('path/to/file.txt')
rawtext = file.read()
file.close()

#create new text curve and object
curve = bpy.data.curves.new("curve", 'FONT')
text = bpy.data.objects.new("text", curve)

#add uppercase letters to text curve
curve.body = rawtext.upper()

#add text object to scene
bpy.context.scene.objects.link(text)


Things you can try to improve viewport performance:

Enable VBOs in User Preferences > System. This should speed up drawing of highly complex scenes with lots of geometry.
Enable Only Render under the display panel of the 3D viewport. This will hide extra lines and wireframes, which are slow to draw.
Disable Double Sided in the object properties editor for high polygon mesh. This is especially helpful on Fermi-level Nvidia cards.
Turn off modifiers you don't need in the viewport.
Use Simplify in the Scene property editor to globally reduce the complexity of the scene.
Make sure you are viewing the scene in Solid mode, it's typically faster than all the other mode, including wireframe.
If you are using physics simulations like particles or cloth, make sure they are baked. Otherwise, Blender will try to recalculate them every time you switch frames.


Tab into edit mode
Select and delete these interior faces

Select these verts and hit f to make them a face

Select these verts and hit f to make them a face

Select these verts and hit f to make them a face


How do I apply a texture to only 1 face?

I don't know how it worked in Blender 2.79. But if you want to add texture to a single face you have to go to Edit-Mode and then mark your face. Create a new material and klick on assign. (The Materials Pannel in 2.8 is on the right side of your Viewport.)

Now you should only have the marked face painted, you are able to add textures by pressing: Use Nodes (also in the Material Panel).

I hope my description works for you, if not let me know.

Greetings Sebbe


Why does Blender crash when I append this group?

[I am working on Windows but it was also crashing here.] You have an object called MiddleMirrorPipeHolder that is a child of ParabolicMirrors - but - you also use MiddleMirrorPipeHolder as the mirror object for ParabolicMirrors. I believe that is confusing Blender. Removing the parenting will allow you to append your model. I suggest you use an empty as mirror object.


Random keyframing polygon material indices

Code below run on a default cone with 4 materials of colour: red, green, blue, yellow.

Can set the frame in keyframe insert

All polygons are given material index 0 at frame 1

At the frame 2 times the polygon index plus 10 the polygon changes to a random choice of material slots with material.

Example script.
import bpy
from random import choice
context = bpy.context
ob = context.object
me = ob.data

choices = [i for i, s in enumerate(ob.material_slots)
        if s.material]

for p in me.polygons:
    p.material_index = 0
    p.keyframe_insert("material_index", frame=1)
    p.material_index = choice(choices)
    p.keyframe_insert("material_index", frame=2 * p.index + 10)

Using Drivers

It is a low level version of dynamic painting

In which case here is an example of using a driver instead of keyframing an fcurve.
Example below selects face index based on integer global distance of face center to emtpy.  Have left in test driver method with  test prints
The world matrices of the empty and the mesh object are added as driver variables, and passed to driver method by way of locals.
The image above is on a 16 x 16 grid, takes a while to run.  On my system a 100 x 100 grid works but takes a while and can get unresponsive.
Select the mesh object and run script.
import bpy

context = bpy.context
ob = context.object
me = ob.data

bpy.ops.object.empty_add()
mt = context.object

def add_driver(face):
    face.driver_remove("material_index")
    fcurve = face.driver_add("material_index")

    driver = fcurve.driver
    driver.use_self = True
    driver.expression = "x(self, locals())"
    var = driver.variables.new()
    var.name = "mw"
    var.targets[0].id = ob
    var.targets[0].data_path = "matrix_world"

    var = driver.variables.new()
    var.name = "emw"
    var.targets[0].id = mt
    var.targets[0].data_path = "matrix_world"

def x(self, locals):
    print(self)
    print(locals)
    mw = locals["mw"]
    emw = locals["emw"]
    d = (mw @ self.center - emw.translation).length
    return min(int(d), 5)

bpy.app.driver_namespace["x"] = x

for p in me.polygons:
    add_driver(p)

Related
This one randomly sets color of faces of a modified (eg subsurf) mesh using a frame change handler.
https://blender.stackexchange.com/a/183440/15543


Mirror not work correctly for stl imported file

By mirroring you don't get two different objects; it's still the same. The point on which your object is mirrored is not the 3D cursor but the origin of the object.

Change the Origin

If you want so set the origin to a specific point, mark the point with the 3D cursor, where you want to set it. Then hit Ctrl-Shift-Ctrl-C and click on Origin to 3D Cursor.

Alternative Way without changing the origin

One property of the Mirror modifier is called Mirror Object. Instead of mirroring the object at its own origin it will use the chosen object's.


I thought it may be easier if you saw a video so go to this link ... if this is not what you wanted let me know.

https://youtu.be/C31vVLQxWME


Is there a way to control the start and end of quick effects?

All of the simulations depend on the cache and have a control for start and end.


Automatic Weights not recalculating after moving Bone

I believe you should be in edit mode and not pose mode.

Suggestion. Manual weight painting is time costly.  If you have zero or or close to zero investment in manual weight painting then simply delete your existing [bone weight] work and start fresh to be time effective.  You have the luxury at the moment of discarding what might be a mistake rather than doing a sequence of recovery steps.

Simply assign automatic weights all over again.  That is 8 seconds of work. In your situation, the action of

Parent Armature with automatic weights Control-P

can be done many times since you are not losing time costly manual weight painting.

Please know that a large bone next to a small bone will have generally more influence except where the small bone is extremely close to the mesh.


Keyframes won't respond to 'Cycles' f-curve modifier

The Cycles f-curve modifier is working, but you have a keyframe on frame 4335 which is being included in the modifier. This means any repetitions of those keyframes are happening after frame 4335. If you zoom very far out after adding the modifier you can see that.

I presume you actually want that keyframe to be on frame 105 as that causes creates the same repeating pattern as the X Scale channel.


Rendering produces a completely transparent image with no objects

Start with pycoder's comment (I can't comment because I'm new to Stack Exchange).

Also check the camera's clipping settings. Select the camera, Properties Window > Camera Tab > Lens > Clipping. The values are blender's units and the default is 100 (way too short in many cases).


Is there an "easy" way to repeat geo for this practice project?

To make a set of boolean "cutter objects" that you can copy for the rest of your sword, first, make your base cutter object (I used a cylinder for the example), then use an Array Modifier to make multiple instances of the cutter object, a Curve Modifier to curve the array, and a (scaled) Empty, used as an object offset to scale the array along its length:


Script to make an empty enclose selected vertices

BMesh script.
Already had this one lying around,.. no need to use bounding box of either object or it be a requirement of empty.

Parent empty to object of interest, this way can work solely in local coordinates.
Find the two extrema of $x, y, z$ coordinates of selected vertices.  The inner diagonal of the bounding box.
Set the empty location to diagonal mid point.
Giving the empty display size of 0.5 makes it unit dimensions at unit scale  (1, 1, 1)
Scale it by diagonal vector.

Test script, run in edit mode.
import bpy
import bmesh
import numpy as np
from mathutils import Vector

from bpy import context

ob = context.edit_object
me = ob.data
bm = bmesh.from_edit_mesh(me)
x, y, z = np.array([v.co for v in bm.verts if v.select]).T

mt = bpy.data.objects.new("MT_BBox", None)
mt.empty_display_type = 'CUBE'
mt.parent = ob
mt.empty_display_size = 0.5 # unit
minp = Vector((x.min(), y.min(), z.min()))
maxp = Vector((x.max(), y.max(), z.max()))

mt.location =  (minp + maxp) / 2
mt.scale = maxp - minp
context.collection.objects.link(mt)

Un-parented local axis aligned bbox in world space.
To give the bounding box global coordinates, instead use above to make a local matrix and transform it by its parents world matrix, picking up from commenting out set parent (and from mathutils import Vector, Matrix)
#mt.parent = ob
mt.empty_display_size = 0.5 # unit
mw = ob.matrix_world
minp = Vector((x.min(), y.min(), z.min()))
maxp = Vector((x.max(), y.max(), z.max()))

L = (
    Matrix.Translation((minp + maxp) / 2) @
    Matrix.Diagonal(maxp - minp).to_4x4()
    )

mt.matrix_world = mw @ L

context.collection.objects.link(mt)

And finally a world axis  aligned bounding box
mw = ob.matrix_world
x, y, z = np.array([mw @ v.co for v in bm.verts if v.select]).T

mt = bpy.data.objects.new("MT_BBox", None)
mt.empty_display_type = 'CUBE'
#mt.parent = ob
mt.empty_display_size = 0.5 # unit

minp = Vector((x.min(), y.min(), z.min()))
maxp = Vector((x.max(), y.max(), z.max()))

mt.matrix_world = (
    Matrix.Translation((minp + maxp) / 2) @
    Matrix.Diagonal(maxp - minp).to_4x4()
    )

context.collection.objects.link(mt)


Partialy applying multiresolution modifier

Old question but still I know at least a work around for this.

If e.g. you want to get rid of the levels 1 to 3 and keep only 4 to 7 you can do this:

Duplicate model
Go to level of detail you want as lowest (e.g. 4)
Apply Modifier
Add new modifier and subdivide till you have the same subdivision as the original one (in this case subdivide 3 times)
Add a Shrinkwrap modifier and set both Meshes to the highest level
Apply Shrinkwrap modifier

Done.


When you move the bone 14 (upper arm), probably you are moving the forearm and hand bone also: check if there is some weight relative to theese other bones in your moving vertex.

Check also if the number you see in the vertex weight tab (0.000) is a true null value (maybe is 0.000024 which is not null).


How to add a parent to multiple disabled objects?

No need for Python, you can do it in the Outliner. Select all objects that you want to parent in the Outliner, then with Shift+LMB drag them onto the object which should be the parent.


Is it possible to project texture across object instances with Animation Nodes?

You can use fragment position as you texture coordinates as follows:

Alternatively, you can make the instances as a single object as follows:


Strange white faces only visible in weight paint? Invisible when ported into UE4

I've figured it out?!

For whatever reason choosing to open image, and bringing in the same texture I was using and reassigning my uv's to that fixed the problem.

The white faces have dissapeared.

Note:
I did delete faces previously and make new ones, which were where the polygons had turned white. I don't understand why this whole thing happened because of that though..


Take a look to logical operators.

position is deprecated use localPosition and worldPosition.

from bge import logic
cont = logic.getCurrentController()
own = cont.owner

own.applyMovement((0.2,0,0),True)

pos = own.worldPosition
x = pos[0]
y = pos[1]
z = pos[2]

print(x)
print(y)
print(z)

if x >= 10:
    own.applyMovement((0,0,5),True)


Is it possible to convert a procedural texture into actual geometry?

Particle is a nice idea to do this, and it is possible to control the volumetric density by procedual texture:

Demo file

Edit:

As MarcClinton mentioned in comment, a nice addon called MSMesher can be a relatively nice solution:

The result looks similar to metaballs, which means, to generate a sharper shape, further remeshing would be considered.


You have enabled Interpolated children in the particle settings, which means every sprinkle will spawn new sprinkles. If you set children to None and activate Show Emitter to render both sprinkles and the icing it will look just like in the viewport.


Parenting - Only the children moves when I move the parent and the parent stays still

This can happen when you transform only Origins.
Parented object (children) are bound to the object's origin, not geometry.

Example: Cube as parent, Suzanne as child.


Opened blender file, lost objects new to blender

I think you are in the Image Editor.

Press Esc or click on this small button a drop down and select 3D View:


Graphics glitch affecting entire Blender window

This solved the issue for me:

from File > User Preferences > System, set "Window Draw Method" to Full


Unfortunately your integrated graphics card doesn't fulfill the requirements for GPU rendering in Blender 2.8x. You would either need a

Nvidia graphics card with CUDA compute capability 3.0 or higher
AMD graphics card from GCN second generation or later

  CUDA

  CUDA requires graphics cards with compute capability 3.0 and higher. To make sure your GPU is supported, see the list of Nvidia graphics cards with the compute capabilities and supported graphics cards. CUDA GPU rendering is supported on Windows, macOS, and Linux.

  AMD

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

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


Below is another way of doing it using drivers.

For canvas to have rotation option, we can use driver for 'y rotation' on an empty object and parent it with Grease-pencil object. This video shows the functionality of it but doesn't show how to do it. There are steps written in description of the video but I found it difficult to follow.

Below are steps to do make the canvas rotate and we not have to move out of the 'draw' mode and the driver would be available by pressing 'N' on keyboard.

Step 1: Create a new file using '2D Animation' workflow from the splash screen of the application.

Step 2: Go to object mode using the mode-change tool at the top-left of the screen. We can also use ctrl+tab to bring the mode-change pie menu and then drag the cursor to desired mode.

Step 3: Press Shift+A and create a new 'empty' object. we used the circle shape because the depicts a actual animation disk.

Also, rotate the circle 90 degrees on x-axis if you used a regular mesh instead of an empty.

Step 4: Press N on the keyboard to open the 'Transform' panel and then right click over the 'y rotation' to add a new driver.

Step 5: After adding the driver to 'Y rotation'. Open the 'Driver Editor' window using right clicking on 'y rotation'. Click on (X) button as shown in the second picture below and choose 'single property'.

Step 6: link the grease pencil object in driver editor under single property.

Step 7: create a custom property for the GP object with following property:
 -  Property Name = Anim Disk
 -  Property value =   0
 -  Min value =    -360
 -  Max value =    360

Step 8: Copy the data path of the created property. Paste the copied 'data path' in driver editor for the 'empty circle'

Step 9: Parent the GP object to the 'empty object'.

Now you can rotate the panel by pressing 'N' on keyboard and then changing the value of 'Anim Disk'


In camera view press Home key on keyboard.
Keyboards without Home key can press fn+←.
This is a shortcut for command Frame Camera Bounds and can be found from View menu under Cameras.


How to Combine Two Animations with Different Y Locations

Let say you want animation A to go from point Y = 0 to Y = 1 from frame 0 to 19, and animation B to stay at point Y = 1 from frame 20 to 40.

You could parent your object to an empty that will stay still from 0 to 19, then at frame 20 move at Y = 1.
If you're talking about an armature, in Object mode, you could keyframe the object at frame 0 and 19, then at frame 20, keyframe it at Y = 1 so that it corrects the animation B location.
Again for an armature move animation B's root's location (+ 1 to Y location) or its bones locations (in the Graph Editor select the Y location curve and give it +1).
And you could do it with the Delta Transform values:

Open the Properties panel > Object > Transform > Delta Transform > Delta Location. You will tweak these values in order to change the object's 0 global location.

At frame 0 create a keyframe with X/Y/Z = 0/0/0. Duplicate this keyframe and put it at frame 19.

At frame 20 create a keyframe with X/Y/Z = 0/1/0.

When your object will arrive at frame 20, animation B begins and it should come back to 0, but the Delta Transform forces it to go to Y = 1. Therefore you won't see the object jump back to 0.

You can fix your particular case with the root's position. As you didn't change its position it would still make your armature position move whatever you do, so:

First your armature and animation are super messy, but let's ignore this. Find your root bone, you can find it in the Outliner, it's called b_C_Base, select it in the Outliner, switch your armature to Edit mode:

It's a very small bone so you can't see it, scale it. Now switch to Pose mode. You can see its position on the Z armature local position at frame 90, copy it.

Go to frame 116, when the animation is supposed to stop, you can see that the bone is set to back to its 0 position.

Paste the Z position you've copied, it will move the whole armature to the good position. Create a keyframe with i, it works.


I already found out the answer. The proportional editing needs to be turned off.


I'm not sure this means the same as color temperature: in the Scenes's properties is a checkbox Use Curves

The release notes only mention

  RGB Curves Curves to control image colors before color space
  conversion.

http://wiki.blender.org/index.php/User:Sobotka/Color_Management


This happens due to the n-gon face on top of the head of your figure. They don't subdivide well, so you get some kind of wavy surface.
To avoid this, you should try to keep quads (faces with four vertices) wherever possible.

That means that you shoud put some additional edge loops there, e.g. like that:

What I did was extruding the top face and scaling it down, then repeating the same thing, so that the inevitable transition from quads to one ngon happens in the small area in the middle.

Cheers


While an armature has not been adjusted in pose mode the object it deforms can be moved without being deformed. Once an armature has been moved in pose mode and the object is moved in object mode without the armature some weird deformation can happen. This is caused by the way the armature and object are linked together.

Once an object and armature have been linked, they need to move together as one. Normally the armature will be the parent of the object and should be moved in object or pose mode to relocate the object.


Go into edit mode after you create the object from text, select all with A and use CtrlT to triangulate. Alternatively, when exporting to obj, there is an option to triangulate on export in the tool shelf.


Ways to create a cylindrical shell (annular volume)?

You can create a cylinder and apply a solidify modifier..


Why is blender exporting face normals instead of vertex normals?


How to recreate 3D "pixel art" characters

A quick way to do it is to use the Remesh modifier / Blocks mode, here is what it gives with Suzan:


How to make more then one character from one rigged mesh

Adjusting a Rigify rig is not impossible but it's quite complicated, due to the presence of lots of machinary and auxiliary bones, that can be revealed turning on all the bone layers of the armature.

The best way to achieve your result is to adjust the metarig to the new copy of the character, and generate a new rig (change the name of the first rig before generating the second).

If you don't want to redo the wheights assignement, you can use all weight already present, just bear in mind that the new rig will have a new name, and you will have to set this new name in the object field of the armature modifier.


Blender API Python split body by loose parts

It seems like blender selected the last object in that list (the reason for that is likely because these meshes are imported in a piece of code infront of the code i posted) and i never actually selected the other meshes.

This code works for me and splits all bodies:

for collection in bpy.data.collections:
if collection.name == "Render":
    for object in collection.objects:
        print("Manipulating object: {}".format(object.name))

        object.select_set(True)
        # place at correct location and scale to the setting size
        object.scale = scale

        thickness = list(object.dimensions)[2]
        location = [0 ,0, thickness/1000]
        object.location = location
        object.rotation_euler = rotation

        # split the mesh
        if object.type == 'MESH':
            print("Splitting mesh")
            bpy.ops.mesh.separate(type='LOOSE')
        object.select_set(False)
    break # no need to check other collections


Weight painting doesn't work properly if bones are moved

The good news is your .blend file is fine. I had no trouble weight painting after changing the pose.

If, by any chance you didn't upload your latest version of your project, please make sure Pose Position is enabled, the Armature Modifier is turned on in the Modifier Tab and remove all keyframes or set keyframes for the current pose on the current frame.

I hope this was helpful to you.

On a side note: you should switch the Shading from Look Dev to Solid in Weight Paint Mode, otherwise the textures will make it harder to see the colors from your Weight Paint.


When you make looping animations, especially animations whose entire motion is procedural, you want to make sure that the first and last frames have the same keys, but also that the Handle Type for those keys is set to Vector. You can change these in the Curves window.
DO NOT TOUCH the vector handles;
Assuming that all handle types are Automatic and you did not adjust the bezier handles, when you convert them to Vector, they should already be flowing the same direction. (The tangents should be the same). If they are not (look at them, compare), you can manually adjust the vector handles or re-key the first and/or last keyframes.
Example of when to expect good results automatically:
A bobbing motion where cardinal (X,Y, and/or Z) position(s) is/are keyed. Suppose you key only one period. You will want 5 keys for the 4 distinguishable segments:
  x
 / \
x   x   x
     \ /
      x

the default interpolation ("Automatic") will create smooth bezier curves that work great in the middle but flatten out at the ends. Assuming this motion has its keys equally spaced and the average position is keyed, if you now select the first and last key and change the handle type to "Vector", their tangents will match and the motion will be seamless.
Also: Remember that the last frame needs to be excluded (since it is literally a copy of the first frame (yes, I see you do). This is done by setting the last frame value in the Timeline window to 1-less-than the frame the last key is on.


Yes. At the outliner panel, find blender File in the menu.

You will see then the current file listed along with other linked files. You can edit the path by clicking over it twice with the left mouse button, or using Ctrl+ left mouse over it.

You must rewrite the new access path yourself. Save and reload to apply the changes.
WARNING !! DO backup before you do this! If the linked file is not found, the result will be a broken file without the link. If you save again with that error, you will loose any reference (instances to that file) forever, forcing you to relink again.


Show/Hide object orientations in Blender 2.8?

In short: armature properties/viewport display/axes


Texture inside out (XNALara) .idk what im doing

Press F3 and search Flip Normals. If that doesn't work press Ctrl +  T while the image texture is selected in the Shader Editor. Try using object/generated coordinates.
You might also want to try applying the scale and location, and apply all geometry shifting modifiers like Solidify or Subdiv.
I am not an expert, that is just the troubleshooting procedure I would have tried based on my very high number of mistakes.


Can I use my two PC on my own network to Farm Render in Blender?

I was trying to find out if two computers in the same network could render in Cycles the same frame or only one instance using GPU Computed feature, and not an animation or several frames. In other words the GPUs to pick up tiles of the same frame. So far I noticed it's possible the computers to pick up different frames if it's an animation going, but not same frame.  Thank you.


Blender 2.8 : enter 'select box' mode while in transform mode

You need to configure key-map.
Find tool Select box, copy operator name view3d.select_box and paste it into "Tweak" sections of Grab, Scale ets (where you want to use it)

If tool haven't "Tweak" section, you can create it by pressing add new and copy settings from other one

In this gif, I don't use B or any outer keyboard buttons


uv unwrapping difficulties with a table leg

I think Mark Seam and Unwrap works pretty good, perhaps share your file + texture of this single object so that we can test


Applying high quality textures to a UV Map

There are some points to clarify first:

A « UV map » is a 2D projection of a 3D mesh. This is what you can see and manipulate in Blender's UV Editor and it's what's define how any 2D texture is applied onto your 3D model.
When you create a picture file out of that UV map, it's called a « UV layout », and really is only a picture of your UV map, not the UV map itself. It's like cooking your meal and taking a picture of your finished plate, it's only the photo of your plate, you won't eat that (I hope) but you might use it somewhere else.

I recommend using those words, to avoid confusion.

The reason to export a UV layout is usually in order to use it as a reference to create a picture file in some external software which suits your UV mapping.
It's necessary only if you need to take parts of a picture (or several pictures), move them around and fit them into pieces of UV. If you just want to apply a picture file without the need of such editing, you just have to plug your picture file in your shader.
The resolution of your UV layout doesn't really matter, it just has to be precise enough for you to see the limits of each UV island. You don't have to adapt your final picture resolution to your UV layout.

What does matter is the resolution of the picture you want to use in your shader. But also the ratio. As long as possible, use square pictures. Non-square pictures usually create unwanted deformations as the UV mapping format is a square and will conform any picture you plug in.

What you could do in your case, is either copy/pasting parts of your initial picture  under UV islands as you want and export the resulting picture alone. Or take your 2960x3000px picture and cut it down to 2960x2960px and save it as is.


There a couple of ways:

Tool shelf > Tools [tab] > Set Origin > Origin to Geometry or Origin to Center of Mass (which could be the same depending on your object)
You can move the 3D cursor to any point related to the object mesh. In edit mode, snap it to any point of the object mesh, or the mean point of any selection within the mesh, like this: Shift+S > Cursor to Selected or Active or Center.  Then tab back to object mode and as in #1 ... Set Origin > Origin to 3D Cursor


How to create an engine glow effect for spaceships in cycles?

There could be several ways to do this.

If you don't want to gent into full rendering just switch to Blender Internal rendering and create either a shadeless material or an emitting material and assign it to parts of your mesh. It wot actually emit light that can cast shadows on other objects but it will quickly simulate the effect.

You could also add some sort of "geometry plumes" if you want actual jet plumes coming out.

If you plan on using cycles or do real rendering add self illumination to the geometry to really light up the scene

Any further effects could be achieved through compositing or post production easily and non destructively


(I don't have the reputation to comment this: Powroupi's latest version of Blender MMD Tools works through version 2.90 (my version). Download it here.)
As mentioned by Kisracora, the plugin needs to be unzipped before the mmd_tools folder can be inserted into the addons folder. (If you're on Windows, you can simply enter the zip folder without unzipping and click-drag the mmd_tools folder in.) If doing that and enabling the plugin in Blender DOESN'T get it to show up, you may want to try rightclick > Properties > Unblock the zip (checkbox near the bottom of the Properties window).


Car model does not render after using motion tracking, but its visible in viewport

When you press "setup tracking scene" after solving the camera movement, blender creates two collections: a foreground (with a cube as reference) and a background (a plane to catch shadows).
You can safely delete the background one if you don't need a shadow catcher.
See: https://blender.stackexchange.com/a/108876/92768


Is there a shortcut to find an object in the outliner?

Hover over the outliner view and press Numpad .. This will move the view to show the object that is selected in the viewport. There is no shortcut if you are hovering over another region.


How to make voronoi move like living ants?

I don't think the Blender Voronoi has access to quite the same parameter as the one illustrated. Typical shader-Voronoi is based on the distances between randomly placed points, one to a cell, in a regular grid of rectangular cells. I think the specific 'wobble' effect you show is based on smoothly varying the positions of those points within the cells, without moving the cells.

Close enough, for this effect, might be to use the frame number to drive the Z component of 3D Voronoi, pushing the texture through our 2D XY slice. (The 'Flicker' path in the tree below.)

To drive a value in a shader node by frame number, just type #frame into the relevant field.

Having started, I couldn't resist following the rest of the instructions in your link:

With this sort of result:

I don't think it would be impossible to roll-your-own Voronoi, to give access to the noise generating the per-cell points.. or maybe there's a better way.