Is there a way to find out what is in the latest build?

Update

For bleeding edge changes and latest bug reports, even typo fixes you can access these feeds as well

https://twitter.com/BlenderLogs

https://twitter.com/BlenderBugs

There isn't a pretty or detailed view like the release logs for the latest builds, one way you can keep up to date with commits is to go to projects.blender.org developer.blender.org. As a new commit is made, it is updated there along with the revision number, files changed and or features added.

Additionally, if you are on twitter or Google+, Adventures in Blender posts about the latest additions or changes in detail with additional links at times. For example.

You can also now view the shortlog on git.blender.org for a quick summary of commits/fixes.


My armature is not effecting the right arm of my mesh

You need to apply your mirror modifier of your mesh before parenting.
This is the steps I did:

Go to the mirror mesh modifier and apply it
Go to to the vertex groups and delete all groups as shown:

Select Mesh then armature then hit ctrl+P and automatic weighting

This is the result after these steps:

The updated .blend file can be found here:


I believe your problem's issue is that you are in the view Material Preview instead of the correct view Rendered View.
You can also easily toggle these views with the Z key shortcut menu.


There are three main steps to any 3D project, you have Modeling where you create the actual geometry and polygonal detail. You have Shading, which is creating the materials/shaders, and then you have Lighting which defines how all the previous parts interact to make a final image.

I think your issue in this instance is you have an object (modeling) and a material (shading) but your lighting is off. Here is an example:

Here the lamp is one unit from the surface of the plane, light has a sharp falloff and is very bright.

Here is the exact same scene, with the same lamp moved up one unit. The falloff is much softer and any reflections and shadows will be softer as well.

Based on these examples, it is easy to see that the position of your lamps is very critical to how your scene will end up even if your modeling and shading is perfect. Sadly lighting is a very in-depth topic and isn't really within the scope of this site, but feel free to check some of the linked references below.

Helpful links:

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

https://www.youtube.com/watch?v=m-N149FMlWk

https://www.youtube.com/watch?v=7o0PauhFQyo


