The following is my result with about 5 minutes of work. Note that I used Cycles Render, as it is much better for the scene showed in your question.

Modeling the Scene Minus the Berries

The key to this is Icospheres, which you can add using Shift + A > Mesh > Icosphere. Add an Icosphere. Key T to toggle open/close the Toolshelf and make sure there is only 1 subdivision.

I scaled all of my Icospheres down on the Z-Axis by a factor of 0.7 by keying S, then Z, then 0.7. I then rotated to Top Orthographic View through Numpad 7, then Numpad 5. From there, used Shift + D to duplicate, S to scale, and G to drag them around appropriately.

I also added an Icosphere of 1 subdivision, which I dragged behind the camera and out of view.

Lastly, I added a ground plane, scaled up just enough so that it fills the camera view.

Materials

The lone Icosphere behind the camera got a Diffuse BSDF with Hex: FF0000.

The bushes got a Diffuse BSDF with Hex: 57E746. Note that you can add the material to one bush, select all of the others, select the one with the material, key Ctrl + L, and select Materials to copy the materials from one bush to the rest.

The ground got a Diffuse BSDf with Hex: 296C27

Berries

Select one of the five Icospheres that should have berries on it. Go to the Properties panel > Particle Systems tab and add a new particle system. Use these settings, but note that Icosphere.010 should be the name of your red materialed Icosphere.

Select all of the bushes that should have berries, then select the one that you added the particle system to. Use this feature:

Lighting

Select the default Point lamp. Change to the following settings. Note that the Color: is Hex: FFFECC

Here is the .blend file:


Why is my fluid simulation mesh wireframe in solid view?

2.9 is using MantaFlow which is different from older versions.
Make sure you changed the type to modular, and turn on the resumable setting. Once you're done, bake the fluid simulation. The baked animation will show as a halo particle. Then, check the Mesh option and bake the mesh. You can mess with the resolution for better result.


Can you change the font in the Sequencer new Text Effect?

No, it's not possible to change the font on the Text effect as of 2.76. Here's a workaround


How to inset a curve into section of circle?

One way to obtain the result you want could be to select the edges in the mesh I selected in the image below and simply click on "Subdivide" in the Tools panel on the left. You should obtain something like the second image, which looks similar to the one you posted in the comments. Remember that you have to do this before using the array modifier, so either hide it by clicking on the eye icon in the modifier panel or delete it and make a new one from the beginning, after you obtained the result you want with the original mesh.


I cannot get correct scale on bevel for nurbs curve

I've just seen your blend file and i've found why you get this problem (and how to fix it) :)

Select your curve
Edit mode
Select All vertices
In the properties tab (N key), change the Mean Radius value (your actual value is 0.008) to 1.

That's all ;)


Base Mesh changes back to its original form after switching to object mode

Because your object has shapekeys, you have a shapekey selected and therefore you're changing this shapekey, you're not changing the original shape, which is on the top of your list and which is called Basis. If you want to make any change to the original shape, select this shapekey called Basis. If you want to save the shape you've created and make it the basis mesh, go into the dropdown menu on the right (down arrow) and select Move to Top. To make any shapekey appear in Object mode you need to tweak the Value, under the shapekey list.


What you need to do is shift+a go-to curve/circle. Then add an object to the scene.
give that object a particle system and leave it all at default other than the object

then select the circle and go-to Physics and add forcefield

change the type to curve guide

you should be good! If you assigned the object with the particle system to itself you just need to duplicate it. Moving the particle emitting object will change the orbit size around the circle.

This is what it looks like (as a png sequence)


You cannot select mirrored edges. To be able to do anything to the mirrored side, you must apply the modifier first, then go back to edit mode.

In 2.79 and before, the "On-clipping" function was not available, but in 2.80+, it allows you to select the mirrored side. It doesn't allow much editing though.


How to prevent blurry interpolation when scaling a texture?

If I had to guess, based only on what the texture output looks like in the window, I would look to see if there is any type of texture filter being applied such as Gaussian and the like that is going on somewhere around the texture to uv mapping area.


Copying a rigged object and having it use the same armature

Shift-D is the way to copy a specific object.


What is a good solution to store a json data in the code?

Only layout in the draw method.
Every time the UI is redrawn a new panel class is instanced and its draw method called. Hence the excessive number of reads.
If the data is not changing then can read once when the module is imported, or when registered.
Have added an example of reading the data in operator definition ,making the data an enum property of the operator, and using a generic layout to expand the operator enum.
import bpy,json,os,webbrowser
from bpy.props import EnumProperty

def open_json():
    json_file = "/home/batfinger/Desktop/json.json"
    f = open(json_file)
    data = json.load(f)
    f.close()
    return data

class HelloWorldPanel(bpy.types.Panel):
    """Creates a Panel in the Object properties window"""
    bl_label = "Hello World Panel"
    bl_idname = "OBJECT_PT_hello"
    bl_space_type = 'PROPERTIES'
    bl_region_type = 'WINDOW'
    bl_context = "object"

    def draw(self, context):
        layout = self.layout
        col=layout.column()
        col.operator_menu_enum("object.simple_operator", "site")

class SimpleOperator(bpy.types.Operator):
    """Tooltip"""
    bl_idname = "object.simple_operator"
    bl_label = "Simple Object Operator"
    data = open_json()['site_list']
    site: EnumProperty(
        items = [(site, site, address)
            for site, address in data.items()],
        name="Site",
        )

    def execute(self, context):

        webbrowser.open(self.data[self.site]) #Open web adress in the default browser

        return {'FINISHED'}

def register():
    bpy.utils.register_class(SimpleOperator)
    bpy.utils.register_class(HelloWorldPanel)

def unregister():
    bpy.utils.unregister_class(SimpleOperator)
    bpy.utils.unregister_class(HelloWorldPanel)

if __name__ == "__main__":
    register()

Example of layout using
        col.operator_enum(
            "object.simple_operator",
            "site")

If you are going to be using the data a lot would consider moving all the json in a separate module and expose the data on import.
from my_json_data import data


Why is the string property added to f-curve read-only

Assigning to Existing Classes
Custom properties can be added to any subclass of an ID, Bone and
PoseBone

Neither are bones, so leaving that aside, can see below ID is subclass of Object not FCurve, and as such is the property is not "wired up" as a property on the fcurve.
>>> issubclass(bpy.types.Object, (bpy.types.ID,))
True

>>> issubclass(bpy.types.FCurve, (bpy.types.ID,))
False

another test for this would be trying to assign ID properties to an instance.  This is how a non default value of a property is stored in blend file.
For example, for an Object type
>>> C.object["foo"] = 1

but not for an FCurve
>>> D.actions['CubeAction'].fcurves[0]
bpy.data.actions['CubeAction']...FCurve

>>> D.actions['CubeAction'].fcurves[0]["foo"] = 1
Traceback (most recent call last):
  File "<blender_console>", line 1, in <module>
TypeError: bpy_struct[key] = val: id properties not supported for this type


While rendering, after a few seconds my screen glitches out, then my computer BSOD's

I have found that when I have instant replay on and record desktop on in radeon settings, it crashes. If turned off, I have no issues at all. Thank you for your time.


Shortest path key makes edges freestyle instead

Here's a fix, I had same problem for  a while where shortest path edge select marked them as freestyle

Apparently I have changed some options on Edge Select mode and forgot. Hope this fixes it


The fastest way I can think of, is to go back to the program where you created the logo and make sure to have different paths/vectors for each of its parts. Then just export the SVG and import it in blender...


Is there a way to use logic operators in Blender Shader nodes?

I've spent the past week or so working on basic logic gate implementations in Blender Shader editor.
I'm sharing these with the community so anyone who would like to use similar nodes can easily find how to make and use them.
They allow for a little more advanced Shader Node behavior without having to resort to OSL or python scripting.

Here's an overview of the logic gate node groups I've made, along with a .blend file that contains all of them.

Download the .blend file here:

It contains all logic gates discussed in this topic, as well as an example of a 7-segment display and the logic that drives it. You may freely use the contents as you wish, though crediting this post and/or linking back to it would be appreciated.

To use the nodes in your files, open the file you need the nodes in and click File > Append, then open the above .blend file. Navigate to "Materials" and import the Logic Node Library material. This contains all nodes mentioned in this post.

Since the node groups are protected and named, you can add them to your Shader Editor by using Shift+A > Search and entering their names.

Preface