Intersecting a plane with another plane, creating a cut (Boolean/knife project doesn't work)

A bit of depth seems to help. In the following image the target of the modifier has some depth (using Boolean Difference) and it seems to work nicely.


If its a texture and you want to animate that check UV Wrap modifier in the modifier tab of the object.

Then, you can animate the texture in the Transform options of the UV Wrap modifier.


View and Render Layers are working similar to 2.79 but sadly EEVEE can't use Material/Object Index Pass. So you can't make a portal using this method. Read more here and watch video from the links: Blender 2.8 - Object index pass in Eevee

How to replicate it using different method

I've created two Collections - Portal and Behind_portal and also two View Layers accordingly.

To exclude Collection from View Layer - select it and press E or RMB > View Layer > Set Exclude.
In Compositing I've used Color Key to "remove" color of Holdout shader assigned to portal. I've also scaled a bit result and blurred it, as Color Key is not 100% precise.


how to avoid straight lines in normal maps

Did you use a margin when baking and did you leave enough space between the UV-Islands? Blender is approximating the map at the seams and if your image doesn't reach all around the UV-maps (e.g. your UV-coordinates are right at the edge of the UV-grid) Blender has problems approximating this edge smoothly.


Automatic weight, which can fail for a lot of reasons in every non-manifold mesh, is not suitable for robot-like movements, because it leads to stretch the body parts with an "organic" feel, that is not robotic at all. When parenting (Ctrl P) use the option "with empty groups" instead. Then select all vertices of a rigid body part (i.e. the forearm), select the appropriate vertex group and click "assign". Repeat for every bone of the rig.


How to move an object without it completely teleporting somewhere else?

Judging by the video, it looks like you are constantly pressing the middle mouse button while moving the cylinder. Constantly pressing the middle mouse button and moving the mouse switches the axis and moves the object on that axis. This happens again and again which causes the teleportation effect.
You can fix this by:

Releasing the middle mouse button after selecting the required axis.
Instead of using middle mouse button, using X,Y,Z on keyboard to lock the axis.


How to select all textures used by all active materials in the scene?

If you save then reload your file, Blender will get rid of the unlinked (unused) images. (and Materials, by the way)

Then you can use File/External Data/Pack all into file, you should end up with a .blend that contain every image used in the scene.

If you need to keep them as separated files, you can copy your packed .blend in a different folder, then use External Data/Unpack all into files.


Unless, for some reason, you need your dominoes to be an array, one approach, as mentioned, is to start with an Archimedean spiral curve, and use dupliframes. A curve deform modifier will deform your dominoes.

In User Preferences (CtrlAltU) > Add-ons,  enable Add Curve: Extra Objects.

Create and adjust an Archimedean spiral, as a NURBS curve.

Arrange your domino so its origin is at the point you would like the lie on the curve, and, for convenience, so that its 'forward' face looks down global Y.

In the curve's properties, 'Data' tab, check 'Path Animation' and inside that panel, 'Follow'.

Select the domino, then the curve, setting the curve to be the domino's parent. (CtrlP)

In the domino's Properties, 'Object' tab >  'Duplication', select 'Frames', setting 'Start' and 'End' to adjust the region of the spiral over which the domino is to be duplicated. Uncheck 'Speed'

The frequency of dominoes on the curve can be adjusted by the total number of frames in the curve's Path Animation.
Other tweaks available, as per manual.

To convert the duplicate dominoes into linked instances: select the dupli-domino, ShiftCtrlA .. (Make Duplicates Real).
To unlink the object data, and make independent meshes: select the instances, hit U .. (Make Single User). From the Toolbar, check the options 'Object' and 'Object Data'.
UPDATE for Blender 2.8:
Now 'DupliFrames' have gone, another approach is to create a carrier for your duplicate object, whose distortion you don't care about.

Create the spiral curve as before
Create a small plane, same origin, say, up in Z
Assign the plane an Array modifier, constant offset, count set to 'Fit Curve', targeted on the spiral.
Also give the plane a Curve modifier, targeted on the spiral, deformation direction Z.

(left, illustrated)

Now you can create a domino. Its Z will face down the plane's normal..
.. when you parent the domino to the plane, and in the plane's Properties > Object tab > Instancing panel, set 'Faces'.

If, for example, you wanted variations in transform, or a variety of objects on the spiral, you could use the modified plane as a Particle emitter, one per face, instead.
Edit: (response to comment from @Ron Jensen) To make the domino duplis into a real object, to use as a Boolean Cutter..

Arrayed Plane selected, CtrlA > 'Make Instances Real'

CtrlJ Join selected instances of the domino into a new object, and use as a cutter.

I haven't found a way of cutting with a collection instance, which would have been nice, to save data?


character splits in half when moving leg

To avoid this problem you should had the "clipping" option checked in the mirror modifier. Now simply go to rest pose (select all bones, then press Ctrl+G, Ctrl+R, Ctrl+S), then in edit mode select all and remove doubles, or manually join (Alt+M) the unconnected vertices, which probably are one on top of the other.


Can't get smoke from Quick Object - Smoke Setting

Is your outer "smoke box" being used as domain and is "adaptive domain" checked? Make sure the smoke has room to move.

From this tutorial, which might help:
https://youtu.be/6DjGpppAUfI?t=147


Is there a way to make a five sided bolt out of a 32 sided disk opening?

You must already have thought about this way but I'm not sure there's any other way around (by the way you could have used less than 32 vertices):

Create a 5 vertex circle (pentagone).
Subdivide it until it gets 30 vertices.
Select 1 of these vertices, ShiftCtrlB to bevel it. Do the same thing with another one. You now have a 32 vertex pentagone.
Bridge the cylinder with the pentagone.


My point light doesn't appear in cycles render, why?

Check your Outliner, or press AltH to unhide everything, you have a plane that is hidden in Viewport but not in Render, and it makes a big shadow on your scene.

Here you can see how the hidden plane is interfering with the light:


How do I mute the audio on a video and replace it with another audio file?

I've never used the video editing feature of Blender but I gave myself a try at seeing this question.

This is the same process as other non-linear video editing program, you can delete/mute the original sound track and import your denoised one.

Firstly go to video editing layout in Blender.

Import your video/audio file at here.

You can press "G" to move its position. "Shift" for precise slower transformation.

So here's the video track, combined with audio and image frames. Then delete the audio track imported from your video by pressing X or "Delete".

Import your denoised audio, and shift the new audio track to the same starting frame to make both sync.

Preview your work by "Alt+A", remember to change the end frame number larger than your imported one.

Then go to Properties panel:

Go to output tab and change the format to "FFmpeg video" to use the MPEG encoder so that you can output it as an MP4 video in acceptable file size.

Then go to "Video Sequence Editor" panel and start rendering with "flim clapper" button.

In conclusion, the process is easy and clear: remove the original audio track, import your processed one, and render it! All you have to learn is about the Blender flexible UI layout and operation based on shortcuts.

Enjoy!


UV Editor does not preview the corresponding image texture of selected object

Try to exit the edit mode (in the right half of the screen) and switch to "rendered view" instead of "material preview" on the top right. In this way your rendering engine (usually Eevee or Cycles) is used to generate the preview instead of the Viewport engine. Depending on the options you've chosen, they might only be available with these rendering engines.


I think what you're looking for is the F key, this joins any selected faces if it makes sense topologically.

But, you will get an Ngon on that face.


How can I create pre-rendered animated sprites with Blender and use them in Godot game engine?

Note: for this demonstration I have used the character Akai E Espiritu and the animations Idle (looking left and right) and Standard Run from https://www.mixamo.com/. The animations were exported in FBX at 60 FPS.

Note 2: it is possible to use pre-rendered sprites in a 3D view, it is called an Imposter Card. It is useful on assets like fences and wood planks bridge like in Rayman 2. And also for characters (they can be animated), trees and building far away like we often see in car games. In 3D you won't need to render the lighting information but the color, roughness, metallic and a normal map. More informations: https://youtu.be/YvOhIFnAa8U
You can also use Billboard, it's 2D images always facing the camera,you can use Sprite3D or AnimatedSprite3D for that in Godot.

Download the Godot project and the .blend used to generate the sprites: https://drive.google.com/file/d/1Pqz6iRkdhgR2prsMmH_R-S-cnmXkqxNu/view?usp=sharing

Benefits of using pre-rendered sprites

Those types of games age very well because they use realistic lighting, shadows, material and have smooth interpolated animations. To remaster them the only thing necessary is to increase the screen resolution setting, if the sprites becomes too tiny the sprites just have to be be re-rendered at an higher resolution and the source images overwritten.
You get a good result and can fake a top down 3D game, it is ideal for an RTS, MOBA, adventure game, top down shooter and more.
Very low system resources are required, this allow to display thousand of characters on an old computer and even a mobile device at the same time. A basic AI would take more computing power than the animated sprites.
You save a lot of time, you can create very smooth animations at 60 FPS and get every angles. You have nothing to draw.
You can edit your animations, models, shaders then re-render it to overwrite your image files.
If you are making a plateformer you will only have two directions to render or a single direction if your sprite and animation are symmetrical allowing to quickly implement your sprites and actions.

Games that use(d) this technique

A lot of Real-Time Strategy games (Age of Empires II, StarCraft, Diablo II, Ceasar III, Red Alert, Heroes of Might and Magic..) and Real-Time Tactic games (Commandos, Desperados, Robin Hood) and some adventure games (Heart of Darkness, Toy Story), RPG (Final Fantasy VII), some SNES games (Donkey Kong Country, Killer Instinct, Toy Story) used this technique. This technique was mostly used in early 2000 when the power of computers were limited.

At that time almost all the best looking 2000s isometric games were pre-rendered and today they often look better than most 3D games because they allow to get almost an infinite amount of details as long as the texture resolution allows it: https://www.kotaku.com.au/2013/03/the-best-looking-isometric-games/

They often age very well. When Donkey Kong Country showed the first pictures of the game, the journalists thought this was a sneak peek of the new Nintendo 64 and it looked better than almost all the 32 bits games available at that time.

BLENDER PART

Cycles render will be used to generate the sprites.

Ground with shadow catcher

You need an invisible ground used to catch the shadows projected by the sun. Add a plane, scale it by 10 and center it (Alt + g). To make it invisible but catch the shadow go in the Object tab of the property panel (the icon is a cube) and at the bottom in Cycles Settings check Shadow Catcher.

Asset settings

Your model must be above the ground and all your animations must loop.

It is important that you animate your asset in different actions and not pack all your animations in the same timeline. This will later allow to play all the actions at once to position the camera correctly because once the camera will be positioned it will need to keep the same coordinates for every other sprites of the same asset.

Duplicate your character and set a different action in each layer, this will allow to switch between animations by enabling a layer.
Use the first layer for the ground and sun, this layer will always be enabled to bake your sprites.

Render settings:

Add a sun for his orientation I recommend you to set it completely vertically, it will allow you to make the shadows fit in the sprite more easily to avoid having to unzoom (and make the sprite more pixelated) and to flip it for the movements on the side if the asset and animations are symmetrical. If you want to use an angle for the sun use a small angle, like 35 degrees maximum. I recommend you a strength of 100 for the sun.
Enable the Sky Texture with a strength of 10.
Enable Filmic in the Scene tab of the property panel, Color Management and View.
Enable transparency in the Cycles render settings, Film and check Transparent.
The direct lighting must not bounce, this is to avoid to get a noisy shadow or large shadow area on the ground that could get out of the camera border. In the render settings, in Light Paths use the Direct Light preset.
I do not recommend you to enable denoising because black pixels could appear, instead increase the samples if needed.
Set the render samples to 200 minimum.
In Output set the file format to PNG 8 bits RGBA and set the output path, you can add a prefix like Heroe_ (I explain bellow how to organize your folders).

Camera settings:

Set your camera in orthographic view mode and the render resolution. For a retro game style or a game where the assets are displayed from afar like a strategy game or simply to save space and memory you can use a low resolution. I will use a render setting of 64x64 for my character, do not forget to set the percentage scale to 100%.

On most isometric games the camera angle is like this:

X: 60
Y: 0
Z: 0 or 45

I recommend you to keep the Z axis at 0 degree to render your character with different orientations and 45 for your building.
For your character you can generate a sprite oriented in 4 directions by incrementing the Z rotation of the camera by 90 degrees or in 8 directions by incrementing it by 45 degrees.

To place your camera center it with Alt + g, go in Camera view with the key 0 of the numpad, press G to move it then press your middle mouse button and drag the mouse to the bottom to move it backward. This is just to make your asset visible, to unzoom change the Orthographic Scale in the property panel.

Add an empty at the center of your scene and make it the parent of the camera (select the camera first, then the empty with shift then press Ctrl + p and click on one of the setting).

To know the best position for your camera display all your animations at the same time by pressing Shift on the layers to open them. Set the animation frame when the character does a long movement like for example the leg behind when running. Rotate the empty and check if everything is visible in the camera border, don't forget to check the shadows too by enabling the rendered view.

After that change of key frame and check another action of the character with a big amplitude like an attack with the hands or sword forward. The border of the camera from the previous action must not be changed, you can only unzoom and move the camera slightly.

Folder structure

Create your folder structure directly into your game's folder, for example from the root of your Godot project.

You can put all those folders inside a GFX parent folder:

-> Sprites

--> Characters

---> Heroe

----> Run

-----> Down

-----> Left

-----> Up

-----> Right

If you use 8 directions don't forget to add those folders:

-----> Down Left

-----> Down Right

-----> Up Left

-----> Up Right

Render the sprites

Important: do not render the last frame of your animation so your character can loop correctly.

Enable the first layer which contain the ground and sun only and enable the layer of the character action you want to  render.

Click on your rigging to see the number of frames used and set it at the end frame of your animation.

Click on Animation in the render properties or press Ctrl + F12 to render it.

Each frame will be saved and each time you will switch back to Godot the sprites will be imported or updated.

GODOT PART

Import settings

In Godot select all your sprites with Shift, in the Import tab uncheck Filter or set the preset to 2D Pixel. The filter blurs your image, it behave like an anti-aliasing to avoid flickering but if you have used a low resolution and don't want post-processing for a retro style looking game or simply want to display the source images untouched I suggest to disable it.

You can also get a bit more anti-aliasing by increasing the render samples.

Using the sprites

Add a KinematicBody2D with two children: the AnimatedSprite node and the CollisionShape2D. For the collision use a Circle shape on the feet of your character. Don't move anything excepted for the AnimatedSprite node, this is because your sprite must be  to get his correct Y position in order to fix the visibility of it (in the "Fixing the depth" section).

The sprites with the collision looks like this:

Create different animations, to nae them indicate the action and the direction like this: "runUpLeft". For 8 direction here are all the actions you should get (you can use spaces):

idleDown
idleDownLeft
idleDownRight
idleLeft
idleUp
idleUpLeft
idleUpRight
idleRight
runDown
runDownLeft
runDownRight
runLeft
runUp
runUpLeft
runUpRight
runRight

Do not forget to set the correct frame rate and to check if loop is enabled or not.

The script

In the script create a direction string variable it will allow to keep the same direction for the idle action after running.
Add a speed variable, to adjust his value use the running to the left or right sprite and try to match the legs with the movement speed so the character doesn't slide.
A motion variable is use to move the character, it is a Vector2().
The motion variable is equal to the multiplier time the speed. The multiplier is in each input condition it is used to set the direction and to reduce the speed. In up and down the speed is halfed because in isometric the scale ratio is equal to 2:1. In diagonal we reduce the speed by 1/4, so it is 1*(3/4) = 0.75 for Y and 0.5*(3/4) = 0.375 for X.

Here are the vectors multipliers:

In each key input condition we must indicate that the other keys must not be pressed at the same time or multiple actions will try to be played at the same time.

The script looks like this:

extends KinematicBody2D

var speed = 12500
var direction = "Down"

func _ready():
    Input.set_mouse_mode(2)

func _physics_process(delta):

    var motion = Vector2()

    #Run

    if Input.is_action_pressed("ui_up") and not Input.is_action_pressed("ui_down") and not Input.is_action_pressed("ui_left") and not Input.is_action_pressed("ui_right"):
        direction = "Up"
        $AnimatedSprite.play("run" + direction)
        motion = Vector2(0, -0.5)

    if Input.is_action_pressed("ui_down") and not Input.is_action_pressed("ui_up") and not Input.is_action_pressed("ui_left") and not Input.is_action_pressed("ui_right"):
        direction = "Down"
        $AnimatedSprite.play("run" + direction)
        motion = Vector2(0, 0.5)

    if Input.is_action_pressed("ui_left") and not Input.is_action_pressed("ui_up") and not Input.is_action_pressed("ui_down") and not Input.is_action_pressed("ui_right"):
        direction = "Left"
        $AnimatedSprite.play("run" + direction)
        motion = Vector2(-1, 0)

    if Input.is_action_pressed("ui_right") and not Input.is_action_pressed("ui_up") and not Input.is_action_pressed("ui_down") and not Input.is_action_pressed("ui_left"):
        direction = "Right"
        $AnimatedSprite.play("run" + direction)
        motion = Vector2(1, 0)

    #Run in Diagonal

    if Input.is_action_pressed("ui_up") and Input.is_action_pressed("ui_left") and not Input.is_action_pressed("ui_down") and not Input.is_action_pressed("ui_right"):
        direction = "UpLeft"
        $AnimatedSprite.play("run" + direction)
        motion = Vector2(-0.75, -0.375)

    if Input.is_action_pressed("ui_up") and Input.is_action_pressed("ui_right") and not Input.is_action_pressed("ui_down") and not Input.is_action_pressed("ui_left"):
        direction = "UpRight"
        $AnimatedSprite.play("run" + direction)
        motion = Vector2(0.75, -0.375)

    if Input.is_action_pressed("ui_down") and Input.is_action_pressed("ui_left") and not Input.is_action_pressed("ui_up") and not Input.is_action_pressed("ui_right"):
        direction = "DownLeft"
        $AnimatedSprite.play("run" + direction)
        motion = Vector2(-0.75, 0.375)

    if Input.is_action_pressed("ui_down") and Input.is_action_pressed("ui_right") and not Input.is_action_pressed("ui_up") and not Input.is_action_pressed("ui_left"):
        direction = "DownRight"
        $AnimatedSprite.play("run" + direction)
        motion = Vector2(0.75, 0.375)

    #Idle

    if motion == Vector2():
        $AnimatedSprite.play("idle" + direction)

    #Make the character moves
    move_and_slide(motion * speed * delta)

    #Quit the game with escape

    if Input.is_action_just_pressed("ui_cancel"):
        get_tree().quit()

You can improve the script by creating a string variable called "state", the variable will have the string "walk" by default and the string "sprint" will get assigned while the key Shift will be pressed. You will need to replace the prefix "run" of the script by the variable.

You can also add a timer, when a key is pressed the countdown is reseted. When no key are pressed and the countdown reaches 0 you can add an extra animation, like the character sleeping or dancing (or one of both with a randi() % 1).

The result

Fixing the depth (sprite in front of another)

In a top down 2D game, bellow is closer to the camera so a sprite bellow another must appear in front. By default the sprite visibility priority is set by the Z index then the position in the node hierarchy.
To set the sprite bellow on top of the others you just have to add all your sprites as a child of an YSort node. You can eventually add them as a child of a TileMap node an check Y Sort.

TIPS

Adding contours

You can add contours in the compositor by plugin the Alpha output of your image to a Filter > Dilate/Erode node. Use a negative distance, then multiply it with the original image with a Color > Mix node. You can then render the animation, the contour will be added automatically on every images.

Use 4 directions

Instead of 8 directions use 4 directions only, do not use the diagonal inputs script. This will also divide by two the amount of sprites used in your project.

Low game resolution

To get a retro look you can reduce the resolution of the game and keep this resolution in fullscreen mode. For that go in Project > Project Settings, in Display > Window and divide the 1920x1080 resolution by the same number to keep the same aspect ratio. For example 640x360 by dividing by 3.

Check the fullscreen button. At the bottom at Stretch change the Mode to "2D" and the Aspect to "keep".

You can also use the camera zoom setting but decreasing the game resolution in the Project Settings slightly improves the performances.

Low framerate

To reduce the framerate you will need to reduce the animation scale to delete keyframes and will need to rebake your sprites.
Before starting duplicate your original animation in a backup folder because animation data will be lost.

Select your rigging, in the graph editor go in the first frame, select every frame with the "a" key then press S then the number you want. If your source animation is at 60 FPS and you want to reduce it to 15 FPS you will need to divide the scale by 4, so type 0.25. With a scale of 0.1 the framerate will be reduced from 60 FPS to 6 FPS, ideal for a Game Boy type of game. Again do not render the last frame especially in low framerate or your character will do a long pause between the last and first frame.

Don't forget in Godot to set your animation at the same framerate.

8 to 256 colors

You will need to download a batch processing image to import all your sprites and reduce the indexed colors between 8 to 256 colors. SNES games used 16 colors (15 colors + alpha) and old PC games like Age of Empires II used 256 colors (255 + alpha).

You can use Positioned dithering (because for retro game look because less efficient) or Floyd-Steinberg dithering to improve the color transition.

A software you can use is XnConvert: https://www.xnview.com/en/xnconvert/#downloads

Once you have opened it, do Add folder, you can add the entire Godot game project if you want to change every images.

Go in the Action tab, you will find the Color Depth in Add action > Image > Change color depth. You can also find presets in Add action > Misc > Retro.

Once it's finished click on Convert.


How to model this in a flexible and nondestructive way?

Make the bracket shapes, and set up an armature to deform them. Maybe just make one bracket and use a mirror modifier to copy it after it’s been deformed. Next, make a heavily subdivided plane, and put it where it would be if it was over the bracket’s location but they weren’t there. Use the shrink wrap modifier on the plane, and I think there is a setting where you can tell it to only deform along a certain axis, and make sure it stays outside of the target mesh.


So as suggested by @LukeD I was over consuming my video memory. I was able to fix the issue by taking off the subsurf modifier and the metal material. Will look into issues with that. Thanks for replying.


Align object after Motion Tracking: Edited

I do not fully understand your question, which is probably why it didn't receive much attention, but I'm still going to try to explain the problems that I do understand.

From what I understand, you go onto explain how you tracked the object in the video, and then ask how to align it now using the tracked info.

In the Tracking, after you have successfully tracked the object, under Reconstruction, hit Empty to Track.

After doing this, switch back to the 3d viewport, and then you will have a bunch of empties wherever Blender thinks your trackers were. You will find that these form a box (If you have tracked successfully. Also, you may need to take footage from other angles as well, and perform the same steps on them). If you did take footage from other angles as well, then delete the overlapping empties. Now, it is just a simple matter of assigning the vertices of your box to the corresponding empties.

Or, if that is too hard, then you could just do it by hand, which isn't too hard either.

Again, this is pieced together by what I do understand of your problem, which isn't a lot, because your question isn't quite phrased together too well.

I hope this solved your problem, and have a wonderful day.


Can anyone get RenderMan to install in the latest version of Blender 2.8? I have tried everything that I can think of

I believe that I found the answer here. https://blenderartists.org/t/pixar-renderman-for-blender/646404/635

The RenderMan for Blender from Github is no longer compatible with 2.8.


Here you go: https://www.blendswap.com/blends/view/70570
It's from bashi, the links on his homepage don't work anymore. But he uploaded it to blendswap as well.


As an alternative instead of subdividing a plane you can create a grid object.

Then have 150 subdividsions for X and Y. And on top of that you can click on Generate UVs. No need to unwrap and all of this in object mode!


How to create volumetric/smoke material in blender game engine?

The trick: Set the object to 'shade smooth' and use the surface normal.
It doesn't work everywhere (such as the left edge of the object, but it works well enough in a lot of cases.
I use this trick quite often, for things like fire, which you can do with a single distorted sphere and some UV-scroll.

Note that this requires GLSL, and uses a node material.

If you mix it with a cloud texture you can make smoke/clouds:

The blend for the cloud can be downloaded from blenderartists


How do I control refractive properties realistically?

In physics, dispersion is caused because different wavelengths of light (colors) have different speeds than each other depending on the medium, and therefore have more or less refraction than other wavelengths.

Now in Yafaray, you have the basic IOR field, as seen below. But, the dispersion field is simply one field. To get accurate dispersion, you would have to enter the IOR for every single wavelength of light, because dispersion is not linear. It is a complicated relationship. But, since Yafaray only has a single slider (Dispersion Power) that affects dispersion, I'm not sure if it is the right tool.

Here is a good list of refractive indices.

My comment stated: 'Two words use Cycles.', but I didn't know that Cycles doesn't have dispersion/caustic support (YET). You might want to check out LuxRender, but I believe that it hasn't been updated since 2009.


Example of persistent usage of «bpy.msgbus» and how to manage it?

The PERSISTENT option doesn't make the subscription remain active when loading files. It is for ensuring that the subscriber remains registered when remapping ID data. Subscriptions will be removed when loading a new file. Persistent application handler appended to bpy.app.handlers.load_post can be used to call bpy.msgbus.subscribe_rna() when a new file is loaded.

bpy.msgbus.clear_by_owner() requires the owner that you've also passed to bpy.msgbus.subscribe_rna() as argument. It will clear all subscribers by this owner.

Below is an add-on that demonstrates the use of the msgbus. It creates a panel "msgbus" with two operators that allow to register/unregister a handler for the message bus. Once registered, whenever the active object changes, it prints information about it to the terminal/console.

bl_info = {
    "name": "Example add-on persistent msgbus",
    "author": "Robert Guetzkow",
    "version": (1, 0),
    "blender": (2, 81, 0),
    "location": "View3D > Sidebar > My own addon",
    "description": "Example add-on that uses msgbus",
    "warning": "",
    "wiki_url": "",
    "category": "3D View"}

import bpy
from bpy.app.handlers import persistent

# For more information see source/blender/python/intern/bpy_msgbus.c
# and https://developer.blender.org/P563

# Object that will store the handle to the msgbus subscription
subscription_owner = object()

def notification_handler(*args):
    print(f"Object: {bpy.context.object.name}, Location: {bpy.context.object.location}, Args: {args}")

def subscribe_active_obj(subscription_owner):
    # What the subscription is for, in this example the active object.
    # Note that for properties it may be necessary to use `path_resolve`
    # as shown in https://developer.blender.org/P563
    subscribe_to = bpy.types.LayerObjects, "active"

    # Subscribe to the msgbus to call the handler when the key is modified.
    # Please note that not every UI interaction will publish an update,
    # despite modifying the key you've subscribed to. For instance, when
    # subscribed to `bpy.types.Object, "location"`, changing the location of
    # an object through the move tool won't call the handler automatically,
    # while updating the location property in the "Tranform" panel in the
    # sidebar will. The publishing of an update can be forced through
    # `bpy.msgbus.publish_rna()`.
    # The "PERSISTENT" option ensures that the subscriber remains registered
    # when remapping ID data, it does not mean that the subscription remains
    # persistent when loading a different file. This can be accomplished with
    # a persistent application handler that is called on file load.
    bpy.msgbus.subscribe_rna(
        key=subscribe_to,
        owner=subscription_owner,
        args=("a", "b", "c"),
        notify=notification_handler,
        options={"PERSISTENT",}
    )

    # Register the persistent handler, ensures that the subscription will happen
    # when a new file is loaded.
    if load_handler not in bpy.app.handlers.load_post:
        bpy.app.handlers.load_post.append(load_handler)

def unsubscribe_active_obj(subscription_owner):
    # Clear all subscribers by this owner
    if subscription_owner is not None:
        bpy.msgbus.clear_by_owner(subscription_owner)

    # Unregister the persistent handler.
    if load_handler in bpy.app.handlers.load_post:
        bpy.app.handlers.load_post.remove(load_handler)

@persistent
def load_handler(dummy):
    subscribe_active_obj(subscription_owner)

class SCENE_OT_msgbus_register_active_obj(bpy.types.Operator):
    bl_idname = "scene.msgbus_register_active_obj"
    bl_label = "Register Handler"
    bl_description = "Register msbus handler for the active object."
    bl_options = {"REGISTER", "UNDO"}

    def execute(self, context):
        subscribe_active_obj(subscription_owner)
        return {"FINISHED"}

class SCENE_OT_msgbus_unregister_active_obj(bpy.types.Operator):
    bl_idname = "scene.msgbus_unregister_active_obj"
    bl_label = "Unregister Handler"
    bl_description = "Unregister msbus handler for the active object."
    bl_options = {"REGISTER", "UNDO"}

    def execute(self, context):
        unsubscribe_active_obj(subscription_owner)
        return {"FINISHED"}

class EXAMPLE_PT_panel(bpy.types.Panel):
    bl_label = "msgbus"
    bl_category = "Active Object"
    bl_space_type = "VIEW_3D"
    bl_region_type = "UI"

    def draw(self, context):
        layout = self.layout
        layout.operator(SCENE_OT_msgbus_register_active_obj.bl_idname)
        layout.operator(SCENE_OT_msgbus_unregister_active_obj.bl_idname)

classes = (EXAMPLE_PT_panel,
           SCENE_OT_msgbus_register_active_obj,
           SCENE_OT_msgbus_unregister_active_obj)

def register():
    for cls in classes:
        bpy.utils.register_class(cls)

def unregister():
    for cls in classes:
        bpy.utils.unregister_class(cls)

    # Unsubscribe and remove handle
    unsubscribe_active_obj(subscription_owner)

if __name__ == "__main__":
    register()

Please note that the message bus doesn't notify for every kind of update.

  The message bus system is triggered by updates via the RNA system.
  This means that the following updates will result in a notification on
  the message bus:

  Changes via the Python API, for example some_object.location.x += 3.
  Changes via the sliders, fields, and buttons in the user interface.

  The following updates do not trigger message bus notifications:

  Moving objects in the 3D Viewport.
  Changes performed by the animation system.

The implementation of the message bus can found in bpy_msgbus.c.


Toggle Grease Pencil "Use Lights" value using Python

You can use:
bpy.data.grease_pencils['GPencil'].layers['GP_Layer'].use_lights = False

The grease pencil object is:
gp = bpy.data.grease_pencils['GPencil']

Its 'GP_Layer' layer:
gp_layer = gp.layers['GP_Layer']

And its use lights property:
gp_layer.use_lights


Object rotates unexpectedly while following path

You need to apply the scale of your curve, it squashes the scale of the empty and therefore of the car:


Create a camera animation orbiting around your object:

How can I animate the camera in a perfect circular rotation around a fixed position?

You can also easily vary the height of the camera when it has TrackTo constraint. This animation should have as many frames as you want images.

Render this animation (CtrlF12) as image frames: Output options, see Workflow > Frame Sequence


duplicate a mesh on the top (many times)

In the Properties menu at the right, go to the Modifiers section:

Select Add Modifier and select Array:

Change the Relative Offset value on the top (the X axis value) to 0:

Change the Relative Offset value on the bottom (Z axis) to 1:

Change the Count value to however many duplicates you want:

If you actually want the original object on the top like in your example, change the Relative Offset bottom value (Z axis) to -1 instead of 1.

The duplicates will not be editable as actual mesh by default. The advantage to this is that you can change all your settings as many times as you want, but if you want actual mesh duplicates click the Apply button on the Array modifier.


Can I use an material texture to represent a surface of spheres?

Use a texture to drive a bump node. Plug Bump's "normal" output into the normal input of the Principled BSDF node. I can make a voronoi texture small enough to represent closely packed balls or bubbles. Then I can colour them as a group with a noisy texture. This hides the fact that each ball is not really coloured. Finally I use a 4D texture to animate the bubbles motion over time.

Here are the nodes :


Particle system not rendering, emitter rendering see-through

Use the rendered layer's image on top of the background plate using Alpha Over:


Is there a way to pull data from bpy.ops without putting the model into Edit Mode

Edit multiple objects.
AFAIK it is impossible to use bpy.ops.mesh outside of edit mode. It would be possible to emulate the select non manifold operator in object mode, however since all objects can be placed into edit mode at once, and the operator called once, it feels unnecessary to bother

As of blender 2.8 it is possible to edit a number of mesh objects at once.  So instead of "flashing" each object, select all the objects to edit, call the operator once, then output the meshes total_edge_sel count, or update all edit meshes by either toggling out of edit mode or calling Object.update_from_editmode() and read the selected edges, and count the edges selected, to get both the total and which edges are selected.
import bpy

context = bpy.context
scene = context.scene

# select and put all in edit mode
for o in scene.objects:
    o.select_set(o.type == 'MESH')
# make sure active object is included
context.view_layer.objects.active = context.selected_objects[0]
context.tool_settings.mesh_select_mode = (True, True, True)
bpy.ops.object.mode_set(mode='EDIT')
bpy.ops.mesh.select_non_manifold()

for o in context.objects_in_mode_unique_data:
    print(o.name, o.data.name, o.data.total_edge_sel)

Test run on 4 objects in image, two cubes, a plane and suzanne.
Cube Cube 0
Plane Plane 4
Suzanne Suzanne 42

Note the second cube shares same mesh as first (linked data), hence only one with unique data shown.


Looks like you are using Bevel on all of your corners?

Another method would be Extrude, Spin and Tweek. Lots of tweeking needed  :)


Alpha over layers but maintain environment background

Enable Environment in the render layers.

Enable Film, transparent.

Then composite your layers with transparency together, and place them over the Environment using Alpha Over.


How to get the entire list of operators?

Yes,
See: Help -> Operator Cheat Sheet

This operator is written in Python, See : startup/bl_operators/wm.py for the source is you like to get this data for your own use in Python.

The result can be viewed in the text editor:


How can I link the mesh data of several objects so they all use the same?

Select the objects you want to transform and then shift select the object that you want to clone to make it the Active Object.

Press the space bar and type "link data".
(or press Ctrl+L and select "Object Data", or use the menu Objects>Make Links Object Data)

The selected objects will then use the data from the active one.


How to extrude the selected faces of a cylinder symmetrically outwards?

If you want to extrude all the selected faces out the same distance along their individual normals simultaneously, press Alt-E instead of E.  Hope that helps!


Why is the preview image better quality than the rendered one?

If you notice , you have pluged the output of your denoise node in your viewer , if you want the results to be similar to the viewer node output , then you should also plug that into the composite node , the viewer node is only for preview and compositor makes changes in the render itself


In the outliner, switch the type of information to display to Blender File. Extend Current File > actions. There you have your Cube-Action – right click it and select delete. See screenshot below.


Looping an array and curve modifier animation of object moving along a path?