Every logic gate can be made from Not-And or Nand gates. (This also goes for NOR, but I'm not using those).

When implementing logic gates, you first need a Nand gate; with this gate you can make any other gate using solely Nand gates. Most of the gates in this answer are solely composed of Nand gates.

All node groups have inputs that are clamped to a range of 0 to 1. Due to how the Nand gate operates, any value greater than 0 is seen as a logic 1.
The Nand gate is also the only gate that utilizes an internal value that surpasses 1; they do binary math with decimal numbers.

The outputs are also clamped to a value between 0 and 1, this makes it easy to chain node groups without losing 'signal' quality.

The terminology I'm using, just for clarification:
1 indicates that the node outputs a True signal.
0 indicates that the node outputs a False signal.

All inputs are noted as capital letters. The output node is named O for most gates.

Outputs of Logic Gate Nodes can be fed into just about any node that accepts values. For instance, connecting the output to a Mix Shader Node fac input allows you to control which shader to use based on your logic. It's effectively a "switch" which allows you to switch between materials based on specific conditions.

The inputs of logic gates can manually be set, or controlled through keyframes.
Another possibility is to split a RGB color value into it's three component color channels and use either one of those values for logic input(since these are also ranged between 0 and 1).

If you have input values that exceed the 0 to 1 range, you can use a Map Range node to map the input range to the output range.

Basic Gates

In this section I'll describe the construction and operation of the four basic logic gates:
- Nand
- Not
- Or
- And

Nand

The Nand gate outputs a 1 unless both inputs are 1, then it outputs a 0.

This is implemented as follows;

Both inputs are fed through a Math > Ceil node which rounds the value up to the nearest integer. For 0 this would be 0, for anything between 0 and 1, this would be a 1.

These values are then added together using a Math > Add node, which results in an internal value which is denoted as X in the following truth table:

Truth table:

Nand
A  B  |  O  X
-------------
0  0  |  1  0
0  1  |  1  1
1  0  |  1  1
1  1  |  0  2

The X value is finally passed through a Math > Less Than node which outputs a 1 if the input is less than 2. If the value is 2 it will output a 0.
This node is clamped so the output value will never exceed the 0 - 1 range.

Considering every following gate consists of Nand gates that contain both input and output clamps, there is no need to further clamp these nodes.

 Or

On to the first compound gate(a gate made from other gates).
This gate outputs a 1 when either of its inputs, or both, are 1. If all inputs are 0, it'll output a 0.

Truth table:

Or
A  B  |  O
----------
0  0  |  0
0  1  |  1
1  0  |  1
1  1  |  1

The node group consists of three Nand gates:

Not

This node has a pretty simple effect; it inverts the input. Is the input a 1, then it'll output a 0 and vice versa.

It is constructed from one NAND gate with both inputs linked to the group input node.

Truth table:

Not
A  |  O
----------
0  |  1
1  |  0

And

Finally, the last basic logic gate(and perhaps one of the most useful ones): And.
This gate outputs a 1 only if both inputs are 1. Else, it'll output a 0.

Truth table:

And
A  B  |  O
----------
0  0  |  0
0  1  |  0
1  0  |  0
1  1  |  1

It consists of a Nand gate linked to a Not gate. Remember how Nand stands for Not-And? This gate effectively is Not-Not-And.

Other gates

With these four basic gates, you can construct gates that exhibit more complex behavior.
I'll describe three gates:
- Nor
- Xnor
- Xor

Nor

This gate is a bit like the opposite of an And gate; its output is only 1 if all inputs are 0. Else, the output is 0.

Truth table:

Nor
A  B  |  O
----------
0  0  |  1
0  1  |  0
1  0  |  0
1  1  |  0

This gate can be used as a last option for conditions; this gate activates only if none of the inputs are active.

It consists of an Or and a Not gate:

Xnor

The Xnor gate outputs a 1 if both inputs are equal. Are they different? Then it'll output a 0.

Truth table:

Nor
A  B  |  O
----------
0  0  |  1
0  1  |  0
1  0  |  0
1  1  |  1

It is constructed like so:

Xor

Finally, Xor is a gate that outputs a 1 only if both inputs are not equal. It's like the inverse of the Xnor gate.

Truth table:

Nor
A  B  |  O
----------
0  0  |  0
0  1  |  1
1  0  |  1
1  1  |  0

More complex components

In the Blender Shader engine I wouldn't expect things like binary adders and 7 segment drivers to be useful.
Singular gates operating on a few inputs are likely way more useful. I've implemented them anyway; since they're fairly complex I will not explain how they are constructed. Instead, see the attached .blend file for more information.

Included in this file are the previously named base gates, a few gates with multiple inputs (things like And with 4 inputs), adders(half, full and 4 bit) and some groups related to handling Blender's decimal numbers.

Here's a quick description of these gates:

The DecimalToBinary node group converts the value on a single input to a 4-bit binary value (0000 - 1111 or 0 - 15). Currently, this only actually supports numbers 0 - 9, since the 4th bit is needed to be able to count to 9. The values 10-15 are not used. I'll add this to the post as soon as I've found a solution for this.

The input value is passed through the DecToDigits node, which converts a singular value to 10 output values (Y0 - Y9).
These effectively convert a number to their digits; 4 would turn output Y4 on and leave the rest off, 8 turns Y8 on and leaves the others off, and so on.

These values are passed to the DigitToBin group which converts the digits to a 4-bit binary number (again, only 0-9 for now) using a fairly complicated node group.

In the .blend file I've also included a WIP 7-segment shader which controls a single digit based on the (keyframe-driven) input value, which is passed through the DecimalToBinary node group. Currently every digit has its own material to account for decimals and hundreds, tens, ones. I hope to find a better solution for this since every material on its own contains about 800 nodes.
The whole display encompasses about 4000 nodes!
This is also included as an example; choose Play Animation to see the display count up. This works best in Cycles render, though LookDev also works but is a lot less responsive.

In terms of performance, I haven't noticed any performance slowdowns when using a few of them here and there in my materials. In the 7-segment shader however, there are 4000 nodes in use which noticeably slows down animation speed to about 1 fps.

Again, if you only use a few of these nodes performance shouldn't be an issue.

In conclusion

Boolean logic is absolutely possible within Blender's Shader editor and may prove useful for making certain materials, like switching shaders or colors based on a keyframed value.
Things like binary computation are also possible, though that is not the focus of this post.

I'm sure people can find interesting applications of these nodes!
I will also add examples of the basic nodes later so you can see what they can be used for.


Using Cycles Render engine with AMD GPU crashes Blender 2.83.5

As it turns out, Radeon GPUs have their own rendering engine for blender (Download Link). While this is not an exact replica of Cycles, there are similarities that make it a potential substitute.


Is there a way to place a single edge in the same way you place an edge loop?

You can add new edges using the Subdivide function.

Select two opposite edges
Go Edge > Subdivide
Adjust the number of cuts in the pop-up menu.


How do I snap two similar geometric shapes to each other with rotation and scaling?

Flip Normal Vector

For the sake of clarity, after recaluculating normals, I colored the faces to match in blue and the triangle that we'll be use as pivot in red.

Letìs get into edit mode, pick the tris and run the Create Empty operator. Note that we can change the vertex of application with the Swap Empty Origin button.

By examining the empty arrows, we can say that our Z axis is normal to the tris surface and pointing toward the inside of the object, the X is running along the smallest edge and the Y is going where it must be.

Chamge object and repeat the process being sure to choose the right vertex. You can switch the normal vector of the empty by checking the box in the command's options or even remap the whole axis system if needed.

In this particular case we'll need te X axis to be running along the short edge and the Z axis to be pointing outside the object, in order to make the faces ...ehm..."facing" each other.

Finish by matching th empties location&rotation and then eventually adjust the relative scale.


How To Rotate some Vertices around a changed Pivot Point?

If you don't want the shoulder to be part of the selection, you should use the 3D cursor. To place the 3D cursor at the origin of the object you want to orient about, click the object (or vertex, it works in edit mode too) and Shift+S to open the cursor menu.

Then you can select Cursor to Active, this will place the 3D cursor at the origin of the selected object. Then change the Pivot Point to 3D Cursor, and whatever you move/rotate will orient around the 3D Cursor.


Problem with Rig. Part of one finger does not move with the mesh

If we press AltH in Edit mode we can see that you have a hidden bone, and if we check its Deform option we can see that it is activated, while I guess it should not because you probably don't want it to weigh on the fingers, so deactivate this option and it should work fine. Also, disable the Deform option for all the bones that are not supposed to weigh on the mesh, and maybe even reparent.


Why light distribution for smooth and flat shading is so different in Blender Render?

Smooth shading is an attempt to programmatically and dynamically make triangular meshes "look" rounded (smoothed).  Even though the reflection looks smooth, the geometry remains unchanged:

With a perfect cube, there should technically be nothing to smooth; but you applied the shader, so it's gonna try to do something.  The problem that you're seeing in the first two pictures is that those faces are not technically four-sided... at least in the graphical/mathematical sense.  Four-or-more-sided polygons are only for the human eye and mind, not the graphics engine.  Those three faces are actually made up of six triangles.  When the smooth shader is applied to them, it's attempting to "smooth" all the edges and faces and that's why it looks like triangles (the Cycles version is less pronounced but if you rotate it, you'll see it).

When you subdivide it, though, you're adding a lot more geometry to the mesh (especially at level 6, that's 6 orders of magnitude more triangles).  So the shader has more geometry to draw from in order to "approximate" the look you're going for.

The same effect can be achieved by using the Edge Split modifier which adds weights to the edges (essentially doubling the edges, it adds more geometry to the mesh) at specified angles of incidence.  In this case, the edges at 90 degrees could be given the weights but the diagonal in the middle of the faces would be outside the threshold of the edge split.

As for the differences between BR and Cycles rendering, they're two totally different engines and they both have their own ideal uses.  But there's a lot out there on that subject.

EDIT: I should add, for plenitude, that the Edge Split modifier effect can be obtained without increasing filesize.  It's called "auto-smooth" and it's located under Properties Pane-> Object Data-> Normals.


How To Get Reflections On A Smooth Surface?

You are in a preview mode known as "material preview". This mode uses a hidden HDRI image to provide reflections and lighting. If you look at the top right of the 3D viewport, you will see there are 4 little circles - these are the preview modes (from left to right - wireframe, solid, material, rendered). You have the second from the right selected (material preview).
Pick the one on the very right (rendered preview) to see your object with your own lighting setup. You can also press Z in the viewport and select rendered from the pie menu that appears.

If you want to see the image, click on the arrow on the right and increase the World Opacity from the menu.
If you want to set up your own image so the reflection shows but the image doesn't, in your World Shader, combine your image (Environment Texture) with a Background node with the color of your choice by mixing them with a Mix Shader, using the Is Camera Ray output of a Light Path node as the Mix Factor:


I'm currently making a game myself, and what i do is connect the W A S D keyboard sensors to individual AND controllers. These each go to seperate MOTION actuators directing the speed and direction to walk in (A and D can be set to rotation). Then create an ACTION actuator with your animation in it and connect it up to the AND controllers of the W A S D sensors. You can reverse the animation for S key by duplicating the ACTION actuator and reversing the KEYFRAMES. If A and D are for rotating, don't add the action.


What elements go into a good material testing scene

Make sure you have correct neutral lighting (a diffuse grey (50%)
sphere should render as diffuse grey (50%)).
You need some reflectors to judge reflections.
Maybe you should have an object with a stepped thickness so that you
can see how refraction behaves.
You could also setup additional renderlayers with different lighting
situations.
Maybe a grid on the floor to get the scale right (cm, dm, m)?
A McBeth chart of some sort?
A diffuse and a reflective sphere for reference in some corner?

I think SHED have some nice examples in their blog somewhere...


How to rotate the object based on the vertex of another object?

Use snapping to achieve this task.

The settings of snapping:

Snap to vertex
Target - Center
Align rotation is enabled.

And move object with holding CTRL:

PS set center of the cone object in bottom of it.


How can I copy strokes from one keyframe to another?

You can copy and paste ctrl-c ctrl-v or use copy paste from the grease pencil menu. Go to the frame you want to grab the stroke from.. then copy.. go to the other keyframe.. paste.. and adjust as needed from there. (blender 2.81)


Blender 2.77 renders smoke\fire domain solid black on GPU (Cycles)

At the time of writing, smoke/fire is still currently only supported on CUDA/Nvidia cards.


how could i compile and update dependencies automatically?

It was easy to do, just turn on the checkbox register in Menu/ Text/ Register
and the next time to open blender it is run automatically


How can I make the shadows more defined?

A big light source is going to give  you very soft shadows. The bigger the source, the softer the shadows (think of the light on an overcast day, when the sun is diffused by clouds). A small light source (like direct sun or a street light) will make harder shadows.

Adding a second point light in front of the original source will give you defined shadows while keeping the light directon You might want to make the original soft source less bright)