you can cut the animation so that when it reaches the endpoint it will restart. To do that you only have to reduce the time line that is in the bottom of your screen where you place the keys frames


Rendering a pupil within a glasses lens?

If you don't mind using OSL (that is, setting the render to Cycles/CPU, and checking the 'OSL' option) then you can look ahead down a ray, using a script.

This script returns the Pass Index of the next material encountered, continuing in the direction of the incoming ray, (so it won't, without improvement, take refractive/reflective deflection into account, and the lens is a single plane, without thickness.)

#include "stdosl.h"
shader NextIdx(
  output float nextIdx  = 0.0
)
{
  if (trace(P,-I,"mindist",0.00001)){
    getmessage("trace", "material:index", nextIdx);
  }
}

.. and can be used in a tree something like this, to make the 'glass' of the lens:

.. where the eye material has an Pass Index of 10, and everything else has an index of 0...

producing..

so in this example, the 'glass' is transparent to everything has a material Pass Index greater than 5, and diffuse grey to everything else.


How can I select top and bottom vertices at the same time in top view?

Either you go into wireframe mode Z or you click this little button:

This will set the limit selection to invisible too. Then select your vertices with B and drag. But: Be aware of these methods will select ALL vertices inside your selection (e.g. if you´ve a more complex mesh).


Prior to cutting the new geometry the transitions are smooth because the shading is a function of the average face normals connected to each vertex. Because each of those adjacent face normals is different as you go around the surface of the object, the transition is relatively smooth. It's a cheap but effective trick.

Once you start cutting into a face, you get new geometry which has a number of vertices which are surrounded by faces which have the same face normals, therefore the shading is 'flat' on those sections. The transition from surrounding faces onto that flat area is also abrupt, and more prominent with transitions between quads and triangles.

Read Blender docs about custom normals

possible solutions

A way out of that is to carefully adjust the positions of the new vertices such that they follow the inferred curvature, this doesn't have to be exact. as long as you get away from the faces all having the same normals on that spot.

The dark area just below the blue arrow indicates the flow that your geometry would need to have (seen from the side of that edited face). If you can move the internal vertices to match the curvature you'll get reasonable smoothing.
or adjust the vertex normals to follow the curvature, but (May 2015) this is not exposed to the UI, but can be scripted. Manual changes  might be overwritten by operations such as remove doubles / recalc normals.

Normal Edit modifier.  It takes a vertex group, and an object, and modifies the normals of the vertices in the vertex group to follow as if they eminated from the center of the object (radial) or directionally if you use a mesh object to help guide the normals.

Blender's Proportional Editing feature can help get nice curvature, but you'll have to experiment with it.


Whats the best format to turn a render into a poster?

First determine what size (in cm or inches) you want the poster to be.

Then decide on the quality of the print: find out how many DPIs you need for the purposes you are after. 300 DPI is the common reslolution for prints, but it might vary.

Find an online calculator to to determine the dimensions in pixels for your image you need to render.

Set your scene in blender to render using those dimensions.

Save to a Tiff or PNG file.

The biggest challenge for such a project is that you can preserve the colors and quality you see on your monitor to those possible on printed media. For that it's better to consult with the printing service you'll use,and find out from them what kind of image format they prefer to work with, and how to deal with color conversion from RBG to CMYK.

If possible print a small test.


Camera pivoting onto 3D Cursor rather than selected object

I've fixed the problem by unselecting the "Lock the Cursor" function on the properties panel under "Views". I've also found that the function also effect's your camera when your rotating the view (middle mouse held down and moving the mouse), so it pivots around the 3D Cursor rather then just rotating the camera.


In the compositor you can use the split viewer node.

From the manual:

  The SplitViewer node takes two images and displays one-half of each on each side (top socket on the right half, bottom socket input on the left). Use this node for making side-by-side comparisons of two renderings/images, perhaps from different render layers or from different scenes. When transitioning between scenes, you want to be sure the stop action is seamless; use this node to compare the end of one scene with the beginning of another to ensure they align.


I think I found the problem with that boolean: duplicate vertices!

I've hidden other shapes, to better see the two objects involved by the boolean, and here is you wrong result:

then I selected the "sun" shape, in edit mode and removed duplicates

It had 78 duplicate vertices:

And, after that, the shape works better with booleans...


Transparent texture makes the mesh transparent too

So here is the answer:

Thank you to Susu and Rob Proctor for the help! :)


Cylinder has small wierd bumps when using Subdivision Surface

This is how subdivision works with faces that are created by that many vertices.
You'll see that on other parts of the cylinder, particularly the quads, that this effect does not happen. It's less of a problem, and more of just how the modifier works.
To fix this I suggest two things:

Delete only the face on top and extrude the edges left behind inward a couple times.

Keep the face on top, but create an edge crease along the top of the cylinder, (and use Auto Smooth if needed)

Creating an edge crease is done by hitting Shift + E, and you'll have to scroll your mouse out to get the full effect. The Auto Smooth is located in the Data tab and controls which parts of the mesh are shaded smooth or not depending on their angle respective to another/other face(s).


how to make constant, looping animation?

Ok there are multiple reasons why this could be happening.
The first one is: You dont have linear interpolation
The fix for that is:

Go into the Graph Editor
Press V and select Vector

The second one is: your animation ends on the wrong frame or starts at the wrong frame. Make sure your last keyframe which is the same as the first one is never actually shown (or the other way round), because when it is, you have 2 exactly equal frames played in sequence. In practice that means you have to either put your first keyframe at frame 0 and start on the frame 1 and end at the last keyframe. Or you put your start and first keyframe on frame 1 and set the end to be 1 frame before the last keyframe.


Why does my texture image look compressed in the z direction on the side of this cylinder, but look perfect on the top?

Although I don't totally understand it, the solution seemed to be to change the texture coordinate to object, and select my cylinder as the target. :)


How do I make an object only visible when it is in front of another specific object?

I believe this is impossible to do with materials.  But I was able to get this effect with some render layers and compositing.

First put the front object in a separate layer than the rest of your scene.  Then set up two render layers, one which renders all the layers, and one which excludes the layer with the front object.  (Check out my explanation of excluding layers here).

Next give the back object a different pass index under the Object properties panel > Relations rollout.  And make sure that you have the Object Index, and Z passes enabled on your render layers (see above).

Then use the following node setup to composite the two layers together.

The Less Than node compares the z-depths of the two render layers to find where the animated Suzanne is in front of the other one, the Add and Greater Than nodes work as a logical AND operator between this and the ID mask of the back Suzanne.  So the mix node will grab the "main" render layer iff the animated Suzanne is closer to the camera and overlaps the other one in the rendered image.  Which, I believe, is the effect you desire.


What can I do to bring my hierarchy back?

You must have accidentally closed that panel.  You can actually make any panel in your view an outliner by clicking on the button on the top-left corner of the panel.
To open it again as it was, simply click and drag from the top-right corner of the properties panel and drag down, then change the new panel you just created to an outliner.


How to build and submit Mac builds to Graphicall?

There are easy to follow steps clearly outlined on the wiki. It tells how to setup the environment and how to download and build the source.

If you then go to graphicall and create an account, after logging in, there should be an option to upload a new build.

Update: To create an account on Graphicall.org, people now have to go to the IRC channel #blenderstorm on freenode and leave a request for an account (just preferred username + email-address is enough). An admin will create the account when the request is received.


BPY add keyframe to each curve after importing a sequence of .SVG files

check this out:
for files in glob.glob("*.svg"):
    print( files, "... imported!" )
    bpy.ops.import_curve.svg(filepath=files)
    bpy.ops.object.select_all(action='SELECT')

for i, obj in enumerate(bpy.context.selected_objects, 1):
    bpy.context.view_layer.objects.active = obj
    obj.name = "Curve" + str(i)

    for x in [10,20,30,40,50]: # the indentation in this line is important!!!
        obj.location = (0.0 + x , 0.0, 0.0) # ADAPT HERE

        obj.keyframe_insert(data_path="location", frame=x)

of course you have to adapt the line with "adapt here" to use some mathematics so that you get your progressiveley -> i have no idea what values you want to have there ;)
and of course you can do the "for x in " with a nicer loop...my version is for sure not the most elegant one - but the laziest one ;)


Rendering Engine:

First of all prefer Cycles Rendering Engine.
In Cycles Render you make realistic objects, text, characters, etc. And the workflow is quiet simple(according to me).

Modifiers:

Modifiers may help saving lots of your time making objects really quick.

Materials

Main part comes on materials, Materials can be anything that make your render look like real world that are colors, textures. Play with some of the material and you'll get an idea how they work.

Animations:

Learn some of the simple keyframe animations.It is simply moving objects here and there.

The Internet Thing:

There are thousands of tutorials who teach how animations work, adding materials, modeling. Internet is vast and you can learn almost everything. Thanks to Blender Stack Exchange that it has experts that if you don't understand some topics or you have some problem regarding your render, modelling,etc. you are free to ask.
I suggest you to go for tutorials by Blender Guru,  He is awesome.

Hope my answer was clear to you.
All the Best. Happy Learning.


There were several issues with your code:

The loop cut and slide operator is supposed to be executed from the 3D viewport. To execute it from other windows (Console, text editor, etc), you need to override the context.
You used an illegal value for the "falloff" parameter (used to be "Inverse_Square", I changed it to "Smooth". You can also choose: "SHPERE", "ROOT", "SHARP" or "LINEAR" if you prefer).

Here's the code:

import bpy

bpy.ops.mesh.primitive_plane_add()
bpy.context.object.dimensions[0] = 1
bpy.ops.object.editmode_toggle()

def view3d_find( return_area = False ):
    # returns first 3d view, normally we get from context
    for area in bpy.context.window.screen.areas:
        if area.type == 'VIEW_3D':
            v3d = area.spaces[0]
            rv3d = v3d.region_3d
            for region in area.regions:
                if region.type == 'WINDOW':
                    if return_area: return region, rv3d, v3d, area
                    return region, rv3d, v3d
    return None, None

region, rv3d, v3d, area = view3d_find(True)

override = {
    'scene'  : bpy.context.scene,
    'region' : region,
    'area'   : area,
    'space'  : v3d
}

bpy.ops.mesh.loopcut_slide(
    override,
    MESH_OT_loopcut = {
        "number_cuts"           : 2,
        "smoothness"            : 0,
        "falloff"               : 'SMOOTH',  # Was 'INVERSE_SQUARE' that does not exist
        "edge_index"            : 2,
        "mesh_select_mode_init" : (True, False, False)
    },
    TRANSFORM_OT_edge_slide = {
        "value"           : 0,
        "mirror"          : False,
        "snap"            : False,
        "snap_target"     : 'CLOSEST',
        "snap_point"      : (0, 0, 0),
        "snap_align"      : False,
        "snap_normal"     : (0, 0, 0),
        "correct_uv"      : False,
        "release_confirm" : False
    }
)


Metaballs show in rendered viewport but not in actual render?

You probably solved this by now but in case anyone is wondering - I had the same issue with emitting metaballs showing up fine in the viewport but not rendering. In my case the emitter object had rigid body physics enabled. Once I disabled that the problem was solved and metaballs rendered fine


Why same scene has diferent size when i export it to three.js and babylon.js

There are many reasons this could happen:

three.js and babylon.js formats are just different, and may encode things in different ways
the three.js exporter may be including extra data that isn't in the babylonjs file like normals or tangents (whether that's data you want or not, who knows)

tl;dr this is fine and normal. Whichever engine you decide to use, both support many formats (FBX, glTF, OBJ) and some may be more efficient than either JSON format. glTF and Draco are may give smaller sizes, in particular.


Move object to mouse position using python?

Can do this using bpy.extras.region_2d_to_location_3d
Here is a sample script using the Modal Draw Template script. As well as drawing a line, it moves the context object to the mouse cursor.  The depth is set to (0, 0, 0)
import bpy
import bgl
import blf
import gpu
from gpu_extras.batch import batch_for_shader
from bpy_extras.view3d_utils import region_2d_to_location_3d

def draw_callback_px(self, context):
    print("mouse points", len(self.mouse_path))

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

    # draw some text
    blf.position(font_id, 15, 30, 0)
    blf.size(font_id, 20, 72)
    blf.draw(font_id, "Hello Word " + str(len(self.mouse_path)))

    # 50% alpha, 2 pixel width line
    shader = gpu.shader.from_builtin('2D_UNIFORM_COLOR')
    bgl.glEnable(bgl.GL_BLEND)
    bgl.glLineWidth(2)
    batch = batch_for_shader(shader, 'LINE_STRIP', {"pos": self.mouse_path})
    shader.bind()
    shader.uniform_float("color", (0.0, 0.0, 0.0, 0.5))
    batch.draw(shader)

    # restore opengl defaults
    bgl.glLineWidth(1)
    bgl.glDisable(bgl.GL_BLEND)

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

    def modal(self, context, event):
        context.area.tag_redraw()

        if event.type == 'MOUSEMOVE':
            x, y = event.mouse_region_x, event.mouse_region_y
            self.mouse_path.append((x, y))
            obj = context.object
            if obj:
                loc = region_2d_to_location_3d(context.region, context.space_data.region_3d, (x, y), (0, 0, 0))
                obj.location = loc

        elif event.type == 'LEFTMOUSE':
            bpy.types.SpaceView3D.draw_handler_remove(self._handle, 'WINDOW')
            return {'FINISHED'}

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

        return {'RUNNING_MODAL'}

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

            self.mouse_path = []

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

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

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

if __name__ == "__main__":
    register()


The material isn’t glass in the principled shader - you have Metallic set to 1.0 and Transmission set to 0.0. It’s essentially a reflective metallic surface. If you don’t specifically need to use the Principalled shader then just delete that node and replace it with a Glass Shader node - much simpler to use. Alternatively, start by changing Metallic to zero and Transmission very close to 1.0.


Ok, so, here we go. This will be the final result:

Beginnings

I came at this task with a systematic approach. I would grade everything by color and sculpt to pull out different colored landmasses from beneath a water surface plane (the lowest object in the scene). The cliff background, along with rocks, trees, and bushes, would come last.

Background Image

I downloaded the image from your question and imported it as a Background Image in the 3D Viewport Properties panel. I set the Display Axis to Camera, because it was the only relevant place that I would need the image. I also changed the Draw settings to Front because I would need to still see the image above my models; it's too complicated to do everything in Wireframe View.

Camera Settings

I also adjusted the Properties panel > Render tab > Dimensions dropdown settings so that the image wasn't stretched.

I keyed Numpad 0 to switch to Camera View, zoomed in, and checked 3D Viewport > Properties panel > View dropdown > Lock Camera to View.

Utilizing the background image, I aligned the ground plane and default cube to roughly the same orientation as the camera. Note how the grid, just barely peeking through the background image, appears to be on the same plane as the water.

Lighting

Sun Lamp

Since this is relatively simple, we'll knock it out now. Select the default Point lamp and go to the Properties panel > Object Data tab. Set the Lamp Type to Sun. Set the Size: value to 0. Click Use Nodes, and set the Strength: value to 3.0. Make sure the Color is Hex: value FFFECC.

HDR

For added realism, I prefer to use an HDR Image as an alternate light source.

Go to the Properties panel > World tab > Surface dropdown. Click Use Nodes. Click the dotted button next to the Color: input and choose Environment Texture.