Where to really learn the "theory" behind Loop flow, and sculpting

This site isn't particularly well suited for these broad answers, but here you go anyway :D

topologyguides.com is a great resource for learning about proper topology. For sculpting resources, check out YanSculpts and Zacharias Rienheart on youtube.


When you duplicate object, I think, you keep linked Animation Data. So if objects share same animation data, you can not create different animations for objects. If that so, click Object -> Relations -> Make Single user -> Object Animation

If you want to duplicate the animation data when duplicating objects, make sure that this checkbox is checked:


You have to enable smooth shade on the Mesh Viewer properties (in the N-panel)


From your video, it seems you have a problem with your hotkeys. CTRL-Z for you is activating the Select More command, which the default hotkey is CTRL-numpad+
Check your keymap, type in "select more" into the search bar and check what it is mapped to. Since you're new to Blender, it might simply be easier to reset your keymapings to default.


Simply convert Lumens to radiant flux.

Set Color to white, Power to 1W [link], and Size to 25 mm
Enter 450 Lumens (energy emitted by a 40W incandescent lightbulb)[link]
Divide the Lumens by 683 to get radiant flux [link] (which is used by Blender)

You can use Blackbody node to specify the 2700K color temperature.

Sources:

Cycles, unit of light energy ATTN: Brecht
Why Watt as light value - Comment by Troy_s
CG Cookie - How physically based, photometric lighting can improve 3D renders


rendering without light only texture as they are

I'm not sure if you're trying to do this. Here's my solution:

Hide all lights in your scene by selecting lights and pressing H.
Set your world to white. If there's no color selection, you may check "Use Nodes" to create nodes before you change the world color.

Use Node Wrangler. It's a built-in plug-in. Ctrl+Alt+U to call User Preferences. Go to Addons and search "Node Wrangler", and tick it, then save user settings.
Go to Node Editor, and build up your materials for the object. Once finished, you want to make a solo preview of your texture, so press Ctrl+Shift+LMB on an image node of your diffuse BSDF to make it solo in preview.

(The dotted line was the original line in final, but I make a solo preview of the texture, as you can see the Material Output receives input from a Viewer, followed with Image node.)

Render, or make a viewport render, by Shift+Z.

Alternatively, You can also make screenshots in Material viewport.

Hope that helps.


Local translation with pivot point established on the active object

Moving a multiple selection with the keystrokes

gz global axis

is different than

gzz local axis

where the letter z refers to the z axis and can be replaced by any of the set {x, y, z, X, Y, Z}.  Feel free to experiment.

So having a selection of multiple objects move on their locally rotated axis is a feature.

You can [apply] a rotation.  And thus all objects would have the same rotational axis and different origins.

I do not know your long term goals for your model.  Tutorials may lead you to understand how to

[join] objects
[parent] objects

Blender always has various ways to achieve your goal.

So what is written here is not a tutorial, and you may need to search further here at BSE.  Also pay attention to the additional information which appears in Blender 3D View at the bottom, when using either of the keystrokes above.

You may appear to be changing transformation axis although the video may be clipping the lower portion of the screen capture.  You can also change the pivot center.

I believe Blender is performing as intended.  As the user you should see this behavior as a good option and not something unintended.

In the image below the Blender User first grabbed an object.  Then pressed

F6

to see the other options of the grab/translate operator.

The famous website that rhymes with noonoob has tutorials on selection transformation in Blender.  Although I have not taken the time to find one that deeply addresses this topic you may find one.

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

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


Storing Path in a Variable and Reading it in another py file?

You can access the file_path in the operator, just like you did in the panel, by using the context. Through it you get a reference to the same instance of the PropertyGroup that stores your settings.

context.scene.worth_group_tools.file_path will give you the StringProperty.

You cannot access a local variable that only exists in the function scope from outside the object.


You can either do it with an (Input) Texture Coordinate node > (Vector) Mapping node > Image Texture and tweak the Mapping scale values, or select your plane, switch to Edit mode, select all and in the UV Editor, select the UV and scale it up.


Let's say this is the object you have:

Now open up the node editor:

Add the material then, in the node editor add the Attribute node:

Change the attribute label to Col:

Then it will show up in both the material view:

And the Render View:

Hope this helps

Regards
Grimlock


Fixing this should be a matter of setting the sampling back to 2000.  I think you accidentally put in 4,000,000 instead.  It is possible that you have "Square sampling" selected.


OK, seems I was stuck in a stupid way.
I selected in the SceneCollection the objects BUT NOT the group. So far the the object itself shows the camera but slightly grayed out.

You have to enable the full object path to enable rendering eventually.


Making a embossing wheel using stl image around the wheel

Put it another way, How would you make a wheel or cylinder with a design embossed on the outside all the way around


ON/OFF switch for smoke simulation effectors

This is controlled by the Field Weights section of the domain object's physics panel.

There are dials for each type of field, which you can set to 0.0 for OFF and 1.0 for ON.

Another way is to create a collection and seet the effector collections. Put the active field effector in that collection, all other effectors will be ignored for the purposes of the smoke simulation.  Then swap out the effector when you want to change to another field effect.


How can I populate a model with smaller models?

Take the Atlas figure, duplicate and apply a displace modifier that makes it smaller (just by a little bit). Use this to spawn particles from source: volume. This prevents any minifigs from sticking out through Atlas. This image shows roughly how the shape would change with a displace modifier. It would not be hollowed out like with a solidify modifier.

Create a particle system. Under render options choose render as object. Select the minifig as the object to render. Play around with particle scale and rotation until it looks good. Apply the particle system under modifiers. Now you have a whole bunch of minifigs filling Atlas.
Select all of the minifigs. Then Object>Rigid Body>Add Active. Now the minifigs will bounce off of each other and whatever objects you set as passive rigid bodies.
Under the material for the minifigs, add an object info node. Use the "random" input from this into a hue/saturation node in order to randomly alter the color of each individual minifig.


How to create a 3D virus envelope like this in image below?

The virus model and the animation of the merging into a cell wall can be generated using animation nodes.

Overview

The virus is formed from 3 meshes for the exterior surface, the interior surface, and the contents. Two additional meshes are used for the lipids and proteins on the surface. Animation nodes are used to place the lipids and proteins on the surfaces.
To animate the merge of the virus and a cell wall, the animation nodes are used to move the lipids and proteins from their initial position to their final position. This is done by moving the location of these items along an interpolated path between the initial and final mesh.
This example was done using Blender 2.79 and Animation Nodes 2.0.

Creation of the Virus

Create a lipid model. Once this is created, choose a scale so it can be used for the virus and the cell wall.

Create a model of the surface proteins. This should be in proportion to the size of the lipid model.

Add a small 'Ico Sphere' to represent the contents of the virus.
Add a larger 'Ico Sphere' to model the interior surface of the virus before the merge. The image below shows the virus contents and the inner surface.

Add another, even larger 'Ico Sphere' to model the exterior surface of the virus. The exterior sphere should be placed so the distance between it and the interior sphere is about equal to twice the length of the tails on the lipids.
Create the animation node trees as shown below for the inner and outer surfaces. The key concept is that the mesh for the ico sphere has vertices with both location and orientation (normals). This can be used to position the lipids and proteins. By mixing the lipids and proteins randomly on the exterior of the virus, the desired 3D structure is obtained.

Animation of the Merge

To move the lipids/proteins the animation is broken into 4 equivalent parts: the interior of the virus, the exterior of the virus, the top of the cell membrane, and the bottom of the cell membrane. For these 4 parts, the same kind of solution is applied. A source mesh is used to initially place the lipids/proteins. A destination mesh is used to define the location at the end of the animation.
For the sake of brevity, only the exterior of the virus will be explained in detail. A similar approach is used for the interior, top surface, and bottom surface. The ico sphere for the exterior is created. The mesh is duplicated and edited into a flat surface. This surface is made so the lipids/proteins will follow a simple path from the eco-sphere mesh to the flat mesh.

An animation node network is created to position the lipids and proteins as shown below. The position and the normal for the vertices is used to the lipids/proteins change their orientation when moving.

Similar networks are created for the interior, top, and bottom.
The meshes for the interior and exterior of the virus are animated moving towards and through the cell membrane. This helps make the merge look smoother.
The virus contents are animated moving with the interior and exterior meshes and finally into the cell.

The blend file can be found here:

The key technique to create this animation was by Jacob Verburgt at Milwaukee School of Engineering, Class of 2018. His original animation is at https://www.youtube.com/watch?v=9cV8KBup7Eo

Thanks to Brenticus to pointing to his animation on Reddit.


Problem with proportional editing on a curve

If it's a Bezier curve, your proportional edit circle has to encompass the handles of the point as well as the point to move it. GL  Ten four rubber ducky.  Over and out.

It looks like Blender calculates "connected" from the point and traces it back down the original curve, and if you connect 2 ends of the curve with F key (make segment), Blender doesn't read that as a new path, so to speak.  I'm not sure how to fix that though.  Hope this makes sense.


Can blender be used for simple optical modeling?