Open an HDR Image. I am using the one from BlenderGuru's Cherry Blossom Tutorial.

Modeling

...and a bit of texturing.

The Water

I deleted the default cube to start and added a plane (Shift + A > Mesh > Plane). I scaled the plane up until I deemed fit (23.13). I then popped over to the Properties panel > Materials tab, ensured that I was in Cycles Render, and added a new material. I kept the default Diffuse BSDF shader but set the color to color of the water. To do that, I...

...went to the 3D Viewport Properties panel > Background Image dropdown.
...increased the Opacity: value to 1.
...went back to the Properties panel > Materials tab > Surface dropdown > Color Selection option.
...used the Ink Dropper to pick the water color.
...went to the Properties panel > Materials tab > Settings dropdown > Viewport Color.
...used the Ink Dropper to pick the Properties panel > Materials tab > Surface dropdown > Color.

You can do that or use Hex value BADDFE.

The Sand

...and basically steps for the dirt and the grass as well.

This is what I call the lightish brown stuff in the image (Hex: FFE1C8).

I duplicated the plane and moved it lower by keying Shift + D, then Z, then -.5. I keyed Tab to enter Edit Mode, keyed W to open the Specials menu, and selected Subdivide. I keyed T to toggle open/close the Toolshelf. Under the Subdivide dropdown, I changed the Number of Cuts to 10, the max.

I then subdivided again, but this time only used 3 cuts. I keyed Tab again to exit Edit Mode.

Next, I traveled to the Properties panel > Object modifiers tab and added a Triangulate modifier. I clicked Apply to apply the modifier.

I entered Sculpt Mode via the footer of the 3D Viewport. In the Toolshelf, I made sure that all mirroring was disabled. I, personally, enjoyed using a brush size of 17 px. and a strength of 0.5. I sculpted everywhere I saw sand. I did this until I felt content.

A gif of a bit of me sculpting:

The Dirt and the Grass

This is what I refer to the low lying green and dark brown coloring as. You will want to do the same thing as with the sand except that you will want to use a different material. Also, where materials are concerned:

Grass hex: DBE492.
Dirt hex: B18E7D.

What I've got so far (note that there were some white bars at the top and bottom of the image that I downloaded. I added these in for consistency's sake. I will include a blerb about how you can include them later. Note that the alternative is either shrinking the camera dimensions or making more scene):

The difference between the two:

Greyish-Brown Cliff

Hex: C4A888

I started by adding a Cylinder and scaling it up by a factor of 11. I then keyed Numpad 7, Numpad 5 to enter Top Orthographic View. I keyed Tab to enter Edit Mode. I keyed A to deselect everything. I keyed Z to toggle in/out of Wireframe View. I Box selected the following vertices.

I keyed X to open the Delete menu and selected Vertices. I then rotated my view and selected the top vertices.

I keyed . to switch the Pivot Point to 3D Cursor, which should be at the center of the scene. I keyed E, then S, then Shift + Z, then 2 to plateau my cliff face. I keyed Numpad 0 to revert to Camera View, A twice to select everything, and G, then Z, then 2.5 to move the cliff up. I keyed S, then X, then 2 to scale my cliff. I keyed G, then X, then -5 to move my cliff left. Lastly, I keyed Alt +  RMB while hovering over the back vertices that we extruded out of the top of the cliff to select them and G, then Z, then 4 to move it up. At this point, I have a cliff that looks like the following.

Now I subdivided it (3 cuts) and triangulated. And sculpted. After sculpting, I had something like the following. It's not totally accurate to the image, but it does look good.

Last thing for the cliff. I extruded and assigned the grass material to the same mesh for the grass at the top left of the cliff.

Background rest of the cliff

Stone hex: C3C3C3
Red Rock hex: E7A17D

There's no easy way for me to explain this, but I basically divided it up into chunks by color and made pieces out of various stretched and sculpted cylinders. This was my result:

But this was my scene. Not pretty, but effective:

Fillers

Pine Trees

Hex: 90C785

These I made by adding a cube, scaling it up, and scaling it down at the top.

Obviously I had to scale them slightly differently for each instance. Also, I did some occasional sculpting of the landscape beneath the trees to make it fit them, rather than vice-versa. After some work, I achieved this:

Rocks and Shrubs

For this, I added various low poly spheres which I triangulated and sculpted and placed around. I added no new materials, choosing to use the existing Pine tree, Greyish-Brown Cliff, and Red Rock materials. After adding these features, I achieved this:

The Trees

Tree Bark hex: 91604C

These I made through the simple system of extruding a low poly cylinder up and up. This was the trunk, for which I added yet another material, this one at a Hex value of 91604C The leaves were copies of a bush using the Pine Tree material again. How I arranged them was quite clever, if I do say so myself...and I do.

In the Properties panel > Scene tab, I turned off all Gravity.
I duplicated shrubs around the top of the tree.
I added a Force Field > Force with a Strength: value of -20 to the top of the tree.
In the 3D Viewport > Toolshelf > Physics tab, I Add Actived all of the leaves.
I Add Passived the tree.

The setup:

After simulating:

After simulating, which I had to do by separate trees, I had to click Bake to Keyframes for each leaf and set the Start: and End: values to the frame that I liked (119).

After making the trees, the last thing, I produced the a result that only needed some minor post-processing, which I'll explain next, to look like the image from the beginning.

Post-processing

I used 1000 Render Samples and 256x256 tiles because I rendered on my GPU. As a rough guide, refer to the following chart by BlenderGuru. Make your own tests to find out what is the optimal tile size for your system and scenes.

For the compositing, I used these nodes to add the top and bottom white borders:

How this works:

The two Box Mask nodes create a two white boxes (top and bottom) with a black background at the specified coordinates for the specified size.
The Color > MixRGB > Add node adds all values white (1) to the other creating two strips with a black (0) background.
This can be used as a Fac: between a chosen color (which just so happens to be white) and the rest of the image that I want to show.

Once again, the final result:

The .blend file:

ARadish's modified .blend file, in which the compositing and tree leaves were changed:

ARadish's compositing and corresponding explanation:

  The compositing was meant to add sepia-ish tones to the image, and make the ambient shadows darker, and orangier. I added an AO (ambient occlusion) render pass under "Render Layers" and strung this to the blue channel of the original image. After recombining RBGA, i ran a tweaked line of the AO into the black levels of the image using RGB curves. This gives me darker shadows without changing the over all contrast of the image. A tad of color balance for sepia made the image get that softer feel.

Result from ARadish's .blend:


How can I get ripples with the Waves modifier in 2.8?

The Wave Modifier seems to be somewhat broken (or at least very unintuitive).
It works best with larger objects, and doesn't scale very well.

Here is an example of my settings on a 1x1m plane, just to help you out.
I couldn't make it work on a smaller plane.

And while this image from Blender Manual is sweet, the manual's reccomended settings don't seem to work well either.


I suggest start here: How to create a custom UI?

To extend the Properties Area of the 3D View you can either register a custom panel to add UI elements onto or you can append elements to existing panels.

1. Panel

Blender comes with a few UI templates (Text Editor > Templates > UI ...) . I'd suggest start with UI Panel Simple ui_panel_simple.py and use it as base to work on. You just have to edit its default variables in order to display the HelloWorldPanel as part of the properties panel:

Set bl_space_type to 'VIEW_3D' to make it part of the 3D View
Set bl_context to eg. 'mesh_edit' or 'objectmode' to either match Edit or Object Mode

class HelloWorldPanel(bpy.types.Panel):
    """Creates a Sub-Panel in the Property Area of the 3D View"""
    bl_label = "My Tool"
    bl_space_type = "VIEW_3D"
    bl_region_type = "UI"
    bl_category = "My Tools"
    bl_context = "mesh_edit" # "objectmode"

The HelloWorldPanel comes with a predefined draw method where you can edit the layout as well as adding UI elements to the panel. More interestingly: You can easily add existing operators like bpy.ops.mesh.primitive_cube_add() to the panel by calling the operator() method on the layout element like row.operator("mesh.primitive_cube_add") without the namespace (bpy.ops*).

row = layout.row()
# bpy.ops.mesh.primitive_cube_add()
row.operator("mesh.primitive_cube_add")

row = layout.row()
# bpy.ops.object.origin_set()
row.operator("object.origin_set").type="GEOMETRY_ORIGIN"

To pass multiple arguments read: How to pass multiple operator properties via UI layout?

2. Operator

If you want a custom function assigned to a button, you'll have to create a new operator. Blender comes with operator_simple.py template which is easy to understand. In most cases it's enough adding your code to the execute method, which will be called when the button is pressed.

def execute(self, context):
    my_variable = "Hello World"
    print (my_variable) # Prints 'Hello World' to the Console
    self.report({'INFO'}, my_variable) # Reports 'Hello World' to the Info Area
    return {'FINISHED'} # Return the execution is finished

If you want to call another operator as part of the operation like bpy.ops.mesh.remove_doubles() which only works on meshes, it's a good idea to limit the scope to mesh objects using the provided poll method, even if the operator is only accessible in Edit Mode because otherwise the operator is still callable using the Search Menu (F3):

@classmethod
def poll(cls, context):
    obj = context.active_object
    return (obj is not None and obj.type == 'MESH')

def execute(self, context):
    # Your code here
    bpy.ops.mesh.remove_doubles(threshold=0.02)
    # ...
    return {'FINISHED'}

Also read: What do operator methods do? (poll, invoke, execute, draw & modal)

If you want to display the vertex count after mesh.remove_doubles, you can store the vertex count before calling the operator and then report the actual result:

def execute(self, context):
    obj = context.object
    verts_before = len(obj.data.vertices)
    bpy.ops.mesh.remove_doubles(threshold=0.02)
    verts_after = len(obj.data.vertices)
    result = verts_before - verts_after
    self.report({'INFO'}, "Verts removed: {}".format(result))
    return {'FINISHED'}

3. Registration

Register your classes properly, add your operator(s), labels, and properties to the panel:

import bpy

class MY_OT_custom(bpy.types.Operator):
    """Tooltip"""
    bl_idname = "object.simple_operator"
    bl_label = "Simple Object Operator"

    @classmethod
    def poll(cls, context):
        obj = context.active_object
        return (obj is not None and obj.type == 'MESH')

    def execute(self, context):
        # Your code here
        # ...
        bpy.ops.mesh.remove_doubles(threshold=0.02)
        return {'FINISHED'}

class MY_PT_custom(bpy.types.Panel):
    """Creates a Sub-Panel in the Property Area of the 3D View"""
    bl_label = "My Tool"
    bl_space_type = "VIEW_3D"
    bl_region_type = "UI"
    bl_category = "My Tools"
    bl_context = "mesh_edit"

    def draw(self, context):
        obj = context.object

        layout = self.layout

        row = layout.row()
        row.label(text="Active object is: {}".format(obj.name))

        row = layout.row()
        row.prop(obj, "name")

        row = layout.row()
        row.label(text="Vertex Count: {}".format(len(obj.data.vertices)))

        row = layout.row()
        row.operator(MY_OT_custom.bl_idname)

def register():
    bpy.utils.register_class(MY_PT_custom)
    bpy.utils.register_class(MY_OT_custom)

def unregister():
    bpy.utils.unregister_class(MY_OT_custom)
    bpy.utils.unregister_class(MY_PT_custom)

if __name__ == "__main__":
    register()

Appendix

TLDR; If you want to 'remove doubles' (merge by distance) for multiple meshes in Object Mode for whatever reason, use the bmesh.ops.remove_doubles() operator as suggested by @batFINGER, it's 3 times faster.

bpy.ops.mesh.remove_doubles()

As of 2.8x we can enter Edit Mode for all selected objects simultaneously, which avoids looping over all the objects as well as switching to Edit Mode and Object Mode each iteration so your code can be simplified as follows:

def execute(self, context):
    # get all mesh objects in selection
    meshes = set(o for o in context.selected_objects if o.type == 'MESH')
    # store the vert count on all objects
    verts_before = sum([len(o.data.vertices) for o in meshes])

    # switch to edit mode
    bpy.ops.object.mode_set(mode='EDIT')
    # select all vertices
    bpy.ops.mesh.select_all(action='SELECT')
    # remove the doubles
    bpy.ops.mesh.remove_doubles(threshold=0.01)
    # switch to object mode
    bpy.ops.object.mode_set(mode='OBJECT')

    # store the vert count again
    verts_after = sum([len(o.data.vertices) for o in meshes])
    self.report({'INFO'}, "Verts removed: {}".format(verts_before-verts_after))

    return {'FINISHED'}

Although this saves a lot of time, it still takes 0.0814 seconds for 100 cubes with a vertex count of 8080.

bmesh.ops.remove_doubles()

    def execute(self, context):
        # get all mesh objects in selection
        meshes = set(o.data for o in context.selected_objects if o.type == 'MESH')
        # store the vert count on all objects
        verts_before = sum([len(o.vertices) for o in meshes])

        # Remove doubles using bmesh based on:
        # https://blender.stackexchange.com/a/68133/31447
        bm = bmesh.new()
        for m in meshes:
            bm.from_mesh(m)
            bmesh.ops.remove_doubles(bm, verts=bm.verts, dist=self.merge_dist)
            bm.to_mesh(m)
            m.update()
            bm.clear()
        bm.free()

        # store the vert count again
        verts_after = sum([len(o.vertices) for o in meshes])
        self.report({'INFO'}, "Verts removed: {}".format(verts_before-verts_after))
        return {'FINISHED'}

Bmesh method takes 0.0290 seconds for 100 cubes with a vertex count of 8080.

Final Panel & Operator

Panel in Object Mode and a proper implementation of the operator (Undo, Merge Distance etc.) in order to remove possible doubles for all objects in selection:

import bpy
import bmesh

class MY_OT_rem_doubles_bmesh(bpy.types.Operator):
    """Remove Doubles on Objects in Selection"""
    bl_idname = "object.remove_doubles_bmesh"
    bl_label = "Remove Doubles (bmesh)"
    bl_options = {'REGISTER', 'UNDO'}

    merge_dist: bpy.props.FloatProperty(
        name="Merge Distance",
        description="Merge Distance",
        min=0.0,
        step=0.1,
        default=0.02
    )

    @classmethod
    def poll(cls, context):
        obj = context.active_object
        return (obj is not None and obj.type == 'MESH')

    def execute(self, context):
        meshes = set(o.data for o in context.selected_objects if o.type == 'MESH')
        verts_before = sum(len(o.vertices) for o in meshes)

        # Remove doubles based on:
        # https://blender.stackexchange.com/a/68133/31447
        bm = bmesh.new()
        for m in meshes:
            bm.from_mesh(m)
            bmesh.ops.remove_doubles(bm, verts=bm.verts, dist=self.merge_dist)
            bm.to_mesh(m)
            m.update()
            bm.clear()
        bm.free()

        verts_after = sum([len(o.vertices) for o in meshes])
        self.report({'INFO'}, "Verts removed: {}".format(verts_before-verts_after))

        return {'FINISHED'}

class MY_PT_custom(bpy.types.Panel):
    """Creates a Sub-Panel in the Property Area of the 3D View"""
    bl_label = "My Tools"
    bl_space_type = "VIEW_3D"
    bl_region_type = "UI"
    bl_category = "Tool"
    bl_context = "objectmode"

    def draw(self, context):
        sel_objs = context.selected_objects
        sel_vert_count = sum(len(o.data.vertices) for o in sel_objs if o.type == 'MESH')

        layout = self.layout

        row = layout.row()
        row.operator(MY_OT_rem_doubles_bmesh.bl_idname)
        layout.separator()

        row = layout.row()
        row.label(text="{} Objects in Selection".format(len(sel_objs)))

        row = layout.row()
        row.label(text="Vertex Count: {}".format(sel_vert_count))

def register():
    bpy.utils.register_class(MY_OT_rem_doubles_bmesh)
    bpy.utils.register_class(MY_PT_custom)

def unregister():
    bpy.utils.unregister_class(MY_OT_rem_doubles_bmesh)
    bpy.utils.unregister_class(MY_PT_custom)

if __name__ == "__main__":
    register()


Window Generator Disappears when changing perameters

Well after more research it turns out that the windows generator in 2.79 is somehow over ridden by archimesh which comes with 2.79.....all you have to do is check the box in add-ins and voila


Continuation of existing curved edges to close mesh body

Select the top edge which you want to extend, hit G twice to activate Edge Slide mode. Now hold the Alt key and you can move the vertices outwards along the projected edges. As soon as your vertices are close enough together press LMB or Return to apply the transformation. Now close the top by hitting F to fill it or  M to merge the vertices. But this extends the edges linear, it doesn't preserve the curvature.


How to use normal maps with nodes in Blender Internal?

In order to use normal map in BI in particular you should have appropriate image - normal map.

Black&White image won't work for this purpose, it will work as a bump map (which is one used on Cube A in your example). Normal map uses RGB values to convert into orientation of given point on the surface; black&white image doesn't provide that information.
Normal map is an image in blueish hues which tells a given 'face' which orientation should it have with respect to its position within the overall structure of the object, and here's an example of one (with respect to this case):

There are different ways to create normal map based on this image, see How do I make a normal/displacement map when all I have is a photo?.
You can create it in Blender using the same way as in normal maps baking from sculpting with the only difference that image will be used instead. This may be not the best way, although it works for fast and dirty results.

Once you have that image use it as a texture for material of the object:

For more details about using normal maps in Blender Internal and Cycles see:

http://thezedlab.com/quick-reference-using-normal-maps-in-bi-and-cycles/
http://www.katsbits.com/tutorials/blender/bake-normal-maps.php


Human model and other textures won't show up on render

The problem is that all of the materials are transparent. Change this in the material settings by disabling the transparent option.


What are the pros and cons of using Blender on Windows or Linux?

It is commonly said that performance is generally faster under Linux based operating systems, both during regular program operation and rendering.
Linux is also commonly said to consume less resources than other operating systems, leaving more available memory and processing power available for applications to use.
According to this recent article's benchmarks, Cycles GPU rendering is generally considerably faster under Linux than Windows for the same hardware configurations.
Have in mind that your mileage may vary and not all hardware/software combinations behave the same under each operating system or for all types of tasks. Dual booting may still be a better solution, also considering the diversity and availability of software for each platform.


Blurring/Feathering a Procedural Pointiness Mask

Creating Procedural Weathering Effects in Blender

Okay so I ended up developing a solution to this question a couple of months back, but I see it's gained a lot of interest recently so I thought I'd post a tutorial on how I went about solving it.

The weathering effects basically involve creating a Worn Edge and Cavity Dirt mask, which can then be used to blend between 2 or more shaders within one material.

This is along the lines of what we'll be creating.

(NOTE: This effect works best for objects with a high poly-count, so throw your object through a sub-surf modifier.)

The Edge Wear Mask Node

1. So to begin, we'll create a simple material a mix between a Diffuse and Glossy shader. In my final image I used Blender Guru's PBR Dialectric and PBR Metallic node groups to give the material a little bit of added realism, so I'd recommend checking those out :)

2. Now we've set up the base material we can move it off to the side and concentrate on building the Worn Edges Mask node group. We'll do this by first adding in a Geometry node, and connecting the Pointiness attribute to the input of a Color Ramp node. I set the black stopper to a position of 0.47, and the white stopper to a position of 0.514.

3. Next we can add in a Math node and set its mode to Subtract. Plug the output of the Color Ramp into the top input of the Math node and set the bottom value to be 1. Then, add in a MixRGB node, change its blending mode to Add and the Fac to 1, and plug the output of the Math node into the top Color input. Finally, we can add in a Noise Texture node and plug the Fac output into the second Color input of the MixRGB node. (Don't worry, it's less complicated from here!).

4. I'll go into more detail on the Noise Texture later on, but it is basically controlling the shape of our edge weathering, which bits are chipped, etc. Anyway, now we can add in another Math node and set its mode to Greater Than. This is where it gets fun- plug the Color output of the MixRGB node into the top input of the Greater Than node and begin adjusting the bottom value. You should see the white areas 'shrinking' towards the edges, the closer you drag the slider to 1 (I found a value of 0.35 to look good here).

And that's the basis of our edge weathering mask! All black areas of the mask will later show the Diffuse material, and the white will be Glossy.

5. Let's plug our mask into the Fac input of the Mix Shader to see how it looks... not too bad! Has a chipped paint feel to it.

6. One last thing we can do before packing it all into a node group is add a Bump node and connect the output of the Greater Than node into the Height input. Optional if you want to use this effect, sometimes it can give an odd outline around the border between the 2 shaders, but often it can add some depth, making the materials seem layered.

7. Now we can select the Geometry,Color Ramp,Subtract,Add,Greater Than and Bump nodes, and hit Ctrl+G to create a node group out of them.