Cycles is relatively simple path tracer without MLT so I did not try to simulate lenses in Cycles, and do not recommend it for this purpose. LuxRender is much better choice for this, it is free and open source, and integrates with Blender very well. With LuxRender it's possible to simulate fish-eye or normal lenses focusing light (image) on film (with translucent matte material and camera behind it). You could simulate chromatic aberration too. You could model half of each aspherical (or spherical) surface profile precisely with XYZ Math Surface, then spin 360 degrees, then delete all doubles and set smooth shading. This way, it is possible to model even achromatic doublet (you will need three surfaces with properly defined interior/exterior volumes). But more lens elements you have between film and the scene, the more issues you will encounter. When done modeling lens elements, enclose them in completely black container.

Simulation of simple lenses (1-2 elements) is almost without issues, complex lenses with many elements (4-6) may have weird noisy artifacts (but result usually good enough "to get overall idea"). If number of elements is too many (for example, 18), simulation may fail (just render few fireflies on black screen). Another limitation is that LuxRender as far as I know cannot simulate AR coating yet.

You did not mention how good you are with lens modeling and underlying math describing their surface, and how many elements you plan to have in your lens simulation(s). I think there are no good tutorials about this yet. If you need one please comment, I could expand this answer with much more details (but please note that it may take few weeks because if I do this, I would like to do it with good examples, and only if somebody actually interested in more detailed answer, and if using LuxRender is acceptable option).


You should uncheck the Progressive Refine option (Under the Performance render properties panel) in order to enable and tweak Denoising settings for high quality renders.

Following are the details for this behavior.

Denoising is a post processing pass after the render tiles and layers are finished. It tries to remove fire flies and other noise by utilizing rendered data. It works best when there are enough samples rendered and saved in render buffers.

The progressive refinement display of an ongoing render is an interactive feedback tool and since it is not used for final renders but for quick turnaround renders for fine tuning wip settings, the denoising feature is disabled.

Denoising and Render Layers in Blender


How do I make it so each shape is colored a different color/shade?

You cannot apply a colour to each shape because Blender has no concept of what "Shape" means in your context. If the shapes were of a set size and offset from each other, you would be able to make a mathematically accurate base layer of colour and mix that into the material matching the locations of the shapes.

But try the following and see if it gets you further in the direction you wanted to go.

Create a UV for your mesh (Unwrap) and pipe the colour from the Image Texture into a ColorRamp node that can isolate the two colours (you already did this) and gives us the mask.

Now create a new Texture. Here I use a quick and dirty Noise Texture but you could use almost any Texture to give you a base colour layer. You could also create an image for this purpose (*).

This can now be Mixed in with the Mask as the Factor.

And finally we Mix the initial texture back into the final result.

The result is imperfect, but you can tweak the Texture to try and better match the locations of the shapes.

(*) This not as silly as it sounds. You could create an image with a very low resolution e.g. 8x8 pixels and use that grid of coloured pixels as the backing colour layer.

And as always with Blender you could use Python to code a solution with shape detection, but I cannot help with that.


How to get reflections from 3D to show up on real images

Use emission shaders as a way to create a mask for the reflections.
(for more information see this answer)

Use two layers for the 3D layout:

Layer 1, containing the scene with all your objects, lights and reflective surfaces

Layer 2, containing the reflective surfaces and a copy of the objects to be reflected, but this copies should have an emission shader only.

On the render layers section create two Layers:

One render layer (I'll call it color) that holds the scene's Layer 1, excludes layer 2 and uses the combined pass.

A second render layer (I'll call it emitter reflection mask) that holds the scene's layer 2, excludes layer 1 and has Glossy Direct enabled, as well as Emission.

On the compositor, Use a color mix node to add the Emit and Glossy direct form the Emitter reflections mask layer. Use the result as alpha channel to composite the color pass over the backgorund image.

To make the reflection less perfect (which I think is what @troy_s suggested) you can take the Glossy direct information,  multiply it with some gray color in a color mix node, and add that to the composited image(You might even want to add some blur or other textures along the node tree too)...

Another example

(using the same scene as in this answer). Simple geometry.

On layer 1 just a plane to catch the reflections and the reflected object, lit by emitting planes with the background image.

On layer 2 the same scene, but with a copy of the object using an emission shader and no other lights.

Set the render layers as described above, that will allow us able to create mattes to separate the original object from the reflected one, and use those mattes to make the final combination of the CG element and the Image background.

The easy part is using the Emssions of the second layer to isolate the forground element.

If we were to compose that over the background using alpha over we'd get some refection... but it would be semi-transparent, making it unrealistic. In real life the reflection of the object would occlude the background...

To get rid of the reflections of the lights on the ground we need a piece that is clean of those reflections but has the reflection of our 3D object.
(I used a portion of right side of the image that does not have the reflection of the lights, that's why the rotate and transform node are for, but in other cases you might need to use photoshop or other image editor to crate a "clean" plate).

Then, combine the background image with the reflection.

Now mix it all together using the glossy direct information as factor for the mix:

To make the reflection on the less present you can change the factor level on the mix with the background plate:


Problem's solved! I've forgot about hidden array modifier, which is appeard in render and overlapped wall :)


Find users of a material / texture / image which is not displayed in the outliner

You can set your outliner to Blender File mode. This will show even datablocks with no users. Under materials you will find a list of all materials in alphabetical order. You can even search for datablocks by name in the small search field at the top:

To find users of a datablock, perform the same search in All Scenes mode instead of Blender File mode.


How can I delete an Empty with it's dependent objects?

Select your parent object then go to Select > Select grouped (shortcut  Shift  +  G ) and choose "Children". That will select every children and their children and so on. Then you can delete them like any other object.


You could create a plane on Z = 0 (an empty will do, too, but you might want to hide what's below), then apply a Mirror modifier along Z around that plane, with Clipping enabled:

This will effectively clamp vertex positions:

If you leave a vertex at the plane, it will stick to it, and you will have to temporarily disable Clipping to be able to move it away:


There are several way you can bend objects.

If you want to use proportional editing, you can use the following steps.

First add a subdivided plane and switch to edit mode. Activate proportional editing. I think linear falloff is the most suitable option for this task. Switch the pivot point to 3D cursor.

Place the 3D cursor where you want the bend to pivot. You can set the 3D cursor to the position of a vertex by selecting a single vertex and then SHIFT+S > Cursor to selected.

Now select the row of border vertices that will be bend. Press R to rotate, followed by the axis you want to rotate around (X, Y or Z). Adjust the radius of the proportional editing influence by using the mouse wheel.

If you want to use the Curve modifier, you have to use the following steps.

First add a subdivided plane and a path (Add > Curve > Path).

Select the path and switch to edit mode. Bend the path so that it represent the bend profile. In the screenshot I have rotated one half by 90° around the Y-axis centered in the 3D cursor.

Then switch to object mode and add a Curve modifier to the plane. Select the deformation axis. The grab the plane with G and X, Y or Z whichever is you deformation axis and move the mouse cursor until it has the desired shape. Alternatively you can do it the other way around and move the curve.

If you want to use the Simple Deform modifier, you can use the following steps.

First add a subdivided plane, then add a Simple Deform modifier to it. Change the mode to Bend and set the axis to the one you want to bend around.

Now switch to edit mode and select the vertices you want affected by the modifier. With the vertices selected go to the object data tab and create a vertex group. Assign the selected vertices.

Add the vertex group to the modifier.

Switch back to object mode and add an empty (Add > Empty > Plain Axes) and set it as Axis, Origin for the Simple Deform modifier. Rotate the empty by 90° around the axis you want to bend. Then adjust the angle in the modifier to control how large the angle of the bend is. The empty is used a center/pivot for the bend so you can adjust the position to change the radius of the bend.

The Bend tool is a bit unintuitive because depends on your angle of view, the angle between your mouse cursor position between the start and end of the operation, the distance to the 3D cursor and uses the 3D cursor as pivot.

First step is to add and plane and subdivide it. Then switch to edit mode.

Place the 3D cursor where you want the bend to pivot. You can set the 3D cursor to the position of a vertex by selecting a single vertex and then SHIFT+S > Cursor to selected. Alternatively you can switch to orthographic perspective (Toggle with Numpad 5) and view the scene from one of the sides e.g. from the top Numpad 7. Then place the 3D cursor using SHIFT and right click into 3D space.

Once you have that prepared, select the vertices in your plane that you want to affect with the bend. Switch to the perspective from which you want to bend, e.g. if you want the bend to occur along the Y-axis, align your view to the Y-axis.

Press SHIFT+W to activate the bend. Now place your mouse cursor at the distance from the 3D cursor that you want as radius for the bend. Move your mouse cursor around the 3D cursor until your reached the desired angle of bend and confirm by clicking the left mouse button.


You should be able to perfectly deform a curve with a another curve, no need to convert to mesh first.

But raises the question why. If the second deforming curve already has the desired shape use that one directly.

Curve deformation generally works well on elongated objects that roughly extend in one direction that should run parallel to the length of the curve deforming it.

So if that is the case and the other object is elongated than you probably won't need  second curve to be deformed.

Otherwise it will probably give very weird results. If your curve has a really contorted shape it will probably yield unexpected glitchy-looking deformations.

Things to look out for when using the Curve Deform modifier are

Make sure deforming curve and deformed object are coinciding have exactly the same origin point in the scene's unit coordinates
Make sure the deforming curve's origin coincides with one its end vertex. In other words one of the end vertex has 0,0,0 local coordinate.
Make sure the vertex at 0,0,0 is the starting vertex, not the end one.
Make sure the deformed object has it geometry roughly close or around it's center, or at least sanely placed in relation to it's center (like at one end).
And lastly make sure the deformed object (the one with the Curve modifier) is elongated in the correct direction that runs roughly parallel along the curve length

If not, then you can adjust the deformation axis in the Curve modifier properties.

For more complex deformations you may want to look into the Cast Modifier, or the Simple Deform one, or even the Shrink Wrap one.


Smooth shading calculates the normal of any point in a polygonal face of a mesh by interpolating between the normals at its corners. The normals at the corners of a face are stored in the mesh data, and are usually calculated from the normals of adjacent faces.

When the cylinder is cut, some of the adjacent faces are missing, so the calculated corner normals are changed.

However, you can copy the corner normals from an intact cylinder to the cut cylinder by applying a Data Transfer modifier.

Place the cut cylinder directly over an intact version of the same cylinder
Add a Data Transfer modifier to the cut cylinder, with the option 'Face Corner Data' checked, set to copy from 'Nearest Corner .. etc', and the intact cylinder as its target.
Apply the modifier

Cylinders: 1. Intact. 2. Cut with no transfer. 3. Cut with transfer.


Armature parent with automatic weights swaps the legs

I applied the scale and rotation to the model before, so I guess the exact solution was to recalculate the normals. I'm not sure exactly, however applying loc,rot, scale and recalculating normals together fixed the issue.


How to limit the frequency of pushing of keys in the BGE?

Here you have simple Python script:

import bge
from bge import logic

REFRESH_RATE = 60

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

owner["timer"] += 1

keyboard = bge.logic.keyboard
JUST_ACTIVATED = bge.logic.KX_INPUT_JUST_ACTIVATED

if keyboard.events[bge.events.SPACEKEY] == JUST_ACTIVATED:
    if owner["pressed"] < 2:
        owner["toggle"] = not owner["toggle"]
        owner["pressed"] += 1
if owner["timer"] >= REFRESH_RATE/2:
    owner["timer"] = 0
    owner["pressed"] = 0

toggle property is used here just to present the effect of the mechanism, it changes if the user input is accepted. Keep in mind that the REFRESH_RATE should be the same as the one stored in Render Properties.
The Logic Editor setup in this case would be:

You can also download it as .blend file here:

I hope this can help you solve the problem. Cheers.


Yes, this is possible using the following node setup (click for larger image):

As you can see, the coordinates are the same as the channels (click for larger image):

In the screenshot above the RGB values are slightly different from the coordinates displayed in the Properties panel because those coordinates are measured at the object origin and the RGB channels represent the coordinates at the objects surface.

Also note that the colors will be different than in your screenshot because blender uses Z (blue) up and it appears that the screenshot is of a Y (green) up space. Aside from rotating your actual geometry, you can remap the colors in the node setup (click for larger image):

Now the colors will match your screenshot:

Blendfile


I created a facsimile of your scene to illustrate how this can be done. Here is what I start with.

Next, I create some non-manifold geometry so that I can later illustrate how to expose it. In Edit Mode, I select the edges highlighted below, and peform an Edge Split.

Next, while still in Edit Mode, I go to the Select menu, and Choose Select All by Trait > Non Manifold. This will select all geometry that is not closed.

Very handy. Here is the result.


OK i found the issue.
The Display field only updates when you change frame, it will not update if you move the empty but stay on the same frame, if you move one forward or back it works.

You can also use python to control this field. ( Firstsplash is name of particle settings, replace with whatever the name of you particle settings is )

import bpy

bpy.data.particles["Firstsplash"].draw_percentage = 1
bpy.data.particles["Firstsplash.001"].draw_percentage = 1
bpy.data.particles["Firstsplash.003"].draw_percentage = 1


Texture Paint painting on back of selected object

Turns out I just had to fuss with some of the default settings, though why they were set to such an odd default, I don't know. For anybody else with a similar problem, this can be fixed by entering Texture Paint mode, then selecting Options > Project Paint on the left panel and making sure only Occlude is checked


How do I import an image as a plane after opening a new .blend file?

With hints from @rob that it's better to append the scene and destroy the old one, and code from How to delete a scene with its content? to destroy the objects in the old scene first, I finally got the results I expected. When you run this code:

# Imports.
from bpy import context, ops, data
import os
import random

def delete_scene_objects():

    # Get the current scene.
    scene = context.screen.scene

    # Remove objects.
    for object_name in scene.objects:
        data.objects.remove(object_name, True)

    return scene

def add_plane():
    ops.mesh.primitive_plane_add()
    plane = context.scene.objects.active

    # Add a UV texture layer to the mesh.
    plane.data.uv_textures.new()

    # Demonstrate that you can attach an image to the mesh.
    if len(plane.data.uv_textures[0].data) > 0:
        print('We have UV Texture data')
    else:
        print("We don't have UV Texture data")

def append_blend_file(blend_file):
    section_name = '\\Scene\\'
    object_name = 'Scene'

    directory_name = blend_file + section_name
    ops.wm.append(filename=object_name, directory=directory_name)

def add_blend_file():

    # Where to get blender files.
    blender_file_dir = 'D:\\Path\\to\\blend\\data\\folder'

    # Object class.
    class_name = 'CoDrone'

    # Open blender file (needs to match the object name).
    file_name = '{}.blend'.format(class_name)
    blend_file = os.path.join(blender_file_dir, file_name)
    append_blend_file(blend_file)

add_plane()
old_scene = delete_scene_objects()
add_blend_file()

# Remove old scene.
data.scenes.remove(old_scene, True)

add_plane()

You get this output:

We have UV Texture data
We have UV Texture data


Here is an addon to do that (if my comprehension of the question is good).

To make it work, you need to associate the wanted objects (empties) in an object's group.

Then:

Choose the group in the UI
Set min and max values (the scramble part will take 3 random values in between and shift x, y, z with them)
Choose a seed if you want to repeat it with the same random sequence
Use the scramble button.

The scramble function is commented in the code below (other parts are simple UI):

bl_info = {
    "name": "Scramble animation locations",
    "author": "lemon",
    "version": (1, 0),
    "blender": (2, 78, 0),
    "location": "",
    "description": "",
    "warning": "",
    "wiki_url": "",
    "category": "Animation"}

import bpy
from random import Random

def ScrambleObjectAnimation( object, scrambleMin, scrambleMax, rnd ):
    #If there is an animation
    if object.animation_data:
        #Get random values to shift/scramble x y and z
        dx = rnd.uniform( scrambleMin, scrambleMax )
        dy = rnd.uniform( scrambleMin, scrambleMax )
        dz = rnd.uniform( scrambleMin, scrambleMax )
        delta = [dx, dy, dz]
        #Loop on the animation curves that correspond to the location
        for curve in [c for c in object.animation_data.action.fcurves if c.data_path.endswith( 'location' )]:
            #Shift all control points of the curve
            for key in curve.keyframe_points:
                key.co[1] += delta[curve.array_index]

def ScrambleObjectsAnimation( objects, scrambleMin, scrambleMax, seed ):
    rnd = Random()
    if seed > 0:
        rnd.seed( seed )
    for object in objects:
        ScrambleObjectAnimation( object, scrambleMin, scrambleMax, rnd )

def SettingsAreOK( context ):
    return True

class ScrambleObjectAnimationOperator( bpy.types.Operator ):
    bl_idname = "lemon.scrambleobjectanimationoperator"
    bl_label = "Scramble objects animation"
    bl_options = {'REGISTER','UNDO'}

    @classmethod
    def poll(self, context):
        return context.mode == 'OBJECT' and SettingsAreOK( context )

    def invoke(self, context, event):
        scn = context.scene
        settings = scn.scrambleObjectAnimation

        #try:
        objects = bpy.data.groups[settings.group_name].objects
        scrambleMin = settings.scramble_min
        scrambleMax = settings.scramble_max
        seed = settings.seed
        ScrambleObjectsAnimation( objects, scrambleMin, scrambleMax, seed )
        #except:
            #pass

        return { 'FINISHED' }

class ScrambleObjectAnimationPanel( bpy.types.Panel ):
    bl_idname = 'lemon.scrambleobjectanimationpanel'
    bl_space_type = "VIEW_3D"
    bl_region_type = "UI"
    bl_label = "Scramble objects animation"

    @classmethod
    def poll(self, context):
        return context.mode == 'OBJECT'

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

        settings = scn.scrambleObjectAnimation

        layout.row().prop_search( settings, "group_name", bpy.data, "groups", text="Object group" )
        layout.row().prop( settings, "scramble_min" )
        layout.row().prop( settings, "scramble_max" )
        layout.row().prop( settings, "seed" )
        layout.row().operator( ScrambleObjectAnimationOperator.bl_idname, text="Scramble" )

class ScrambleObjectAnimationProps( bpy.types.PropertyGroup ):
    group_name = bpy.props.StringProperty()
    scramble_min = bpy.props.FloatProperty( name="Scramble min", default=-1.0, soft_min=-10, soft_max=0, step=2, precision=2 )
    scramble_max = bpy.props.FloatProperty( name="Scramble max", default=1.0, soft_min=0, soft_max=10, step=2, precision=2 )
    seed = bpy.props.IntProperty( name="Seed", default=0, min=0)

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

def unregister():
    del bpy.types.Scene.scrambleObjectAnimation
    bpy.utils.unregister_module(__name__)

if __name__ == "__main__":
    register()


how to move cursor between viewports while extruding

Thanks for your reply! Well, it seems like I was fooled by the hidden efficiency of Blender: When I finish an extrude (left click), the new edge is still marked, so just scooting over to another viewport and pressing G will just shuffle that new edge around in another direction, like the extrude continued there. I totally missed out that the newly created edge is as movable as any other selected part. (Old Solid CAD modeller here, hard to get used to this...)


ASCII Art in blender using Animation Nodes

ASCII Art rely on a fundamental concept, when characters are viewed from far, they no longer look like characters but rather some white and black blocks. Some characters look more black that others, for instance, a dot . colors a single pixel black, while an I colors more that one pixel black and thus it looks more black that a dot from far away.

Let us define the density of a character as the ratio between the white and black pixels in a rasterized version of the character. From this, it is clear what we have to do in order to draw an image using characters:

Sample the pixels of an image and convert them to greyscale if they were colored.
Compute the density of each character and store it in a list.
For each pixel in the image:

Find the character with the closest density to its value and append it.

Break the list of characters into n number of row where n is the width of the image. Then output that text.

Sample Image Pixels

I am going to make a group that samples the pixels of the image as well as return its width. You can get the R values of the pixels of an image with name imageName using the expression:

bpy.data.images[imageName].pixels[:][0::4]

And the width by the expression:

bpy.data.images[imageName].size[0]

So the node group looks like this:

Notice that you can cache the results for faster execution in the future.

Compute Characters Density

To compute the character density, we are going to use a BVH tree. We will ray cast a group of ray in the bounding box of each character, count the rays that hit each character, divide it by the number of rays. This will get us the normalized density of each character. First, I am going to create a mesh with all possible characters aligned in a row. It is important to use a monospace font for this:

Next, I am going to create a loop that takes a grid of vectors, ray cast them on each character and compute the number of hits. Notice that at each iteration, I move the grid in the x direction by some offset value that is equal to the width of each character (Which is constant since we used a monospace font):

Next, we create the BVH tree and the grid that will be used as the input for the previous loop. The BVH tree is easy to compute using the Construct BVH Tree Node. However, to create the grid, we have to identify the width and height of each character, I couldn't really find anyway to do that, so I aligned a plane with one character and got the width and height from it, I also added an array modifier to get more accurate results by cross checking width and height with all characters:

Computing the grid in this case is easy, we get the difference between the lower left and upper right vertices locations of the plane to get the height and width, the Grid Mesh node returns a grid that is centered, to move it to the first quadrant, we subtract half of the difference vector. Having the grid in the first quadrant, we move it such that the first vector is aligned with the first vertex in the plane:

We then divide the number of hits by the total number of rays. Now the problem is to find the index of the character that its density is closest to each of the pixel values, so lets make a loop that returns the index of the closest value in a list to some reference value. We loop over the values of the density list, compute the difference between the current density and some reference value, if the difference is smaller that an initially infinity parameter delta we reassign an integer parameter to be the current index and reassign delta to be the difference. I realize it is not easy to understand what is going on here, but it really is easy, at the first iteration, delta is infinity and thus any difference is definitely smaller than it, so delta becomes the difference between the density of the first character and the index becomes zero (Indicating that so far the closest value is at index zero), at the next number of iterations, if we find a smaller delta (Difference), we reassign again indicating that we have found a value that is closer. Make sure to output the Closest Index parameter after you are done:

Now, we loop over the pixel values, use the previous loop to find the index of the character with density closest to it (The pixel value is the reference value here), then output those indices:

We now split the characters we used to create the mesh, get the characters at the indices we just generated, split them again at nth character where n is the width of the image, then join them with a line break as a separator. Notice that we  reverse the lines, that is because blender reads the image from the lower left corner, while text is written from the upper left corner:

One thing to note is that if one normalized the density by dividing by the maximum number of hits, the result will be richer. All of this results in a text:

Not sure if you can see it, but Lenna is drawn here. There is something to note however. The line height is much larger than the width of the character, so we may want to reduce it, since we can't do that in blender, we are going to take another approach. We are going to use cycles.

Shading Approach

What I am proposing is that we create a texture that is composed of the characters ordered from the lowest density to the highest density. We then compute a texture coordinates that position the characters in a grid where the the density of the character in each cell correspond to the pixel values in the image.

First we generate an image with the 84 characters we have ordered based on their density, we can do that by rendering a text object generates by this node tree:

We are basically sorting the characters, joining them and writing them to an object, then we render it producing an image like this:

Notice that the characters at the left are more sparse (lower in density) than those at the right, and that is exactly what we want.

We now have to compute the texture coordinates based on some input image, I shall not describe how the node tree is created because it is out of the scope of this answer, but I will share the blend so that you can study it yourself.

Character Instancing

Lets say we have 80 different characters that are used in the ASCII Art, they may repeat a lot inside the art, so there is no good reason to repeat them that many times and consume memory like that. A better approach would be to create 80 text object each with a character, then create 80 meshes with vertices, each of which will be the base for a DupliVert of some character, for instance, the character a was repeated a thousand time at different locations, we create a mesh with vertices locations equal to those of character location, then parent the object with character a to it, this will result in instancing the character a in all of the locations it was supposed to be in. By doing that for all objects, we create a complete grid of characters just like the one in the CSS and text editor example. So we use the Object Instancer Node to create the character objects as well as the DupliVert object as follows:

Then we hand it to the Instancer loop. This loop find the indices at which each character occurred, find it location in the text grid by means of modulo and floor division by the width, then the output locations are assigned to one of the mesh object, then dupli_type is set to VERTS and the character object is parented to the DupliVert Base:

And this immediately returns the results we are looking for, notice how by selecting one of the objects, we see all the places it occurred in:

We have about 9 million polygon in the scene and blender isn't complaining.

Here is the blend file for study and practice:


The Principled BSDF has anisotropic and anisotropic rotation settngs in order to achieve this.

This video explains pretty well how it works.


The bpy module and the API provided by Blender is pretty close to a scene description language.

Switch to Console Editor.

Now you can interactively make modifications to the scene.

The bpy module is already imported into the console.

>>> list(bpy.context.scene.objects)

[bpy.data.objects['Point.002'], bpy.data.objects['Point.001'], bpy.data.objects['Point'], bpy.data.objects['Cylinder.006'], bpy.data.objects['Cylinder.005'], bpy.data.objects['Cylinder.004'], bpy.data.objects['Cylinder.003'], bpy.data.objects['Cylinder.002'], bpy.data.objects['Cylinder.001'], bpy.data.objects['Cylinder'], bpy.data.objects['Suzanne'], bpy.data.objects['Plane']]

>>> bpy.context.scene.objects['Suzanne'].location.x = 1
>>> bpy.context.scene.objects['Suzanne'].location.x = 0

C is an alias for bpy.context, so you can also do

>>> C.object.location.x = 0

You can keyframe object properties (In the example below we are adding a keyframe on x location attribute)

The data related to the scene can be accessed from the context directly.

>>> C.scene.frame_current = 1

>>> C.object.keyframe_insert('location', index=0)

>>> C.scene.frame_current = 25
>>> C.object.location.x = 5
>>> C.object.keyframe_insert('location', index=0)

Links to some important blender python API modules

https://docs.blender.org/api/current/info_quickstart.html
https://docs.blender.org/api/current/bpy.context.html


I've found the issue and I feel stupid now but maybe someone will feel like me one day so here is what happened : Before I bake normals, I add a modifier on my low poly (shrinkwrap) and I forgot to shut it down... :p


One thing you can do is select the edge you want to snap the vertex on and then subdivide it, this way you have a new vertex on said edge that you can move to the location you want the snap to happen, then simply snap the two vertices together, and then remove doubles just to be sure you don't have ovelapping vertices.


Using edge loops for sharp edges without distorting the mesh?

You just need to move some vertices to make it smoother:


How to rotate UV and preserve the correct aspect ratio?

Clearly the UV editor uses the aspect ratio.

Closing the image in the UV editor on LHS demonstrates that the UV editor is using the aspect ratio of the image when rotating.  The LHS rotation result is equivalent to running script result in question, or with unit aspect ratio below.
Instead of our normal 2D rotation matrix,
$$R=\left[
\begin{array}{ccc}
 \cos \theta & \sin \theta& 0 \\
 -\sin\theta & \cos\theta & 0 \\
 0 & 0 & 1 \\
\end{array}
\right]$$
can allow for a non uniform aspect ratio $\rho$
$$R=\left[
\begin{array}{ccc}
 \cos \theta & \dfrac{\sin \theta}{\rho } & 0 \\
 -\rho  \sin\theta & \cos \theta& 0 \\
 0 & 0 & 1 \\
\end{array}
\right]$$
Here is a an object mode script using numpy and the $XY$ dimension of the object (for example, if imported using image as planes) to calculate $\rho$ which will emulate the rotation as shown on RHS of gif.  Setting p = 1 will be same as shown on LHS.
import bpy
from mathutils import Matrix, Vector
import numpy as np

ob = bpy.context.object
me = ob.data
uvlayer = me.uv_layers.active

pivot = Vector((0.5, 0.5))
angle = np.radians(30)
# aspect ratio
p = ob.dimensions.y / ob.dimensions.x
# aspect rotate
R = Matrix((
            (np.cos(angle), np.sin(angle) / p),
            (-p * np.sin(angle), np.cos(angle)),
        ))

uvs = np.empty(2 * len(me.loops))
uvlayer.data.foreach_get("uv", uvs)

# shear rotate about origin, translate to pivot
uvs = np.dot(
        uvs.reshape((-1, 2)) - pivot,
        R) + pivot
# write the new UV's back
uvlayer.data.foreach_set("uv", uvs.ravel())
# update mesh to display changes.
me.update()

Result on image imported from "Images as Planes" addon. Note positive rotation is clockwise, where-as blender uses CCW (simply change sign of angle to change)


Should I model a humanoid body as separate body parts?

Generally speaking it's not how 3D game artists are building their models. Separating the head and the limbs from the body might make things easier in the beginning of the modeling process but later on it will be harder to produce a good result.

Separate limbs always result into seams. You can hide them under garments but you cannot get rid of them by painting over them.

As for the aspect of rigging and animating them you might want to take into account that most of the rigging tools (for Blender and otherwise) are designed to work with single meshes. At one point you will have to weight-paint your mesh to get a good result. Having two separate meshes even in the same model leads to gaps and deformities which cannot be fixed. It's just the way inverse kinematics work.

About that "getting lost in a big mesh" part - you can always hide parts of your mesh in edit mode. Select the part you want to hide, then hit H to hide it and Alt+H to unhide it.


Blender 2.78c Cycles particles change color by age

Here's what's going on, from Blender Docs about Particle Info Node:

  This node currently only supports parent particles, info from child
  particles is not available.

So your only option is to turn off Particle Children and crank up Particle Number to make it 'similar'.

Also if you turn on Parents in Particle Render section some of them will be white but only a few.

I've checked also in Blender 2.79RC2 but it's not working there either.


Using alpha data on one material to mask a texture in another material

The answer is to have a skin texture that uses an alpha channel to leave the area of the eyes out.

The alpha texture can then be used to drive the fac value of a mix shader.
If you want to animate the eyes, you need to change the texture coordinate input.


The .blend files are the project files of Blender.

They are binary files with the .blend extension as in fileName.blend. Blender saves its data as .blend files and can only open .blend files.

Other 3D files types are not "opened", but imported.

Blend files contain the models, materials, the scene (camera, lights and animation) and the information for rendering and viewing along with the state of the user interface.
By default they don't contain images used as textures unless you pack them. Read: How to pack images into blend file

Also not contained as part of the file are simulation caches or the add-on used to create the scene.


Why does an update function loop when string property is reset?

In the execute method of the Test_Op class, you should access the property like this to prevent the update method from being called:

bpy.context.scene.test_vars["test_update_string"] = ""


Only if you have a mirror modifier applied. You have to cut your model in half then apply the mirror modifier to apply transformations in both sides at the same time


this can be done by changing the unit type from none to imperial

Then, add your cube and change the measurements to whatever you want


Assign the object an emissive material the color you want. Set the world background color to something you like, if you like.

Switch the view mode of your window to'Material'. If you want the new background color too, you'll have switch to 'Rendered'. I find a pie menu (with gestures) helps speed up the switch.

If you want a new background color without rendering, you can change that in User Preferences 'Themes'. If you need a quick switch of background color too, that's scriptable... see this BSE answer.


mesh hair cloth: how to find root vertices to pin

I have found a python solution to effectively find vertexes to pin.
I the base/complete mesh, I first defined a Vertex Group called "pinned".
The hair was a series of meshes, so I first separated each into its own with the Edit Mode Mesh "Separate" "By Loose Parts":

I created a "pin.target" object near the crown of the scalp, to calc distance of each vertex I visit I then created a python script that did a select pattern to find all of the "strand" objects, and for all strand objects, for each vertex...
import bpy
import bmesh
from math import sqrt

pinTargetLoc = bpy.data.objects['pin.target'].location
print("pinTargetLoc=",pinTargetLoc)

bpy.ops.object.select_pattern(pattern="ToulouseHR*")
hairParts = bpy.context.selected_objects

cnt=0
bpy.ops.object.select_all( action='DESELECT' ) # Deselect all objects
for hairPart in hairParts:
#    if cnt>0:
#        continue
    print( hairPart, hairPart.location )
    hairPart.select_set(True)
    bm = bmesh.new()   # create an empty BMesh
    bm.from_mesh(hairPart.data)   # fill it in from a Mesh
    verts=hairPart.data.vertices
    #verts.ensure_lookup_table()
    cnt+=1
    print( len(verts)," vertices" )
    # find the vertex closest to the "pin target" object location
    closestVertex = None
    distanceOld = 9999999.0
    selected_verts=0
    for v in verts:
        distanceNew = sqrt(
            (pinTargetLoc.x - (hairPart.location.x + v.co.x))**2 +
            (pinTargetLoc.y - (hairPart.location.y + v.co.y))**2 +
            (pinTargetLoc.z - (hairPart.location.z + v.co.z))**2)
        print( distanceNew )
        if ( distanceOld > distanceNew ):
            if ( closestVertex is not None ):
                closestVertex.select = False
            closestVertex = v
            print( closestVertex, "@", closestVertex.co )
            distanceOld = distanceNew

    # add 'closestVertex' to pinned group
    indexList = [ closestVertex.index ]  # vertex index list  of single closet item
    print( "closestVertex.index=", closestVertex.index )
    hairPart.vertex_groups.active_index=1
    pinnedGroup=hairPart.vertex_groups.get("pinned")
    pinnedGroup.add( indexList, 1.0, "ADD" )

    print("v count",selected_verts)
    print( "closestVertex.co=",closestVertex.co )
# end of script

I then selected all strands, and then Joined them into the Scalp, where I could then Select the "pinned" Vertex Group and see the result:

I can now use this Vertex Group as the Cloth -- Pin group to keep hair strands from flying away.


Blender 2.80 Subdivision Surface Modifier has no effect

Updating to version 2.81 Fixed this for me.


Collect, apply modifiers, and triangulate meshes before export, without touching the original mesh

Bmesh from object.
See How do I get a mesh data-block with modifiers and shape keys applied in Blender 2.8?  Can use the evaluated mesh and look at loop_triangles or with a bmesh and call the bmesh triangulate operator. In both cases no new data need be added to file.
The two answers show how to get the evaluated mesh as either a bmesh or an evauated mesh.  In either case there would appear little need to bother with a context manager to use the with statement.

Result of running on two selected subsurfed default cubes, creating one joined and triangulated to export
Here is an example that creates a joined and triangulated bmesh from all the selected mesh objects.
Just as with multiple calls to bm.from_mesh(...) can be used to read multiple meshes into one bmesh, can do same for bm.from_object.
On each "read" the new vertices are transformed by the objects matrix world.
To demonstrate result, a new mesh object is created and added to scene, whereas the exporter can simply re format the bmesh data.
import bpy
import bmesh
context = bpy.context

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

dg = context.evaluated_depsgraph_get()

bm = bmesh.new()

for o in meshobs:
    n = len(bm.verts)
    bm.from_object(o, dg)
    bmesh.ops.transform(
            bm,
            verts=bm.verts[n:],
            matrix=o.matrix_world,
            )

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

# new object to test
me = bpy.data.meshes.new("TriExportTest")
bm.to_mesh(me)
ob = bpy.data.objects.new("TriExportTest", me)
context.collection.objects.link(ob)

World or Object Coordinates?
Note the created bmesh above will have its vertices use the global coordinates of the input meshes. And an identity matrix world (no transform)  To more closely emulate the join operator, by using object space of the active object
Save and calculate inverse of matrix world of active object.
mw = context.active_object.matrix_world
mwi = mw.inverted()

then in the bmesh transform operator
    matrix = mwi @ o.matrix_world

and finally assign the matrix world to the joined object
ob = bpy.data.objects.new("TriExportTest", me)
ob.matrix_world = mw


Is there any way to generate Inverted or taper geometry by using displacement?

I write an answer as proposed to by @SHikhaMittal. Though, still not sure this is the wanted result.
As this is about "any shape", have used an image, like a decal, to drive the displacement.

The shape is colored with "wireframe" node, so that we can see the result of the displacement in term of geometry.
The nodes:

Bottom part is the decal used to drive the displacement scale. It is 0 outside of the image.
The middle line is to offset the normal around the mesh center. X and Y parts are scaled and added to the normal in order to drive this normal "outside".
Top part, the wireframe colors.

Remarks:
We can notice that the scaled and displaced part looses resolution, because we only keep a small amount of vertices and scale them.
The other answer by Bruk, using another way to do it (scaling down a larger part along a cylinder) should avoid this issue.


You can right-click on the object (while you are in object mode) and then click on set origin -> set origin to geometry. Then your origin is going to be centered again


Area of mesh moving along bone despite not being weight painted

The right arm and shoulder have weights form Arm_L bone that are causing the deformation.

You can clearly see it when in vertex selection masking and adjusting weights levels in the Weight Tools panel.

To fix that problem set weights from Arm_L on the right shoulder and arm to 0, or use Subtract Brush on that areas.


Is it possible to make a car with this kind of functional axle?

Select the axle, then the wheel, and press Control+J to join them into one object.  Now the axle and wheel will move together.


So as switching to Quaternion would remove the animation, I guess the easiest way is to create additional keyframes so that Blender knows better how to interpolate.
For example it begins to mess up at frame 9:

So move and rotate the bone correctly and create a keyframe (i):

Keep on doing it at frame 10 and 11, then you can come back and see if you can delete some.


.fbx and .obj files should be importable for most or any 3d applications.


Using the exact technique used by Leon Cheung in this answer: How to animate morphing a rectangular plane into a sphere.

Using two empties and two simple deform modifiers in bend mode.


Try to recalculate the normals of the mesh you have applied the material onto. If that doesn't work, try inverting the normal map by making the strength of the normal map negative (-1.000)


Unless I am misunderstanding your question. You should be able to just tilt the earth and then rotate it setting keyframes how fast you want to do it. It should still follow the parent.

Dont do anything to the parent just set keyframes on the earth itself by rotating Z space. Not sure what the wobble is, check the graph editor to make sure nothing looks weird there. Maybe apply scale CTRL + A. Make sure you dont have to many keyframes that is making it look weird.


Physics simulation won't run until the last frame of the timeline

The rigid body simulation does have it's own start and end.

In the 'Rigid Body World' settings you can change the simulation start and end.


2.8 - Do I still need to mark each animation action for saving?

So, did a little extra checking on the Blender Artists forums and it seems that, for the moment at least, Fake User is still required.

thedaemon:

  I’m still going to turn on Fake User because of the loss of animations
  before they fixed it. I don’t honestly know, I ran a test and it seems
  to save, but that was a quick test.

zeauro:

  Actions saving requires a user. If action is used by an animated
  object when Save operator is called : action is saved. If action is
  removed from object that is no more animated when Save operator is
  called, it appears with a 0 next to its name in actions list : action
  will be lost. If action has a fake user, you pressed shield icon
  before removing it from object that is no more animated when Save
  operator is called, it appears with an F next to its name in actions
  list : action is saved.


After importing the two objects in the same scene, select the shaped, shift select the base object and in the properties panel, shape key tab, select "Join as shapes".
The two objects must have the same list of vertices in order to work properly (they have to be one the modified copy of the other).


Mirror modifier making verticies overlap

Did you check the "clipping" option in the modifier's box?

You also could look into increasing the merge distance.


Render a layer only once for all 1800 frames?

Okay, so I rendered all the layers together for the first frame, but with compositing checked off. Then, in the image result viewer I selected only the atmosphere render result, saved that layer as a PNG, and then imported that PNG into the compositor as an image input node, replacing the atmo render layer input node and its connections.

Then to render the animation, I will uncheck or entirely delete the atmosphere object and render layer from the project, and Blender will now render the planet for each frame and composite that render layer with the single atmosphere image.

I did a quick test of render time for 27 frames (just an arbitrary number of frames I decided to stop on), and for this method, the render time was about 62% that of the old method.

Many thanks to @cegaton for the help, I feel weird answering my own question though.


Understanding (and fixing) non-manifold geometry

When you turn on edge-snapping, then try to snap a point to a vertex, the point will end up on the edge, not on the vertex.
Try the same procedure you gave with vertex-snapping enabled instead of edge-snapping. Everything should work as you expect.
Alternatively, when you merge points that are not in the same place, you can increase the merge distance. Or you could select a group of points you want to merge and merge to center, but your resulting cube is liable to be out of square.


How do I fix this Pinch-like effect on such model with Subsurf modifier turned on?

Just a slight change in topology fixes a lot of it:

(yours in blue, mine green)

Get the pole, (the 5-pointed vertex) off the angled edge, and on to a safe flat area, where it doesn't affect normal interpolation.
Put a holding loop in the front-to-back axis, and another loop on the flat, around the frame
Spread the curve-defining loops either side of the corner more evenly - in this case, they work better straightened out, I think.

When cutting sharp concave insets, corners, the secondary holding loops at a little distance, (like the one furthest to the left in the green topology) become quite important to keep the frame edges straight, and prevent new Catmull-Clark generated faces derived from large faces close to the corner 'leapfrogging': cutting the corner ahead of faces closer to it.

Maybe further improvements could be made by adding  a couple of edge loops to isolate the frame from the flat on the front.. (you could afford the polygons, I also reduced the Subdiv. from 5 to 2. :)

GG to slide a loop, followed by E to make the loop parallel to the next loop on one side, and F to flip which side, is a very quick way to straighten existing loops, try out variations, as is K (knife) followed by C constrain to one of the 45 degree angles , followed by Z to cut through the object: also handy when making repairs like this.


How can the Blender API be used to access Blender from another application?

Following the link in CharlesL's answer, I was able to find a Wiki entry that dashes my hopes. Apparently this is not possible in the way I had hoped.

http://wiki.blender.org/index.php/User%3aIdeasman42/BlenderAsPyModule


You can try with a mix of voronoi textures (with randomness = 0).
check this setup and result:


The circle wont render without it being distorted, how to make it smooth after render. Help

Ok...kicking myself after noticing the layers which are turned off in the layers panel still show up in the final render..

so... lesson learned... DELETE the layers you do not use as they will cause a problem.


How can you append a material with nodes?

Be careful not to confuse material nodes with compositing nodes. The composition nodes are kind of like filters or effects in a video editor, and are applied after or during the render on the image, rather than on the mesh. Your material nodes are being appended just fine, but the compositing nodes are not being appended since they are not related to your light saber object, but rather to the blender scene being rendered.

To copy them, you can create a node group in your original blend file, and append the node group from your second file, or you can click and drag to select all the nodes in the original blend file's window, and ctrl+c copy them, and open your second blend file and ctrl+v paste them. For more info, read this question How do you import a Compositing Node Set-up?.


I don't believe you can get a better result from a boolean modifier, they are nearly always messy, however, there are several ways to clean up a messy mesh.

Method 1:
Rather than fixing it by hand it might be easier to just add a 'Remesh' modifier which will try to convert the mesh to a quad based mesh.

Setting the remesh modifier to 'smooth' mode and upping the Octree Depth (think of it as resolution of mesh) will result in a cleaner mesh.

However, to get the the mesh as smooth as you want it may mean the resolution of the remesh would have to be quite high, but even at a lower resolution it can be a good starting point.

You could use a lower level remesh modifier and then a subsurf modifier after that to smooth it out again.

Method 2:
Another method is to select all the faces that make up the bottom of the mesh press F to make an ngon and then choose Ctrl + F > Poke Faces to subdivide them again. You would then also have to repeat this for the top of the mesh.

This should result in the 'topological cylinder' you mention in your question.


Cycles compute device for rendering is GPU but actually CPU get's used

solved it.. in the end looks like there were some leftovers from older versions of the nvidia drivers that were causing conflict because i wiped clean the pc and reinstalled the drivers and now gpu rendering works as it should.


While I am not familiar with the subject in question, one way would be to use a custom image and use it as an emissive shader.

image used: http://orig14.deviantart.net/3961/f/2012/050/a/f/wheatley__s_eye_by_mycroftporthos-d4qarjf.png

Obviously you can find a better image (more pixelated) or make your own and use some filter in photo editors app like Photoshop, Affinity, Gimp or whichever you prefer.
Photoshop has a bunch of filter under the category Pixelate.
Affinity also has a filter under the Distort category called Pixelate and I'm sure Gimp also has one.


A working guidance for building blender as bpy python module?

This issue should be fixed by commit 0a02c288aa258e18d19eff0be984f214d556b159

(27.03.2020)

  "install_deps: Enable PIC in Python static library."

I was discussed here: https://developer.blender.org/D7177

Also similar question here:

https://stackoverflow.com/questions/36779834/compiling-blender-bpy-recompile-with-fpic/60903565#60903565


I have found the solution for my question.

Increase steps value to above 6 or 8 in particle render tab.


You should activate the plugin "Node Wrangler" (it's awesome). Beside offering many Shortcuts and hotskeys it also offers to view every? possible output. To enable it open File > User Preferences...Ctrl+Alt+U and go to the Addons section. Search for "Node Wrangler":

Next you can go into your node editor and Ctrl+Shift+Left Mouse-click on the output node of your choice. It should have created a Viewer-node that is linked between the selected node and the Material Output.

You can now view the output from the node in any 3d-Viewport after switching to Viewport-Shading Rendered. To render faster you can switch to Object-Local-view. Just select the object you want to view and press Numpad /. This will temporarily disable all other objects and speed up the preview rendering. (If you don't have a Numpad, the setting can be found under View > View Global/Local)

Note: This plugin also offers much functionality. Just press Ctrl+Space in the Node Editor to see it for yourself.


I will post 2 ways to do that.

First way :

Select inner circles which you are going to straighten, hit X and select Edgeloops.
Use loopcut tool Ctrl+R and increase loopcuts to 2. These new loopcuts are your recreated circles, straightened along the line between outer circles

(Note that the angles of original circles if they were rotated aren't saved).

Second way:

(this way is a little tricky) If you do want to preserve original inner circles and not recreating them, then:

Select outer circles, hit Ctrl+E and select Bridge Edge Loops.

Use loopcut tool Ctrl+R and make 1 loopcut on the created bridge between the outer circles. Place it roughly at the place you'd like one of the inner circles should be.
Hit Shift+S and select Cursor To Selection. After that, while this created loopcut is still selected, hit X and select Edgeloop.

Select adjacent inner circle you are straightening, hit Shift+S and select Selection To Cursor (Offset). One of your inner circles is straightened now.
Repeat that for another inner circle.

Select outer circles, hit X and select Faces. This will delete additional geometry created by Bridge Edge Loops.


N-gons with a hole

Currently holed-ngons (e.g. a doughnut section) are not supported. If in the cutting process you are creating one of those, the software will try its best in finding a way to continue anyway (in this case by splitting the ngon in two and as a side effect deleting th inner face).

In the picture below you can see the difference of behaviour of the command upon the same mesh but with different topology:

I suggest to continue knife projecting the shape as you were doing and then simply re-fill the boundary with a new face. Just select the hole boundary and press F or with another method (e.g. fill holes operator).


How would I set up a smooth rotation for a angled object?

Setting up properly oriented origins for orientated objects with rotation applied.

After the orientation is lost, if there is the possibility of planar faces, it can easily be recreated.

Create a face, which is perpedicular to your desired orientation axis. ↹ Tab > ⎇ Alt RMB > F
Since my faces median is even at the desired center, I snap the cursor to selected. ⇧ ShiftS > Cursor To Selected

Add a helper object, in my case a cube. ⇧ ShiftA > Cube

Apply all transformations of the helper cube.
Activate snapping and set it to Closest Face.

Snap ON
Faces
Closest
Align rotation ON
Project individual[ly] ON

Grab the cube G and by moving it onto the helper face, it will align itself.
Snap it to the cursor afterwards. ⇧ ShiftS > Selection to Cursor

Select the original object  RMB, then ⇧ Shift RMB select the helper object, and join them ⎈ CtrlJ. The will merge into one object which still holds the helper objects orientation.
Delete the unnecessary faces and vertices.


Undesired different results with bevel modifier and vertex group

I found a reason.
Its because I have another window right next to this. So the vertexes are connected and take the edge in count when beveling so I would have to add another edge between them to separate or the better solution was as @lemon wrote to use edge weight.
Beveled by edge weight

When add a weight between the windows it makes the same artifacts like when I used vertex group that counted in that edges between windows.


How to generate a synthetic data similar to the real image

Here is a basic answer for such a broad question...

Since you say detail doesn't quite matter, you may find something like this interesting. for this approach I used meta spheres, and then  converted it over to a mesh.

Just so I steer clear of any trouble, here are is my source of the image used:
Pixabay Image Reference

Here are the results, and the Blend File:

Blend File:


Clean topology with holes in a mesh with bevel modifier?

This is my way of making holes. It's probably not the best one, but looks good enough for me.

1) We subdivide a plane one time to many, and select 4 quads for each hole.

2) We do inset. (I)

3) We use Mesh: LoopTools add-on (just enable it) using Cicrcle tool.

(in edit mode right click and then LoopTools->Circle)

4) Inset one more time. (I)

5) Extrude downwards. (E)

6) Add Subdivision Surface modifier