8. Then we'll connect the noodles to the appropriate group input and output slots and rename them accordingly (see the screenshot).

9. Finally we can rename our Node Group to Worn Edges... and that's it! We've successfully created the edge wear mask node! :)

The Cavity Dirt Mask Node

1. Now, setting up the Cavity Dirt is ridiculously simple now that we've completed the previous steps. First, add another Diffuse and Mix node to the material, like so...

2. Duplicate the Noise Texture and Worn Edges nodes. Adjust the parameters of the Noise Texture node to how you'd like the cavity grime to look. Now, click the '2' next to the Worn Edges name on the node group to make the duplicate a single user copy, and rename it to 'Cavity Dirt'.

3. Finally, hit Tab to go into the Cavity Dirt node. Find the Color Ramp node and hit the flip ramp button to invert the ramp from 'black -> white', to 'white -> black'.

4. And it's as simple as that! Tab out of the node group and tweak the settings, and you'll be able to see a mask that only affects the cavities of the object.

5. How it looks when combined with the second Diffuse shader.

Using Image Textures

Although the Noise Texture node used as the shape mask doesn't look toooo bad * cough *, I've found that using image textures can give much more appealing results if you use generated box mapping.

These tend to work best if they're greyscale, and I've found dirt masks/grunge maps tend to look good. The ones I used in my original image came from Max Textures. I've found they provide some nice, high quality, seamless ones for free.

Limitations

Although this technique works very well for most applications, there are a couple of limitations to the method...

As mentioned by other answers and at the start, the fact that this setup uses the Geometry node's Pointiness attribute means that it will not work at all, or at least not well for low-poly models, as there simply aren't enough vertices.
Some texture maps work better than others, currently I haven't been able to distinguish exactly what causes one to work well and another not so much. My best guess is it's the contrast.
Sometimes the values to bump up edge wear, for example, can be very tight. That is, there can be a drastic jump in how the mask covers the object with a value change as little as 0.1. Again my best guess is that this is due to contrast when using image textures.

Other than that enjoy! Hope it helps people out, and don't forget to upvote if you liked it! :)


How to properly light a scene that's both indoors and outdoors

On a bright sunny day, the exterior will always be much brighter than indoors by several magnitudes. In the real world, photographers deal with this by adding and hiding light sources and making the interiors brighter until they get an image with a dynamic range that is within the limitations of the imaging device and the artistic intentions they are after.

There is no reason why you couldn't do the same, with the added bonus that in 3D rendering you can create light suorces that are invisible to the camera...

Create light sources the size of the windows and place them in a way that they don't block the incoming light, but suplement it. That way you'd still feel that the light is coming from outside the window, but in reality is coming from a light source inside the room. It is very important that you do not try to make the interiors as bright as the exteriors, it would break the illusion of realism. When you are indoors the exterior should feel a bit brighter and when looking at things from the outside the interior would be a somehow shaded (why would you want to buy a house that offers no escape from the intense sun light?)

A very important step towards realism is to create your scene with a much wider dynamic range, so that you can still keep values that are like those in the real world. But the trick is in how those values get displayed in the final image. The default sRGB color transforms for blender will severely limit the way light values can be displayed, try using the Filmic BLender transforms.


Change the "OK" button name in dialog-boxes?

Unfortunately this isn't something you have any control over. The window_manager.invoke_props_dialog function is defined in C here, and ultimately uses the wm_block_dialog_create function, which contains this:
uiBut *but = uiDefBut(
        col_block, UI_BTYPE_BUT, 0, IFACE_("OK"), 0, -30, 0, UI_UNIT_Y, NULL, 0, 0, 0, 0, "");

As you can see from IFACE_("OK"), the text "OK" for the confirm button is hard-coded in the C source, so there's no way to override it short of rebuilding Blender from source.


What do operator methods do? (poll, invoke, execute, draw & modal)

For a comprehensive description of operators and their use see:
https://docs.blender.org/api/current/bpy.types.Operator.html

For a quick run-down

poll, checked before running the operator, which will never run when poll fails, used to check if an operator can run, menu items will be greyed out and if key bindings should be ignored.
invoke, Think of this as "run by a person". Called by default when accessed from a key binding and menu, this takes the current context - mouse location, used for interactive operations such as dragging & drawing. *
execute This runs the operator, assuming values are set by the caller (else use defaults), this is used for undo/redo, and executing operators from Python.
draw called to draw options, typically in the tool-bar. Without this, options will draw in the order they are defined. This gives you control over the layout.
modal this is used for operators which continuously run, eg: fly mode, knife tool, circle select are all examples of modal operators. Modal operators can handle events which would normally access other operators, they keep running until they return FINISHED.
cancel - called when Blender cancels a modal operator, not used often. Internal cleanup can be done here if needed.

* - note, button layouts may set the context of operators to invoke or execute. See: https://docs.blender.org/api/current/bpy.types.UILayout.html#bpy.types.UILayout.operator_context


Try checking a "Self collision" box

By the way there is same question answered.
Cloth - Cloth interactions in Blender
Maybe this will help you.


Is it possible to parent an object and have the child retain its rigid body physics?

use the normal parenting in object mode "Ctrl+P" ,which will be neglected in the BGE  , and to add parent in the BGE use the Parent actuator with an Always sensor :


Blender Fluid Simmulation: How to turn on and off the fluid appearing from inflow?

In Blender 2.8 they changed the name. Instead of being called "Enabled" it's just called "Flow".

Keyframe that toggle on and off and it will give you exactly what you want.


How to make the circumference of a Path/Bezier Curve Low Poly?

You should select  your bevel object (curve circle). And in settings of this curve you should change the resolution value:

If you set it to 1 or 2, I think, it will be close to that you want


Control Cycles material based on the distance to an empty using Animation Nodes

The problem is that all objects share the same material, consequently, editing the material affects all objects equally. Your solution of creating a number of independent materials could work, whoever, it would be very inefficient and hard to control. Instead, we could use one of numerous methods that vary in efficiency and difficulty.

The easiest method but the least efficient is to use vertex colors. You just use the Set Vertex Color node to set a color to an object, this color could carry your emission strength. The color can then be retrieved using the Attribute node in Cycles. It should be noted, however, that your objects have to be Deep Copies. My answer here explains this in more details. Also see my answer here.

The most efficient method is to do the computations in Cycles itself. Since your emission strength depend on the distance to an empty, we can simply pass the location of the empty and compute the distance in the shader as follows:

Finally there is the method of using an image sampler based on the object indices, which you can use when your relation is more complicated that a mere distance. I explained this in details in my answer here.


3D manipulator not pointing in the right direction

The orientation of the 3D manipulator is determined by the setting of the Transformation Orientation control in the bottom of the 3D view.

You have set it to Normal which aligns the manipulator to the vertex normal. You might want to set it to Global or Local.


Parent to bone (by only rotation), or snap head to origin of other object

If I understand your question, you want to build an armature (in edit mode) in which the bone's head is exactly in the object origin location. To do so, select the object, press Shift S (Cursor to selected), then select the armature, go to edit mode, select the head of the desired bone, press Shift S (Selection to cursor). THEN parent the object to the bone (Ctrl P - Bone).


How to control the appearence of texture on certain number of faces, in Blender?

All your object is actually made of seperate meshes as we can see if you do a simple unwrap:

So in Edit mode select all and AltM > Merge By Distance, then unwrap again. Also it is very high poly, are you sure you need so many faces? In that case press AltJ to untriangulate, then CtrlE > Un-Subdivide, choose the ratio in the Operator box, then unwrap again.


How to apply a material (e.g. dirt) over an object that already has multiple materials?

One way would be to add a node group right at the end of all your materials:

This way you would only need to setup/change the dirt shader stuff once, and it'll be used by all your materials the same way.

The nodes inside the group might be something like this (though it really depends on what you're doing):

More info about node groups:

User Manual
Blender Cookie tutorial


How can I make this hexagon be exactly the height of the square

By splitting a hex of height 1 into equilateral triangles, and Pythagoras, we know its side-to-side width is sqrt(3)/2. So, if we just look at the threshold in X, we know that has to be sqrt(3)/4. (And, IMO, that's an easier way to think about it than considering the dot-product branch of your tree)

You would hard-code that value into the Less Than, though, so it doesn't have to be recalculated for every shading-point... (the same goes for your existing sqrt(3). )


Blender Rigify strange issue with weighting

This is a common problem. Up in the top right you will see that it says Auto-run disabled. You have to press the button beside it that says reload trusted, and it should resolve your issue.


Character mesh low poly in object mode and high poly in sculpt mode

Not sure about this,
But it looks to me like simply right clicking no the object and clicking 'Shade Smooth" while in object mode should do the job


How can i Mirror more than one objects at the same time?

Download Smart Join Addon

Select the mesh (wheel) and click on smart join (it temporary join all the selected mesh). You can now move all the join mesh and add any modifier to all the join mesh.
If you want to separate the mesh just click the separate s. join

If you want to edit the join mesh click on the expand smart join and after finishing the editing click on collapse smart join.


Show addon tab panel in just the Compositor, not in Shader Editor

You can add a poll function:
@classmethod
def poll(cls, context):
    snode = context.space_data
    return snode.tree_type == 'CompositorNodeTree'


Drawing precision, straight lines on animated surface

Perhaps you need the shrinkwrap modifier:

This will work dynamically with a mesh or a curve. If you need to animate the curve handles, use the hook modifier to parent them to armature bones.


Can movie data from a movie strip in the VSE link to data in a texture?

Make a scene that renders or outputs the texture (eg. connect it to a composite output). Then in the sequencer instead of adding the video select the scene strip from the Shift+A (Add) menu.


Fluid Simulation: an object set as outflow doesn't remove all the "water" mesh

It does seem to be a bug and should be reported. Though it seems that there is currently no one maintaining the elbeem fluid sim code.

A possible work around would be to use a boolean modifier.

http://pasteall.org/blend/index.php?id=46863

Note that you'll need to bake first. I left the boolean modifier off (eye icon not checked) to illustrate that the boolean modifier removes the resultant fluid mesh, so you may need to tweak the boolean object to catch any particles/mesh that happen to move above the boolean object later in the animation.

Also, using a boolean modifier with a fluid sim mesh will likely really drag down the UI responsiveness.


when parenting object to bone, the object changes position

It was my mistake, the object was previously parented with another object, so, when re-parented the object with the bone, its position is now referenced with the position of the bone, forgetting the previous spatial reference with early parent object, so it cause re-positioning :-)