7) Smooth shading (subdivided 2 times)

8) Render Eevee

To make hole sharper you can make more insets, and extrude down several times to put loop-cuts in all holes.


Can't import more then one blend shape into Unity using Blender

Try this

apply all of your modifiers before importing to Unity

Your shape keys must be set to 0 influence in blender before being imported.

export from blender as an .fbx file.


If you want to test whether a variable exists, you can follow this solution and see if it's in locals() or globals().  So your code would be

if 'verts' in globals() or 'verts' in locals():
    verts.append([1,1,1])
else:
    verts = [[0,0,0]]
    edges = []
    faces = []


Algorithm of Blender's Proportional Editing- verts outside radius

The radius displayed is an indicator of influence from each of all selected.

A single vert selection only shifts other verts within the radius  Suggest the radius of influence applies from each vert.

Simple test on grid eg select two verts outside circle, appears to confirm this.

Notice with two verts selected on grid, both outside the displayed radius of influence, move verts of within the radius of influence of each.

Each vert that moves is within the radius distance of a selected vert.

In your question image no vert is being moved that is not within the radius of another selected vert.


Issues opening files created in 2.8 in 2.83

Actually, the problem with blender is that when you try to a file from an older version on a new version, or a file from a new version on an old version, blender sometimes doesn't find data that was present in the version the file was made in when trying to open on a different version. The best thing to do is open this file with 2.8 or tediously fix all the problems manually.
Hope it helps.


You can fix this problem by first triangulating the mesh you wish to carve holes into. The large ngons on the top and the bottom make it hard for blender to create these holes.

Go into Edit Mode, Tab
Select the mesh you wish triangulate, A or hover mouse of mesh and press L
Triangulate the mesh, CtrlT

You will notice that the error message under the modifier is now gone.