Decided I'll post a tutorial anyway in case anyone else is curious in the future, as the techniques used are extremely valuable to a variety of different scenes and renders! :)

This is along the lines of what we'll be creating, rendered at 150 samples:

1. To begin, I've used a relatively simple scene setup comprised of a UV Sphere, backdrop and 3 emission Mesh Lights.

2. Diving in head first, we'll jump straight on over into the node editor! The basic glass material will be comprised of 2 Shaders, a Glass BSDF mixed with a Glossy BSDF, with a Layer Weight node's Facing output plugged into the Fac input of the Mix Shader. Set the Blend of the Layer Weight node to 0.200. Change the Glass BSDF's light distribution type to GGX, and the IOR to a value of 1.800. Finally, add an RGB node and plug the Colour output of the RGB node to the Colour input of both the Glass BSDF and Glossy BSDF. Change the colour of the RGB node to the values shown in the following screenshot:

3. Now we've got the basic glass set up, let's add in some fingerprints! Glass is rarely ever 100% clean, and unless it's been recently polished or moved by machine it's going to have little bits of human grime on it in the form of fingerprints. We'll add this photorealistic detailing in through the use of a custom 'Finger Print Map', which I created using chain's brushes located here http://chain.deviantart.com/art/fingerprint-brushes-549217 . You can download my Seamless Texture from the imgur album link at the bottom of this post :)

Start by adding a Texture Coordinate, connected via the Object output to a Mapping node. Change the Mapping Node's XYZ Scale values to 0.500 and connect to an Image Texture Node. Open up the 'Fingerprint' texture into this node and set the projection type dropdown from Flat, to Box, with a Blend of 0.500. Finally add in a Mix RGB node and set the blend type to Add. Plug the Image Texture into the add and the Add into the Roughness Input of the Glossy BSDF shader as follows in the screenshot. Finally change the Colour 2 input of the Add node to a more greyish colour, i found changing the RGB values to 0.250 to work quite well. This just helps to mute the fingerprints slightly and make them appear more realistic.

4. Next comes the scratches! These tiny details will add both roughness and surface texture to the marble, all the while enhancing the realism! Again I created this Seamless Scratch Texture from, well scratch, using KeepWaiting's brush set located at http://keepwaiting.deviantart.com/art/11-Scratch-Brushes-for-PS7-177075258 , again you can download the Normal Map of the texture in the imgur link at the bottom!

Start by duplicating the Mapping and Image Texture Nodes and connecting them up to the Texture Coordinate Node as we did in the previous step. Change the scale of the Mapping Node's XYZ to 2.000 and open up the 'Scratch Normal Map' in the Image Texture node, changing the Colour Space from Colour to Non-Colour Data and the Blend to 0.000. Next, add in a Normal Map node and connect it to the Image Texture and Glass/Glossy nodes as shown in the screenshot. Finally, change the Strength value to 0.100. This will add subtlety to scratches that are really only visible around light sources reflected off the glass, but it'll help sell the weathered effect by a million percent! ;)

5. The final step! And arguably the most complex, so it'll be easier to explain it by showing, rather than explaining. Using the custom dirt map that I have edited from this original image: https://hmmatthews.files.wordpress.com/2012/07/table_colour.jpg , we will overlay it on top of the glass, adding an effect similar to that caused by limescale and grimey water and dust drying on a window surface... or a marble in this case! :P This image will also be available in the imgur link at the bottom.

Begin by repeating the process of adding in Mapping and Image Texture Nodes, change the XYZ Scale to 1.000, load up the 'Dirt Map' Texture and set the Blend to 1.000. Next add in a Diffuse BSDF (with a colour of that shown in the screenshot) with a Transparent BSDF, and mix them together. Plug the Dirt Map Texture into the Fac input of the Mix Shader. Add a second Mix Shader and insert it as the last node before the Material Output, blending together the rest of the nodes with the 'Dirt Map'. Again plug the 'Dirt Map's input into this second Mix Shader's Fac input, however this time add in a ColourRamp node onto the connecting node branch, and edit the stoppers as shown in the screenshot. This causes that subtle speckled effect that is definitely totally not noise...! (Don't worry it becomes more obvious with more samples!) ;)

6. (Optional Step:) Below are several setup screenshots of my render settings for the final image at the start of the tutorial, using my CPU.

And there you have it, the final result alongside a sweet node Setup! :P

And as I mentioned the techniques and textures can be used with a variety of different materials in a variety of different scenes!

Hope this helps! :D

Links:-

1) Imgur Link to Custom Maps: http://imgur.com/a/0Fpru

2) KeepWaiting's Scratch Brushes: http://keepwaiting.deviantart.com/art/11-Scratch-Brushes-for-PS7-177075258

3) chain's Fingerprint Brushes: http://chain.deviantart.com/art/fingerprint-brushes-549217

4) Original Dirt Map Image: https://hmmatthews.files.wordpress.com/2012/07/table_colour.jpg


Display length of object to render, dynamically

We can use a frame change handler to alter the text objects content before each frame during playback.

import bpy

def distance(p1, p2):
    return sqrt((p1[0]-p2[0])**2 + (p1[1]-p2[1])**2+ (p1[2]-p2[2])**2)

def update_size(scene):
    point1 = scene.objects['Empty.001'].location
    point2 = scene.objects['Empty.002'].location
    scene.objects['Text'].data.body = '{:.3f}'.format(distance(point1, point2))

bpy.app.handlers.frame_change_pre.append(update_size)

# to disable
# bpy.app.handlers.frame_change_pre.remove(update_size)

Instead of using distance between two points you may prefer to add the length of the pose bones between shoulder and hand.

format(scene.objects['rig'].pose.bones['upper_arm.L'].length +
        scene.objects['rig'].pose.bones['forearm.L'].length)


Using joint angles to animate a character

Yes it can be done, no I don't know any existing examples. The best I can think of is the bvh import script or the Motion Capture tools addon.

Blender's python api is available online but you may find it easier to use the autocomplete feature in the python console.

As a hint to get started -

bpy.data.objects['metarig'].pose.bones["head"].rotation_mode = 'XYZ'

bpy.data.objects['metarig'].pose.bones['head'].rotation_euler[0] = 32

bpy.data.objects['metarig'].pose.bones['head'].keyframe_insert(data_path="rotation_euler", frame = 10)

I can't say if this is the best or correct way to pose armatures by script.


To do this first join all your objects into one if they aren't already by selecting them all and hitting Ctrl+J.  Then create another grid object consisting of just edges which you will use to slice up the map.

Select the grid and then the terrain (in that order), enter edit mode, go to top view (numpad 7), make sure you are in orthographic mode (numpad 5 to toggle), then use the knife project tool found in the toolbar.  Make sure cut through is checked after you do so.

Your terrain will then be sliced up based on the grid object's edges.


Convert the text to a mesh. It's going to have a lot of tris.
Select all in edit mode and clck on 'Mesh' at the header of the 3D viewport and click on ''Clean Up'.
Select 'Limited Dissolve' which will drastically reduce the number of tris appearing while retaining form of the text mesh.
You can further increase the value of the limited Dissolve' from it's adjustment pop up bar that appears at the bottom left immediately you click on it hence reducing the mesh's noisy face Tris but do this slighty as giving an high value input will make the mesh to loose form.
At this point you should be able to use the 'Smart UV Project' which will project something quite relatable then go ahead texturing. Should work out fine now.


You could do it with texture paint, you would have control on how your spots appear exactly, or, as John says, you could do it procedurally.

If you choose this second option, here is a try. Set this nodes chain: Texture Coordinate (Object output) > Mapping node > Texture node (here Musgrave) > ColorRamp > Mix Shader. Mix your 2 colors (carrot color and spot color) in the Mix Shader. Play with the Mapping scale values to squish the spots on the right axis and with the parameters of the other nodes to give them the shape you want. At the end of the chain mix with a Glossy, and maybe also with a Subsurface Scattering to give it a bit of transparency.


The Bricks node puts out a random-per-brick blend of the two input brick colors, biased at Bias  = -1 to Color 1, and Bias = 1 to Color 2. So you can  quantize the blend, and map it to colors, as much as you like:

I've added a tree which uses the range of colors to switch between completely different textures:


Cannot cut area out with AddModifier Boolean

When you delete a face you are making the cube physically impossible. It can't exist in real life. The reason for this is that it's sides are infinitely thin. With another word, it is not manifold anymore.

If you want to make it manifold, but open, add the solidify modifier before attacking it with boolean. Now the sides have a thickness again.

Now it is time for boolean. If you want, you can apply the solidify modifier first.


Cannot see mesh for reference images Blender 2.80

Background images as we used in 2.7x are not available in 2.80.

Now when we load a reference image, the image is attached to an empty which displays it in the viewport. As it is an object you can move it in front of or behind any other objects or hide it when not being used.

We can also make the image transparent by adjusting the image properties for the empty.

Note that cameras now have background image properties, this allows an image to always be aligned with the camera view. These settings have a depth option to display the image in front of or behind the scene.


You can always position things by typing in there exact coordinates numeric input. Also snapping to an axis or the grid can help you align things. For symetry the mirror modifier is often the goto thing.

More precision tools


You probably need to set the 'Flip' checkbox in the Screw Modifier. ;)


Is it possible to create a function that is performed on the render engine change?

Use the msgbus

There is a relatively new and mostly undocumented feature of blender that fires a callback when a property is changed.  Check if your version has this feature in python console.

>>> bpy.msgbus
<module 'msgbus'>

Related

https://developer.blender.org/P563

Origins to the down of the object by default

How to get an event when an object is selected?

For this case (IMO) can substitute context.scene.render.engine for context.engine

>>> C.engine
'BLENDER_EEVEE'

>>> C.scene.render.engine
'BLENDER_EEVEE'

>>> C.scene.render
bpy.data.scenes['Scene'].render

>>> type(C.scene.render)
<class 'bpy.types.RenderSettings'>

Use msgbus to invoke a callback whenever the "engine" property of bpy.types.RenderSettings is altered.

import bpy

handle = object()

subscribe_to = bpy.types.RenderSettings, "engine"

def notify_test(context):
    print("Notify changed!", context.scene.render.engine)

bpy.msgbus.subscribe_rna(
    key=subscribe_to,
    owner=handle,
    args=(bpy.context,),
    notify=notify_test,
)

bpy.msgbus.publish_rna(key=subscribe_to)

Note using bpy.types.Context, "engine"  does not work.

For versions without msgbus

Can use a depsgraph_update_post (or prior scene_update_post) handler.

import bpy

engine = bpy.context.scene.render.engine

def engine_change(scene):
    global engine
    if scene.render.engine != engine:
        engine = scene.render.engine
        print("changed", engine)

if hasattr(bpy.app.handlers, "scene_update_post"):
    handler = bpy.app.handlers.scene_update_post
else:
    handler = bpy.app.handlers.depsgraph_update_post

handler.append(engine_change)


Save rendered images in different formats

See the Output panel in the render settings. It can also be changed post render with Image > Save As Image (F3) in the Save As Image side panel.

If you want to output to multiple formats, this can be done using the File Output compositor node.

For GIF see: Can Blender render animated gifs?


Cutting hole into a face with a line loop?

This can be done using Knife Project, however for the case you show to work, you will have to use a recent Blender build, since improved knife support was added after 2.69 release.

  To use Knife Project, in Object mode select the object you want to project (use and cut the other) first then Shift select the "object to be cut". Now Tab into Edit mode and press Knife project.

Before projecting from a text object and Resulting knife projection.


Cycles left some squares in final render

I have found out what cause the problem!!!
One of my area light which I have use to imitate lights of the wall lamp, has been partly inside of the object:

That cause the artefacts and lot of noise. Now, the image is crystal clear!

I hope this will help others with same problem ;)


How can I use Photoshop to edit the textures of my model?

You can sort of "open" 3d model in Photoshop (example), but it's not something as flexible as editing it with 3d package (and that won't provide you with most features like what is expected when importing 3d models) . What Blender provides you with is to edit the texture of the model with any image editing program. There are 2 possible ways:

editing image used as texture directly in image editing software. Note that you might want to export UV layout in order to be able to see what faces you're painting on;
export current position of the mesh in the viewport to the image editing program, paint on the mesh like it was visible when captured in 3-rd party program and then apply those changes back to the image texture in Blender. This feature is called Quick Edit (image painting program should be set up in the User Preferences):


Compute object's foreground mask in screen coordinates

I was not aware of Blender's ability to render the scene depth map. This is exactly what I need to obtain the foreground mask. The code snippet at the link below produces the desired results, specifically when setting the map.size value to a very low number, e.g. 0.001.

Render depth map to image with python script


Freestyle render - Problems getting it right

I'm very curious to see a better solution since I'm not very experienced with Blender myself, but perhaps this would work for you:

create a plane an add an Array modifier, with Constant Offset in the Z axis. The more duplicates you create the more lines you'll have in your final render.
select the object to be rendered and add a Boolean modifier.

Operation: Intersect
Object: plane

hide the array for rendering

Repeat with any other objects to create the horizontal lines.


How to view from the Lamp’s perspective?

Non-Camera objects including lamps can be used as cameras objects in Blender.

Select the light you want and make it the active camera (CtrlNumpad 0), then manipulate it as you would a camera for positioning / rotation / etc...

You may also want to enable Lock Camera to View, so you can use regular view manipulation to place the camera.


Is there a way to render to PNG as raw pixels / without converting color space to sRGB?

Use the color management controls . Change the Viewfrom sRGB to LinearRaw


Some children positions are off, both when animating and rendering (but not when paused at any frame)

While writing this question I realized the problem.
To have a more correct rotation of the weels when steering left or right, I set the driver to the x position of the tire,
creating a driver to a property of a child (of a child) caused the problem.
Instead I created an empty that is parented to the main steering object with an offset to the center of the wheel, resulting in a more correct rotation and preventing these delays


How to move objects via script so that they stay in camera view

camera.data.angle_x/y doesn't seem to follow changes in resolution, so I made the following script taking into account resolution, pixel aspect and focal length.<
br>
The following functions camera_normalized_frame1() and camera_normalized_frame2  both return camera frame normalized by the distance btween camera image plane and origin.
import bpy
from mathutils import Matrix

#-------------------------------------------------------------
def camera_normalized_frame1(cam):
    render = bpy.context.scene.render
    aspect = (render.resolution_x * render.pixel_aspect_x) \
                / (render.resolution_y * render.pixel_aspect_y)
    view_frame = cam.data.view_frame()
    frame = [-f/view_frame[0].z for f in view_frame]
    if aspect > 1:
        mat = Matrix.Diagonal((1, 1/aspect, 1),)
    else:
        mat = Matrix.Diagonal((aspect, 1, 1), )
    for i in range(len(frame)):
        frame[i] = mat @ frame[i]
    return frame

#-------------------------------------------------------------
def camera_normalized_frame2(cam):

    import bpy_extras
    scene = bpy.context.scene

    frame = cam.data.view_frame()
    poss = bpy_extras.object_utils.world_to_camera_view(scene, cam, cam.matrix_world @ frame[0])

    ratio = [0.5/(poss[i]-0.5) for i in range(2)]
    norm_frame = []
    for f in frame:
        norm_frame.append(f.copy())
        for i in range(2):
            norm_frame[-1][i] *= ratio[i]
        norm_frame[-1] /= -norm_frame[-1][2]

    return norm_frame

Create Icosphere objects in the corners of a rendering imag.
import bpy
from mathutils import Matrix

cam = bpy.data.objects['Camera']
frame = camera_normalized_frame1(cam)
#frame = camera_normalized_frame2(cam)

distance = -cam.data.view_frame()[0].z
for v in frame:
    loc_l = distance * v
    loc_w = cam.matrix_world @ loc_l
    bpy.ops.mesh.primitive_ico_sphere_add(radius=0.1, location=loc_w)

Place objects at random locations within camera view.
import bpy
from mathutils import Vector, Matrix
import random, os
import math

random.seed(os.times().user)
min_z, max_z = 2, 10

# Base object for duplication
bpy.ops.mesh.primitive_ico_sphere_add(radius=0.05)
obj = bpy.context.object

cam = bpy.data.objects['Camera']
frame = camera_normalized_frame1(cam)
#frame = camera_normalized_frame2(cam)

for i in range(200):
    v = Vector([
                random.uniform(-1, 1) * frame[0].x,
                random.uniform(-1, 1) * frame[0].y,
                frame[0].z
                ])
    distance = max_z * math.sqrt(random.uniform( math.pow(min_z/max_z, 1), 1 ) )
    loc_w = cam.matrix_world @ (distance * v)

    obj.select_set(True)
    bpy.ops.object.duplicate_move_linked(TRANSFORM_OT_translate={"value":loc_w})
    bpy.ops.object.select_all(action='DESELECT')

obj.hide_set(True)
bpy.context.view_layer.objects.active = cam


How to select what to render with F12 in Blender 2.8?

You probably need to move the camera to the position that you are looking at; you can move the camera manually like an object or you can press Ctrl + Alt + Numbpad 0 to move the camera to your view position.

Hope that helps.

Good Luck


How to make some value sliders of a node in a node group display on the group node

Use some nodes with sliders (for example a Map Range Node) on it and connect it to the hollow group input or node as seen in this screen shot.

After that use the N-Panel to set up the minumum and maximum slider range.
The Result looks like this:


You haven't assigned materials. Light power (emission) is not high enough. Try 5000 as emission/power.


This is definitely because of the time settings. Setting it to a frame value will make it think that the simulation happens 179 seconds after the start of the animation. What's this? Like frame 600? Change it to a small value that compensates with your animation time (in seconds), and your problem should be solved. You may even want to check the animation timeline 179 seconds later, and you will probably see your fluid.


how to keep sharp points using subdivison surface

This is how your tooth topology should look like:

You can add more loops to the body of it to shape it differently as you want it.


Replacing a part of animated mesh with bone weights

One solution would be to use vertex selection masking (in red circle on the image below) and select only new mesh vertices, then assign automatic from bones.
Second way would be to take new mesh out, place in the right spot in object mode and parent it to armature with automatic weights and delete old character body leaving cloths and weapon.


Round or hard corners on a single vertices in 2D

Mesh objects always have what you seem to be thinking of as "hard corners". When you're saying "like in any graphic software" I assume you're thinking about vector-based software like Inkscape or Illustrator which typically use Bezier curves.

If you want to manipulate points in a similar manner you would have to create Curve objects, not Mesh objects.


BGE How to change a music loop in the middle of a game?

I have all my audio and audio logic setup on my camera, just so it is easy to keep track of it all.
To start I have a boolean game property called "sound_switcher", the empty checkbox means that it is FALSE. This is what is getting changed when the player goes near my cone object. That property in turn controls which sound file gets played.
The Near sensor detects when the player gets close to my cone (it has a game property of "prop" on it).
When that gets triggered it toggles the game property (booleans can only be TRUE or FALSE).
Now look at the other two sensors (Always and Property). The Sound actuator only plays when the always sensor is true (always) and the game property is FALSE (remember I have it set to false by default).
Notice the top "Nand" controller, it is the important. When the player is near the cone, and the game property is true, the Property sensor is no longer true, thus the "Nand" controller is TRUE, which activates the second sound actuator.
(The Nand controller activates when at least one connected sensor evaluates False, which in this case is the only one plugged in to it the Property sensor.)

Now the logic above will toggle the audio, but if you want the second song to keep playing even when you leave the cone, then simply delete the bottom Nand controller (it is highlighted in orange.)
The blend file


You have two options:

Hover your cursor over the buttons, press Mouse Scroll and drag it left/right
Place the cursor on the window edge and expand the panel with LMB


How to set multiple camera views in one scene?

Yes.

You can create new cameras with ShiftA> Camera, or you can just duplicate an existing camera with ShiftD.

To name them, enter a name in 3D view > Properties region > Item, and optionally enable  Name in Properties editor > Object > Display to display the name in the 3D view:

The active camera (the one used when you press Numpad 0 or render) is the one with the solid triangle.

To set a camera as active, select it and press CtrlNumpad 0, or select it in the scene panel with a search-able list drop down:

Another useful shortcut is CtrlAltNumpad 0, which snaps the active camera to the current view.

You can lock the transforms of the camera object to prevent moving them in the 3D view:

However you can still move them with the transform sliders in the interface.


What is a good way to learn clean topology?

A good way to learn to use clean topology is to do a lot of modelling
'Clean' topology is topology that is easy and convenient to work with. We avoid triangles because they do not allow the use of a lot of functions related to edge loops or do not look nice after surface subdivision, we avoid non-manifold geometry because some algorithms are confused by it and do not work as expected, we use as little of geometry as possible to define shapes and forms because it is easier to work with and there is less lag, we use denser geometry where objects are going to deform because they do not look nice when deformed otherwise and so on and so on. Clean topology has natural reasons to be - that's why you learn it naturally while modelling. If you model something for animations, you need to take extra care to understand the rigging and animation process enough to have suitable topology, but else than that, most of the time the more modelling you do, the better you get at judging what topology is 'clean'.


Are there any advantages of bigger/smaller tiles

There are two considerations involved with tiled rendering:

There is some overhead when switching tiles. Larger tiles = fewer tiles = less switching = less extra processing time.
Smaller tiles render faster (which reduces the likelihood that one tile is left rendering at the end, leaving all the other processors idle *)

You must find a balance between these two factors (In other words, you don't want all your processing time to be spent switching between tiles). The optimal tile size for you will probably be specific to your scene, hardware configuration, personal preferences (e.g. sacrificing a small amount of speed for larger/smaller tiles), etc.

See Best Tile Size for Blender Internal Renderer and Cycles for some examples.

* this assumes you have more then one processor/core in your system.


How to make armature edit mode match object mode?

The change in location during render or closing/opening the file is due to the animation, which is taken in account during render and opening the file.

The procedure for having your shoot as rest position for both the mesh and the armature is this:

Select the body mesh and apply the armature modifier.
Do the same for the hands mesh.
Select ALL bones in pose mode and apply pose as rest pose.
Turn off the animation in the action editor.
Add an armature modifier to the body mesh, choosing your skeleton as "object".
Do the same for the hands mesh.


offsetting textures of cycles materials to simulate movement

Use a Vector > Mapping node after the Texture Coordinates node, and plug that as vector for the texture.

To offset the texture, animate the values for Location (and/or Rotation or Scale)


You must be looking for the Correct Face Attributes option:


How can correctly scale a rigged model along with its armature?

Probably,your entire mesh is parented to the main armature.
Scaling the armature deforms the object.
The best solution I found in that case is by creating a new empty and parenting the main armature to the empty. Now,scaling the empty scales the model without deformation.
Otherwise,try parenting every single mesh to that empty and scale the empty.


This can be done using a combo of Blend4Web's Switch Select and Set Shader Node Param logic nodes.

Feel free to ask for an example blend file on the B4W forums.


Tracking; How to deal with tracked features that disappear and become visible again later?

There is a button that cuts it fro a certain set of frames, and then you can add it back when it reappears


How can I change the language of the blender to understand it?

You can change to your language inside Preference Menu/Interface/Translation


How can I copy and paste dimensions to make objects the same size?

If you enable Align Tools Add-on in the Preferences(F4->P, or Edit -> Preferences):

You will have Advanced button in the sidebar, Item tab:

You can then select the objects you want to scale, then select the one you wish to scale to so it's the last selected and active and hit Advanced under Advanced Align Operations:

In the Last Operation panel you will have Fit Dimensions:


Holes in Mesh, when using Subdivision Surface Modifier

maybe double verts, select everything in edit, press W, and click remove doubles, if that doesn't work i'm not sure.


Is there a way to fix these weird faces without adding more polygons?

While we model using quads, blender always draws to screen using triangles. The current triangulating algorithm for quads always triangulates the same way, while the newer ngon triangulating is more intelligent, see this question for some more insight.

While the vertex order used to make each face could be re-arranged to get a better result, I don't think there is an easy way to do that.

You should find that a subsurf modifier will hide most of the effect you are seeing.


Speed control effect doesn't change the length of video strip

When you add a Speed Control strip, Stretch to input strip length is enabled by default.  That gives you the ability to change the length of your video strip (aka "input strip") and the speed will automatically adjust.  For example, if you make your video strip half as long, the speed will be twice as fast.

You also can set the parameter Multiply Speed.  This will change the speed of your video without changing the length.  For example, you can set this to 2.0, but since the video finishes twice as fast yet the length stays the same, the video will run out before the end of the strip, and so for the remainder of the strip, Blender will just display the last frame.


Whats the purpose of Ambient Occlusion node in Cycles?

The purpose is that you can control how much AO each object has.

  The ambient occlusion node gives per-material control for the amount of AO. When AO is enabled in the world, it affects all diffuse BSDFs in the scene. With this option it's possible to let only some materials be affected by AO, or to let it influence some materials more or less than others.

Quote from the Blender Wiki.


What is this mode that is causing everything to be evently scaled?

On the top right of your viewport, next to 'Global', you have an icon with 2 circles with dots in them. This means that your transform Pivot point is set to individual origins. Which means that every selected objects/face/edge will be scaled individually. If there is a hotkey for this I don't know it, but you can switch it by clicking on the icon and choosing whatever you want, by default Blender set it on Median.


Getting area (region.view2d) pixel coordinates of 2D views (VSE, NLA)

Yes, this can be done, using the API call View2D.view_to_region.

Heres a "hello world" example, drawing Hello World under the active strip.

import bpy
import bgl
import blf

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

    region = context.region
    strip = context.scene.sequence_editor.active_strip
    if strip is None:
        return

    x = strip.frame_final_start
    y = strip.channel
    x, y = region.view2d.view_to_region(x, y)

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

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

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

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

        if event.type == 'MOUSEMOVE':
            self.mouse_path.append((event.mouse_region_x, event.mouse_region_y))

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

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

        return {'RUNNING_MODAL'}

    def invoke(self, context, event):
        if context.area.type == 'SEQUENCE_EDITOR':
            # 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.SpaceSequenceEditor.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'}, "SequenceEditor 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()

Note that this is the template operator_modal_draw.py with minor edits.

The draw_callback_px can be added without having to be connected to a modal operator, if you want this to display continuously.

Also see: https://github.com/armadillica/attract-blender-addon/blob/master/draw.py for example use cases.


A few things to consider are:
 Are you using an official release?
 Are you in the latest version or in an old verion? There is both Blender 2.78a and 2.78b now. I have been working in the video editor with 2.78b and have had no trouble. Try download and re-installing the latest verion. If it continues, try with a different video file. If the problem is fixed, then it means that your video file was damaged. It could also be your audio file... Hope this helps! :)

-Tovin


Can you make a mesh follow another mesh with Cloth Sim?

What you can do is to link the pinned of the vertices and the rigid body to a bone.

Create a bone and apply the metarig to the cloth with empty groups first.

After this, delete the Bone vertice group and copy its name to the name of the pinned group.

Now parent the bone to the rigid body(select the bone first).

And there you go.


This is a problem related to uv coordinate interpolation. It is inevitable when working with very low mesh density. To avoid
this kind of problem increase mesh resolution by adding few extra loops.

As you can see the distortion runs along triangles - this is the way uv is interpolated in quad polygons.


How to make Sapling addon settings reappear?

This is standard behavior. You can not edit any settings after editing, moving, deselecting, etc. anything in the scene without the editing menu being removed.

More information


Combining a solid object Fresnel glow on top of a glass object?

You can do this by assigning faces materials in edit mode.

Here's how:

1) Enter edit mode in Blender.

2) Select the top face you want to be able to apply the "purple" shader to.

3) Make sure your material colors are already created. You will need at least two separate materials. (One for the top face, and one for the rest of the cube).

4) Go to the materials tab, and select "Assign". This will assign the material to the single face.

5) To prevent the material from being applied to the entire object, press CTRL+I to select inverse.

6) Assign the previous material to those faces the same way you assigned the other material.

Last) View it in render, it should look awesome.

Here's a picture of multiple assigned materials on one object:

The answer in total, to this question is simple. If you know how to assign materials to individual faces of an object, then you have solved the problem.


Apply scale and recalculate Normals

The selected object has a negative scale. Despite you see it light grey in the viewport, the faces are indeed flipped for the modifiers, as the object transformations are runned after them.

I would suggest to apply the scale in Object mode (Ctrl+A), than go to edit mode and recalculate normals (Ctrl+N).

Result:

Notice that the same result can be achieved by simply give to the X scale a positive value, but to avoid misbehavior in future operations is better to fix the scale once for all:


There is a mode in the UV Editor called Sync Selection.  When Sync Selection is enabled; selecting the entire model in the 3D Viewport will select everything in the UV Editor;
however! when Sync Selection is disabled this will not happen.

To select everything when Sync is disabled you must first select everything in the 3D Viewport and then again in the UV Editor.  This mode allows you to work on UV coords independently but will often cause the problem you are describing.

Make sure that everything is selected in the UV Editor and then reapply the texture.
You might want to keep that little button activated all the time until you get used to it.


I don't think you need to get this kind of convoluted node tree if you just want a random color.

The "Get Random Elements" node has a "Single" mode which will output a single randomly chosen value.

The setup :

Result :

If you just want a random index, you can use the "random" node with a floor math node.


How to get curve to twist with the hooked object?

You can add a driver to the Tilt of the point.

Select the desired point and add a driver to it's Tilt.

Then go to the driver editor and do ass follow:

Now when you rotate the object the curve rotate too.


Child of constraint with bones and objects

Nevermind. I just made another external bone and it tracks no problem. If anyone can tell me if childing to an object and not a bone is possible id love to know where i went wrong


Scaling works differently in GUI and from script

It's a context issue and you need to Override the Context

The pivot point is a member of the 3D_VIEW space.  In code below would be area.spaces.active.pivot_point  Example of overriding the context which "fools" the operator into thinking it is being run from the 3D view, not the text editor.

import bpy
context = bpy.context
override = context.copy() # dictionary of context

for area in context.screen.areas:
    if area.type == 'VIEW_3D':
        override["area"] = area
        override["space_data"] = area.spaces.active
        override["region"] = area.regions[-1] # rule of thumb r.type == 'WINDOW'
        break

bpy.ops.transform.resize(override,
                         value=(0.3, 1, 1),
                         constraint_axis=(True, False, False))


How to tile the Gradient Texture node with the spherical gradient type?

This is a little more complex than the linked question due to the spherical gradient texture needing a range of [-1,1] to generate a full circle.

The modulo(1) function will generate a repeating pattern by mapping positive values to a new value in [0,1] and negative values to a value in [-1,0]. This means that half the circle will be repeated in either direction from 0, not what we want.

Instead we can generate two versions of our repeating pattern that each work for just one side of the zero point, and then combine them by masking out values we don't want and using a maximum:

Modulo(x,2) - 1 generates a repeating [-1,1] range for x > 0 and [-3,-1] otherwise
Modulo(x,2) + 1 generates a repeating [-1,1] range for x < 0 and [1,3] otherwise. This [1,3] range will present problems when combining each side with maximum so we need to set it to something less than or equal to 0
By exploiting the fact that the spherical gradient is symmetrical around x=0, we can invert the part from (2) to avoid the issues with maximum.


Not saying this is the solution but this happened to me and it was because I had been in the composite mode and hadn't gone back to main viewport


Auto apply a frame to over 50 imported paintings

Through the UI:
Design a frame-profile curve in such a way that its origin is on the inner edge of the frame's passepartout. (Test it out in a rectangle)

Import your images as frames
Select all, and ShiftD duplicate the lot. (It's sensible to keep pictures and duplicates in separate collections, for hiding, etc.)
All dupes selected, Alt + Header menu > Convert the duplicate planes to curves, in one move.
All the curves selected, one active, Alt assign the frame Profile as Bevel object. All the frames should acquire the bevel.

So now, all the pictures are framed. Trouble is... they're all separate objects.

Alt Convert all the frames back to meshes.
Choose Locations from the Header Options dropdown, with pictures and frames selected, scale the objects' locations to spread the framed pictures out a bit.
CtrlJ join everything into one object.
In Edit Mode on all, M Merge > By Distance all the coincident vertices of pictures and frames. If your profile was good, that should be all 4 corners on each picture.
Still in Edit Mode, P Separate the framed-pictures object by loose parts.
Object mode, all selected, ShiftCtrlX Origin > To Geometry

Now all the pictures should be framed, as single objects, with origins at their centers. Trouble is... they all now have a lot of surplus material slots.
To clean them up, you could run:
import bpy

sel = bpy.context.selected_objects

for ob in sel:
    bpy.context.view_layer.objects.active = ob
    bpy.ops.object.material_slot_remove_unused()


Animation nodes > Mesh Object Output > Use function

That is socket Enable/Disable switch. When it is disabled data in the socket is not used. You need to enable that for writing data to target mesh. So that it always rewrites new data on the mesh.


This can be done by correctly unwrapping the UVs of the model to fit the geometry:

To start, your shape looks like this:

First, I add a texture coordinate node and a mapping node to my texture (or just select the checker texture and press Control + T to generate it automatically if you have the Node Wrangler addon enabled). You don't actually need the mapping node for this, but it is helpful in many scenarios.

Then, change it so that the UV comes out of the texture coordinate, through the mapping, into the vector input of the checker texture.

Then, using the search feature, select "Smart UV Project" on your object. This will generate UVs to fit your angled edge.

I achieved the following result:


Problem with bending model using simple deform

You could use vertex parenting, which is similar to parenting but the child will follow the vertices as they are deformed.

Select the cover.
Shift select the spine.
Go into edit mode.
Select three vertices a the end of the spine.
Press ⎈ CtrlP to parent the selected object/s to the selected vertices.


Magic Room Illusion - making objects appear when viewed through another object

Add a plane (as "window") - give it this material:

Add a box with suzanne in it with this material:

world material:

switch to cycles

result

https://youtu.be/vMg0V0UcHPs
Video tutorial: https://youtu.be/Qgu4z5T-GV4


Physics with an object made of several parts

create a cube the size of the die, make the cube not rendered and then use it as a rigid body physics and parent the die pieces to it


Why is object deviating from path random?

First you have 2 curves overlaying, curba1 and curba2, so it's a little bit confusing. About the useful one, curba2: it's very long, so you need to increase its resolution if you want the movement of the sphere to be smooth (in the Properties panel > Data > Shape > Resolution > Preview and Render). Also, you've given an animation to your sphere (which makes it move away from the curve) but I guess it's on purpose.


DirectX Export Script for Blender v. 2.71

The x file makes sense, it has a 1 to 1 correspondence of vertex to normals. If you use smooth shading, you should fix your rendering code.

The rendering code:
1. Upload vertices array , normals array and  UV's array.

Draw triangles using the vertex indexes provided

It's rather simple, look here:
http://www.songho.ca/opengl/gl_vertexarray.html


How can I zoom without moving camera (also for render)?

That is a background image, it is not supposed to move. It's only for reference. If you want the image to stay in place, while you move the camera use the addon "import image as plane". Or simply create a plane with an emission material and use your BG image as the texture.


Is there a way to create per-face/per-vertex normals?

It is possible since 2.74 release (see the release notes). Upcoming 2.75 release will include some rather important fixes for them too.

You can only manipulate them in 'Object' mode though (i.e. not in BMesh), and there are several other limitations that may be addressed in future - in a few words, they are mostly procedural currently (through modifiers), and you should only use them on final topology, any topology change (adding/removing verts/edges/faces, or even applying negative scaling) will more or less break them.


How can I speed up assigning materials to specific faces (for low poly style)?

Here is a solution similar to what you are asking, but not exactly. For this solution, you will be selecting the faces you wish to color, then assigning the color from a palette.
Create a 5x5 pixel image (or other tiny resolution image), and fill each pixel with a color you want to use.
Then open the shader editor.
Then, ⇧ Shift +  A, S for search, then type image texture.
Connect the image texture Color output to the Base Color input of the Principled BSDF node.
Then, open the UV Editor, and in the dropdown select your palette image.
Scroll up to zoom in to your image.
Then, tab into edit mode on your object, hover over the UV editor, then press  A,  S, $0.01$.
Now, your faces should be tiny in the UV editor.
When you want to change the color of a face or multiple faces, you can select any faces in the 3D View, hover over the UV Editor, and press  G to grab the faces and move them onto any of the colors in your palette.
Source


I got so many .blend files in my C:/tmp folder....is it safe to delete some of them?

Most files in temp folder are either autosaves, temporary backups, clipboard items (when using copy-paste through Ctrl + C > Ctrl + V) or expendable cache files.

Unless you recently lost any work and some file needs recovery, you worked on some unsaved projects, or Blender crashed or unexpectedly closed and you didn't save your work before, non of those files should be important, and can be safely removed without issues.

Blender doesn't normally store important files in unsafe locations, so unless you specifically told it to (either explicitly or by omission) files in temp locations should be unimportant and discardable.

Be sure that all your files are correctly saved in some "projects" folder in a safe spot in your hard drive. If in doubt use your system's safe deletion system (Recycle Bin for Windows) when deleting so that if something goes wrong you can restore it.


Go to  Render, select Object and choose your particle object, also Show Emitter.
Your emitter object is probably in another hidden layer and there for it will not show you your particle system.

Try resizing your particles on Render > Size tab.
The shader assigned to the emitter is the ones the particles will inherit.

Unless you´re working with another object as particle, in which case it will select that object´s material as the particle material.


Blender model to .dae/.sdf with textures

by textures if you are meaning the materials they don't render in exported objects(read why: .fbx export why there are no materials or textures?)
otherwise textures as images shoud should show up.


How to draw a slider button with a custom defined numeric value?

I don't know if it is possible to set the default auto_smooth_angle of each new Mesh object -- I think your reason for trying is legitimate. If it isn't possible there's an alternative you might be interested in.

Rather than changing a default property of a mesh's auto_smooth_angle a solution could be to offer an EnumProperty with some quick-pick options, in addition to the existing slider. The enum would update the slider when an option is selected, if you want to fine tune then you use the slider.

here the rough code:

import bpy
import math
from math import radians

class LayoutDemoPanel(bpy.types.Panel):
    """Creates a Panel in the scene context of the properties editor"""
    bl_label = "Layout Demo"
    bl_idname = "SCENE_PT_layout"
    bl_space_type = 'PROPERTIES'
    bl_region_type = 'WINDOW'
    bl_context = "scene"

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

        obj = context.active_object
        if obj and obj.data:
            mesh = obj.data
        else:
            return

        row = layout.row(align=True)
        row.prop(mesh, "use_auto_smooth", text="BreakEdge")
        row = layout.row(align=True)
        row.active = mesh.use_auto_smooth and not mesh.has_custom_normals
        row.prop(mesh, "claas_smooth_angle", expand=True)
        row.prop(mesh, "auto_smooth_angle", text="")

def register():

    def set_smooth_shade_angle(self, context):
        obj = context.active_object
        if obj and obj.data and obj.type=="MESH":
            mesh = obj.data
            mesh.auto_smooth_angle = radians(int(self.claas_smooth_angle))

    bpy.types.Mesh.claas_smooth_angle = bpy.props.EnumProperty(
        items=[(str(j), str(j), "", i) for i, j in enumerate([30, 45, 90])],
        default="30",
        update=set_smooth_shade_angle)

    bpy.utils.register_class(LayoutDemoPanel)

def unregister():
    bpy.utils.unregister_class(LayoutDemoPanel)
    del bpy.types.Mesh.claas_smooth_angle

if __name__ == "__main__":
    register()

or

    row = layout.row(align=True)
    row.prop(mesh, "use_auto_smooth", text="BreakEdge")
    row = layout.row()
    row.active = mesh.use_auto_smooth and not mesh.has_custom_normals
    split = row.split(percentage=0.4)
    row = split.row()
    row.prop(mesh, "claas_smooth_angle", expand=True)
    split = split.split()
    row = split.row()
    row.prop(mesh, "auto_smooth_angle", text="")


Adjust Background Transparency after Motion Tracking

I found out how to do this. Select the Camera object, then go to Object Data -> Background Images. Expand the background image being used (the video clip in my case) and adjust the Alpha slider as needed.


My character with soft body still go through wall a little (animation)

The blender physics simulation doesn’t work with absolutes, only forces so it is not possible to give a mesh a property that will absolutely prevent anything penetrating - give something enough velocity or enough force and it will pass through a surface.

However, there are some simple general things you could try - in particular, make the simulation work with smaller intervals so that forces and velocities are proportionally smaller. This should result in the collision having an effect before the impactor manages to get through. This can be achieved by increasing the ‘Steps per second’ setting for the simulation. For very fast simulations or extreme forces (such as a soft body string wrapping around another mesh) you may need to increase the steps per second by orders of magnitude (perhaps from 60 to 6000 or more). Increasing the steps will provide a more accurate simulation at the expense of requiring more simulation CPU time.

Other options are to ensure your Normals are set correctly and to adjust the collision bounds (eg, Soft Body settings) to be appropriate to teh mesh. For example, see How to get the physics engine to wraps a string around the moving part of a motor constraint


How do I properly use core matte to keep green section of shirt on using green screen keying?

Hard to tell without seeing your setup, but my guess is :  the mask plugged in Core Matte always output a 100% value, while the rest of the shirt output a lower value ; ie, there is some green in the shirt and the keying node make it a little bit transparent. Nothing noticeable at first, but noticeable by contrast with the mask.

You can verify that by compositing the output of the Keying node on a grid, or on a vivid color. Or plug the Matte output to a Viewer, and make sure there is only black or white areas, no gray. That will make obvious if some areas aren't keyed correctly. If that's the case, adjust the parameters of the keying node.


How to connect two vertices with curved edge

As Leander has commented, if you want a circular arc, you can use the Spin tool, (AltR) to spin a single radius around the 3D cursor.

If you want a more arbitrary curve interpolating through control points, you can select and position those points on an existing boundary, and use the shipped add-on: Loop Tools > 'Curve' to form it.


It looks to me like you may have a bad path in the Output directory. From your screenshot, it looks like 'Science'. Replace that with an actual path to an existing directory for which you have read/write permissions.

If you click the little folder icon at the far right of that field, you can browse to your desired render directory.

Ensure that the path you enter in that field ends with a trailing slash (or backslash if on Windows)


How to draw RGBA 2D image in 3d_view with gpu module (or without)?

The 3D view does not know about this script, so it won't draw immediately since some change occurs for it.

But you can force updates in 3D views using this at the end of your script:

for area in bpy.context.window.screen.areas:
    if area.type == 'VIEW_3D':
        area.tag_redraw()


Bump Causing Bumps? (Not the right ones)

Those weird circular/truncated conical bumps are in fact in your bump map texture.  At least, I see them when I apply your texture to a simple unwrapped object using the "bump" node.  It's the white circles in your texture that are the culprit; they have a gradient around them which makes the cone shape.


This is not a bug, it's a feature! :-D

Joke aside, blender is letting you know how many triangles you would have had you converted all your polygons to triangles.

The tri-count is an important number for lots of purposes, including game asset creation (where you always try to maintain the lowest polycount possible), 3D printing and other areas,

Several file formats support only triangles (STL for instance), and convert everything to tris implicitly (while others, like Collada, support quads too but convert to tris by default). So this gives you a preview of the number of tris you will have after converting.


eye lighting + export image/video problem

A lot can be wrong with the particles to make it look bad in render. First thing I would look into to get a grip of what's going on is "if the particle system - the hair is baked". If not bake it.
As for the eyes, try to uncheck shadow in Object properties Cycles Settings of the cornea object with glass material. If that wont work, try to experiment with mixing glossy with transparent shader for cornea instead of glass. If mixed in right proportions it will let some more light into pupil object. You can also try to work something out using Light Path node to connect it's Is Shadow Ray with Mix Shader node to mix Transparent with Glass in a way that makes shadow of the object invisible. Give it a try, probably one of this ways will work for you.


Why does my armature's bone rotate 360°, but the mesh only rotates 180°?

Your head also inherits roatation from the torso bone. Look at the vertex groups: The head's vertices are members of both groups, 'Head' and 'Torso'. Thus the rotation of the head and the torso bones are combined by a weighted average. The weights of both groups are 1, so this results in equal influence of both bones. The torso-bone does not rotate, so the total rotation is halved.
Just remove the 'Torso' vertex group from the head and it rotates as intended.


How to recreate this wireframe looking effect

Hmm.. maybe you want to animate this, in which case this answer would need expanding..

But as a still, this is a close shot:

It involves:

A distorted plane with a Triangulation and a Wireframe modifier with a matte black material
A particle system to place a 'vertex' at every vertex, with the same material
A duplicate of the plane with a glass material, very low IOR, (no Wireframe, flat shaded)
A long lens on the camera, to keep vertices about the same size in shot
A shallow depth of field set for the camera
A Background shader for the world, large-scale noise to reflections in the glass, but white to the camera and transmission through the glass.

I probably should have used Dupliverts, not particles.. but can't replace the Blend right now...


How do I change how the blender menu looks?

When you open a new file, go to File > Open. After this you will have a browser, select the file and look for the gear icon on the right top corner, click that and uncheck Load UI


Connected Bone Parenting Issue with IK Constraint

Have you setup the IK constraint's Chain Length setting? Its default value of 0 means the whole chain of bones, right up to its root which is the head, will be affected by the constraint. You'd need to limit it to whatever length of bones really need the IK behavior, in this case 1.

If you want to make eye target controller, IMHO a Damped Track constraint would be more appropriate than IK, because it works on a single bone and very easy to setup correctly.

Each eye's bone need not be connected to the head, BTW.


trying to export mask animation but data dont change when changing frames!

i found the solution is to use frame_set function:

bpy.context.scene.frame_set(i)


Start a particle’s animation when it’s in a certain location with animation nodes?

Not sure if this will be helpful, but I had a similar project where I was trying to animate a crowd of simple stick figures, but wanted them to be in different parts of their walk cycle so they didn't look like they were marching.

In my case, rather than rigging, I used shapekeys to animate the characters, used particles to instance the objects (as you're doing,) then had animation nodes cycle through the shapekey animation based on the overall animation frame #, but assign a unique offset value for each character's animation so they wouldn't be in lockstep.

Using shapekeys like this worked for my simple animation, not sure if it would work for your situation. Sample attached.


How to rotate viewport camera without moving it in Blender 2.90?

Not sure if this is what you need, but if you hit N while in the viewport and then you go to View > View Lock > Lock Object. You could drop any object or model there and the Viewport camera will be focused on that object or model


need help with armature and weight painting

Hard to understand your first picture, but your hip has too much influence on the thigh vertices, so simply select your armature, select your mesh, switch to Weight Paint mode, select the hip bone and use the brush in Blend > Substract mode to remove this influence. You'll have to bring some other corrections on some other parts of the mesh.


There are several ways to go about this, most common and easiest is to use a boolean modifier. Select the plane and add a Boolean modifier to it, In hte Object field, select the object you want to stamp holes with (ie some cylinders joined together) and change the Operation to Difference. Next apply the modifer, delete or hide the cyclinders then Tab into Edit mode and box select the botton half of the mesh that protruded down and delete these.

If your mesh has thickness, you can just delete or hide the cylinders after applying the boolean modifier.

You can also further read up on some more techniques here http://www.blendernation.com/2013/07/14/8-methods-of-cutting-holes/.


Why is object.origin_set(type='ORIGIN_CURSOR') not working?

You are right. To set object origin, you must be in object mode. You can also try using bpy.ops.object.mode_set(mode='OBJECT') to change to object mode.


That is because you are in blender render mode.You need to switch it to Cycles render mode.


Ensure your mouse is over your 3D view, and hit 'n' if your properties panel isn't already showing. Then, just click 'Ambient Occlusion'. This simulates only shaded areas.

If you tick 'Matcap' above this, the combination of these options is very handy for checking the smoothness or subtle details in your mesh. Great for sculpting, or just checking for imperfections that need fixing.


matrix_basis vs. matrix_local for object parented to bone

matrix_basis is simply a way to access the pose-bone or objects (location,scale,rotation) properties.

This is just for convenience - so you don't have to consider if euler/quaternion/axis-angle rotation are used when getting/setting a transformation.
matrix_local is the the objects world-space 4x4 matrix, relative to it's parent, if it has a parent - if the parent is a bone or a vertex, it will be relative to the parent matrix defined by the vertex/bone parent relationship.


How can I achieve the visual of objects pressing against membranes more beautifully?

While I was ultimately forced to use a realtime displacement shader in Unity to achieve the effect and my client later moved onto an off-the-shelf raymarching solution in Unity, I was able to slightly improve my workflow in Blender.

Using a Displacement Modifier to initially perturb the subdivided plane provided a gentle organic 'texture', I then followed this with a Warp modifier to move the vertices in the direction of my depth map (the Warp modifier obviated the need to worry about normals as it extends the vertices towards the 'to' empty).

While not perfect (still getting stretching artifacts, etc), it worked out pretty well within Blender and I was able to export Alembic bakes for playback in Unity.


How to properly apply PBR displacement on non rectangular Planes?

hope i understand your request. you need a non rectangular plane to be displaced, right? I think best way should be insert a plane, subdivide it, select and remove not necessary vertex.

Then add the modifiers you need. in the image you can see a displace modifier with cloud texture and subsurf added.

Them you can unwrap (you can do that in ortho top view and then uv -> project from view) and apply the shaders.

It was that you need?


Here are the settings I use for retopology with snapping. (Note the options on the right of Closest)

If you make an extrusion, and the vertices don't snap to the mesh underneath, just press g with the vertices selected and they should snap.


Rigify widgets generating in wrong position and won't rotate

Solved in the duplicate topic here: Rigify generated rig, hand IK controller has unexpected rotation
The generated rig tries to correct the roll automatically by default, but this can be overwritten by selecting each upper_arm bone and in Bone Properties > Rigify Type > Rotation Axis selecting the rotation axis manually. If you have copied the roll orientations from the human metarig template, then this should be Z manual for the arms. This causes the hand IK control to be correctly oriented when generating the rig.


Automatic Heat Weighting: Failed to find a solution for one or more bones

Try adding a subsurface modifier to the meshes you want to parent before you parent them. You can remove it later. For some reason it should work.


There is no such thing as bpy.types.IDPropertyGroup in bpy.types, hence this line:

if isinstance(val, bpy.types.IDPropertyGroup):
    ...

fails. Try from bpy.types import IDPropertyGroup you will get an ImportError.

>>> from bpy.types import IDPropertyGroup
Traceback (most recent call last):
  File "<blender_console>", line 1, in <module>
ImportError: cannot import name 'IDPropertyGroup'

This is why that isinstance fails. I agree this is a little bit weird, but this changes the question a little.

  Why isn't it there and how would I use isinstance to test complexity of an ID property. Are there alternatives?

Because ID properties are a limited collection of types, it's perhaps no less crazy to check for int, float, str, list.

import bpy

x = bpy.context.active_object

for k in x.keys():
    val = x[k]

    if isinstance(val, (int, float, str, list)):
        print('simple', val)
    else:
        print('complex', val.to_dict())

You could also check if the ID property has an attribute to_dict instead, else it's a basic type.

import bpy

x = bpy.context.active_object

for k in x.keys():
    val = x[k]
    if hasattr(val, 'to_dict'):
        val = val.to_dict()
    print(k, val)

Even use the (always present) class type returned by type(x['cycles'])

import bpy

x = bpy.context.active_object
IDPropertyGroup = type(x['cycles'])  # <--- use this type's return in isinstance

for k in x.keys():
    val = x[k]
    print("k %s type %s" % (k, type(val)))
    if isinstance(val, IDPropertyGroup):
        val = val.to_dict()

    print(k, val)


How to duplicate an object in 2.8 via the Python API

Make copies of ID data with ID.copy()

For blender data ID objects ie objects in bpy.data.objects meshes in bpy.data.meshes actions in bpy.data.actions  the ID object has a copy method .

For a bpy.types.Object object copy, the copy will have the same transforms, parent, modifiers, constraints, animation data et all of the original.  All linked data will be same as original. eg if mesh of original is bpy.data.meshes["Cube"] so is the copy's.  Fortunately the mesh also has a copy method.

template_ob = bpy.data.objects.get("template")
if template_ob:
    ob = template_ob.copy()
    # link to collection if need be
    collection.objects.link(ob)

the copy ob has the same linked data as the original template_ob.data is ob.data is True.

    # assign a copy of the mesh to copy object
    ob.data = ob.data.copy()

Assuming we've checked original has an action then to make the action a copy of original's

    action = ob.animation_data.action
    # make it a copy
    ob.animation_data.action = action.copy()

To unassign

    #make it None (no action assigned)
    ob.animation_data.action = None

Or in one fell swoop, remove all animation data including actions and drivers

    ob.animation_data_clear()

Constraints and modifiers data are not linked. The copy has the same of each, including the same names, as original.  The vertex groups and target objects pointed to will be same as original, and may need to be adjusted.

To remove all modifiers and constraints on copy

    ob.modifiers.clear()
    ob.constraints.clear()

Duplicate Object operator. bpy.ops.object.duplicate()

can also use the duplicate operator.  As with operators they work on the context and selected objects, which if need be can be set within a script.

Alternatively with an override dictionary. Early testing and 2.8 appears much simpler on this front.

Test code (can confirm works as expected when run in python console on 2.8)

Duplicate an object template_ob with linked data

bpy.ops.object.duplicate(
        {"object" : template_ob,
         "selected_objects" : [template_ob]},
        linked=True)
ob = context.object # newly duped object

linked=False is the default.

Making a new object with copies of originals data.

From question:

template_object = bpy.data.objects['TemplateObjectName']
new_object = bpy.data.objects.new('NewObjectName', template_object.data)
collection.objects.link(new_object)

  how do I attach the template object's animation, modifiers, particle
  systems...?

Strictly speaking this is not a duplicate. It is a new object that shares the originals data part.  Or similarly in your answer where it shares data part, and original action or copy thereof. Results will match in the simplest of cases,   ..and may be the answer you are seeking. However for others wishing to duplicate their objects in 2.8 using this method

Can they be assured that nothing is affected by not having  a property of original on the new object?

The action or driver may refer to data paths of properties on original that either,
will not be defined, or set to default on the new object.
Relations: modifiers constraints animations could require  the original having a certain parent or transform.
How to go about copying over the constraints / modifiers of the
original? What if they have drivers? Should target objects be duped,
Vertex groups? .

To reiterate, making a new object sharing some chosen DNA of the original is IMO not duplicating.  Obviously there's no need to write a script with all the options required to emulate ob.copy()  just like there's no need to use ob.copy() to add a new object with default settings, and only a few chosen attributes of ob

Putting the body of Porsche on your new car, and driving it like it's a Porsche, doesn't make it a Porsche, it may however achieve the result you are after


To do this you can select the edges or vertexes you want and then press 'F' while in edit mode.
Which actually fills up the selected entities with a single face.
Be careful with ending up with N-gons though with this technique.


Animation Nodes - Have an effector control the rotation of many objects

Your Question

We can compose a transformation matrix out of the locations, then generate the rotation matrix using the Offset Matrices Node and then set the objects transformations to this new matrices.

Warning - Make sure not change the locations of the matrices or set the locations of the object by mistake to any value.

Recommended

If your objects are exactly the same, then you can replicate them using the Object Instancer node and set their locations using thew Distribute matrices node (See my answer here: Answer):

Note - If the object has modifiers and you want to copy them, use Copy Full Object option in the Object Instancer.

If you objects are different, then you can replace the Object Instancer with the Object From Group just as you did.


Character's Underlying Mesh is showing through top mesh of Jeans

You could delete this part of your mesh. If you prefer a non-destructive way you could give your object a Mask modifier:

In Edit mode, select the part you want to make invisible, assign it to a group.
Back in Object mode, give your object a Mask modifier, in the Vertex Group field, choose the group you've created, click on the arrow on the right to invert the masking effect.


You are also starting out on a new adventure, and a very steep learning curve. If you don't already have it, you will need to gain an understanding of modelling, texturing, rigging, lighting, staging, sound/sound fx, pacing, composing, compositing, story structure, cinematic structure, and, and, and. Blender can do many things, and you have a lot to learn just for that. But consider you will also have to gain some mastery of other programs like audacity (for audio) and the gimp (for texturing/backgrounds) as well before you can, as you say it, prof animate in a little map.

I guess you need to do what every one of us has done, search for tutorials on what you need to know at the time. Why not start with the opening shot on your example there. Model a rock, some trees, flowers, and a little character like you already have. Then light your scene and set up the animated camera shot. All of these links are to tutorials I found with a single search, all leading to dozens of others that may fit your needs more.

I was going to suggest that you also try to track down the production files for Big Buck Bunny and study the blend files because that movie opens similarly to your example. But it seems that more and more of Blender is getting locked up behind paywalls. Even so, there are many good blend files still freely available that you can download, open up and study.

I hope I haven't put you off. But I think it will help you more to understand that you will never get to where you want to be (prof animate) by starting with a single animation and then asking SO how to do everything else.


Is there a way to get a list of coplanar faces using Python?

Using bmesh

As an alternative to bpy.ops.mesh.select_similar(type='COPLANAR')

  4 points are coplanar if the volume created by the points is 0. If any
  three points determine a plane then additional points can be checked
  for coplanarity by measuring the distance of the points from the
  plane, if the distance is 0 then the point is coplanar

Select all faces with normals within angle tolerance of face.normal, then check if the convex hull,  made from the verts of each of these faces with those of selected face, volume is zero (or within some tolerance).  If so it must be on same plane.

Quick script to test.  Runs thru all mesh objects in the scene each face in the objects mesh and the coplanar list of the indices of faces coplanar to that face.

"Volume" of face

import bpy
import bmesh
from mathutils import Vector

def coplanar_list(bm, index, TOL=0.001):
    bm.faces.ensure_lookup_table()
    face = bm.faces[index]
    coplanar = []
    # narrow down selection based on normals
    faces = [f for f in bm.faces if f.normal.angle(face.normal) < TOL]
    # list of faces with same normal
    bm2 = bmesh.new()
    for f in faces:
        verts = [v.co for v in face.verts]
        if f.index != face.index:
            verts.extend(v.co for v in f.verts)
        # make a dummy bmesh with verts of each face
        o = sum(verts, Vector((0,0,0))) / len(verts)
        for v in verts:
            bm2.verts.new(v - o)
        #calculate a convex hull
        bmesh.ops.convex_hull(bm2, input=bm2.verts)
        # if the convex hull has no volume its on same plane.
        volume = bm2.calc_volume()
        if volume < 0.001:
            coplanar.append(f.index)
        bm2.clear()
    bm2.free()
    return coplanar

context = bpy.context
scene = context.scene
meshobjs = [o for o in scene.objects if o.type == 'MESH']
print("-" * 72)
for o in meshobjs:
    print("Object", o.name)
    if o == context.edit_object:
        bm = bmesh.from_edit_mesh(o.data)
    else:
        bm = bmesh.new()
        bm.from_mesh(o.data)
    for f in bm.faces:
        print("\tface %3d " % (f.index), coplanar_list(bm, f.index))

Or using distance point to plane for 4th and higher verts of plane defined by first 3 verts.  Note this script merely lists faces whose verts are coplanar by way of example, not those that are coplanar to active face.

import bpy
import bmesh

from mathutils.geometry import distance_point_to_plane as dp2p

TOL = 1e-6

context = bpy.context
ob = context.edit_object #  run in edit mode
me = ob.data

bm = bmesh.from_edit_mesh(me)

coplanar = []
for f in bm.faces:
    if len(f.verts) == 3: #  tri
        coplanar.append(f)
        continue
    v1 = f.verts[1].co - f.verts[0].co
    v2 = f.verts[2].co - f.verts[0].co
    if all(abs(dp2p(v.co, f.verts[0].co, v1.cross(v2))) < TOL for v in f.verts[3:]) :
        coplanar.append(f)

print([f.index for f in coplanar])


Ctrl + Click  used to select shortest path.

Try to change it to Shift + Click, then change Select in Mesh to Ctrl + Click.

I didn`t change every other options in selection, but it is ok for me


Use shift-right-click to multi-select nodes, or B to border-select a group of nodes and their connections.  Ctrl-C and Ctrl-V (or platform equivalent) will copy and paste nodes across materials.

NOTE: After pasting some nodes, try moving the nodes around with the mouse.  Blender has a bad habit of pasting node copies exactly on top of existing nodes, and it becomes almost impossible to see that anything has changed.  Slide the new nodes away to reveal old nodes underneath.

Also, consider using Node Groups to avoid having a bunch of duplicated nodes. This way, you can fix problems in a complex node structure and have the fixes apply to multiple materials at once.

A node group can have inputs for customizing in different ways, to make nodes more re-usable in different materials.  You can create a node group just by multi-selecting the nodes and picking Make group or Ctrl-G. Then, get in and out of the node group editor with the Tab key. Finally, you can add references to your node group from other materials, with Add -> Group -> {GroupName}.


fabric textures messed up in Cycles even though preview seems fine

I think I found the answer: I was using Lily's surface scraper and the displacement of the textures weren't scaled and were too large for the objects in my scene.


After some experimentation, it appears that #include-ing OSL files works with external scripts, but not internal.

The OSL compiler takes a shader file as input, and seems to use the directory of that file as a base for further includes. It also looks in the \scripts\addons\cycles\shader directory.

If external scripts are used, the OSL compiler therefore looks in the correct directory, and will find included files correctly.

If internal scripts are used, the script being compiled is moved by itself to a temporary directory, given a random name, and deleted afterwards. This means that internal scripts cannot use #includes unless the included files are placed in the \scripts\addons\cycles\shader directory.


A different approach (than my other answer)  would be to modify the mesh slightly so that you could perform a bevel operation.

Beveling rounds off a corner, so you need a corner where you want the rounded part instead of a flat face.  I accomplished this by connecting the two edges across the face and moving the new edge to a positing where it's two adjoining faces are at right angles.

You can then select the new edge and hit Ctrl+B to bevel the edge into a curve, using the mouse wheel to control the number of subdivisions.


How can I use Extrude Faces along normals without making different sizes?

Already comments are very usefull ... so just a tip.
You can start with Solidify Modifier with Even Thickness enabled.


Custom Texture Map Generators

Software to help generate planetary texture maps.

Rye Terrell's texture map generator
Planet generator
TerraNoise
PlanetMaker
Sci-Fi World Generator (Map Palette option has a land mask)
Experilous Planet Generator
Cloud Maps
Fracplanet
Terraform (X11)

Java

TerraJ
Planet Genesis (website)

Unavailable

Software that is offline, defunct, unreleased, or otherwise unavailable but still potentially useful.

Fractal Worldmap Generator (defunct)
Scientific Exoplanets Renderer (unreleased)

Source Code

Links to uncompiled software.

Planet generator (mirror 2)
Planet generator
http://www.oocities.org/area51/6902/t_torben.html (Java version of Torben's code)
https://github.com/unconed/NFSpace
https://github.com/fluffyfreak/GLSLPlanet
Fracplanet
Fractal Worldmap Generator

Free Maps

Maps of various resolutions (often without specular, cloud, or normal maps).

Extraterrestrial Planetary Surface Texture's for Imaging Professionals
Flatplanet
Planet Texture Maps 01 (by Hameed)
Pix For Planet Texture Maps (various, license unknown)
Deep Time Maps
Maps of Fictional Worlds

Solar System

NASA Images and Textures
Planetary Pixel Emporium
JPL/Cassini Saturn's Moons

Tutorials

Comprehensive web pages that describe various ways to craft realistic texture maps.

Making Worlds (C++)
http://xnameetingpoint.weebly.com/planets1.html
libnoise (how to use the API)
Using "Planet" for 16-bit maps
Orthographic projection of 2D SVG texture map onto 3D SVG sphere

GIMP

Creating Normal Maps
GIMP Planet Making

Photoshop

Create Planets in Photoshop

Binaries

Binaries that run under Windows and Wine.

Planet Editor
Wilbur (run winetricks vcrun2010 to install missing DLLs)

Related

Related information about planetary texture maps.

Rules Can Be Beautiful (TEDx Talk, jump to 7m 30s)
Procedural Planets, Heightmaps and Textures

Research, Whitepapers

Height Maps, Cube Maps, etc.
Planet Map Generation by Tetrahedral Subdivision
Procedural generation and realtime rendering of planetary bodies
Planetary Scale Terrain Composition

Palettes

Cartography palettes for planetary colours.

Standard Color Palettes for Relief Maps
Archive of colour gradients

Long Live the Rainbow

Creating beautiful relief models

Best Colour for Elevation (no snow)

Best Colour for Elevation (with snow)

ESRI Mapping Center

Red, Blue, Green

Palettes given as red, green, blue values.

Snowball colors

Palette {
  Class          "IceWorld"
  StyleRange     (0.00, 0.00)
  colorSea       (1.00, 1.00, 1.00, 0.50)
  colorShelf     (0.95, 0.95, 0.95, 0.50)
  colorBeach     (0.80, 0.80, 0.80, 0.75)
  colorDesert    (0.85, 0.85, 0.85, 1.00)
  colorLowland   (0.87, 0.87, 0.87, 1.00)
  colorUpland    (0.93, 0.93, 0.93, 1.00)
  colorRock      (1.00, 1.00, 1.00, 1.00)
  colorSnow      (1.00, 1.00, 1.00, 1.00)
}

White-brown colors

Palette {
  Class          "IceWorld"
  StyleRange     (0.00, 0.00)
  colorSea       (0.30, 0.25, 0.22, 0.00)
  colorShelf     (0.37, 0.31, 0.28, 0.00)
  colorBeach     (0.56, 0.47, 0.42, 0.20)
  colorDesert    (0.70, 0.70, 0.70, 0.50)
  colorLowland   (0.70, 0.70, 0.70, 0.80)
  colorUpland    (0.65, 0.65, 0.65, 1.00)
  colorRock      (0.60, 0.60, 0.60, 1.00)
  colorSnow      (1.00, 1.00, 1.00, 1.00)
}

Blue ice

Palette {
  Class          "IceWorld"
  StyleRange     (0.00, 0.00)
  colorSea       (0.30, 0.25, 0.22, 0.00)
  colorShelf     (0.37, 0.31, 0.28, 0.00)
  colorBeach     (0.65, 0.86, 0.88, 0.20)
  colorDesert    (0.59, 0.76, 0.80, 0.50)
  colorLowland   (0.93, 0.95, 0.95, 0.80)
  colorUpland    (0.90, 0.98, 0.98, 1.00)
  colorRock      (0.60, 0.60, 0.60, 1.00)
  colorSnow      (1.00, 1.00, 1.00, 1.00)
}

Purple colors

Palette {
  Class          "IceWorld"
  StyleRange     (0.00, 0.00)
  colorSea       (0.30, 0.25, 0.22, 0.00)
  colorShelf     (0.37, 0.31, 0.28, 0.00)
  colorBeach     (0.82, 0.77, 0.81, 0.20)
  colorDesert    (0.64, 0.52, 0.56, 0.50)
  colorLowland   (0.53, 0.41, 0.44, 0.80)
  colorUpland    (0.56, 0.41, 0.45, 1.00)
  colorRock      (0.60, 0.60, 0.60, 1.00)
  colorSnow      (1.00, 1.00, 1.00, 1.00)
}

Orange impurities

Palette {
  Class          "IceWorld"
  StyleRange     (0.00, 0.00)
  colorSea       (0.30, 0.25, 0.22, 0.00)
  colorShelf     (0.37, 0.31, 0.28, 0.00)
  colorBeach     (0.98, 0.98, 0.96, 1.00)
  colorDesert    (0.73, 0.35, 0.14, 0.50)
  colorLowland   (0.82, 0.37, 0.17, 0.80)
  colorUpland    (0.98, 0.98, 0.96, 1.00)
  colorRock      (0.60, 0.60, 0.60, 1.00)
  colorSnow      (1.00, 1.00, 1.00, 1.00)
}

Pardo

Palette {
  Class          "IceWorld"
  StyleRange     (0.00, 0.00)
  colorSea       (0.30, 0.25, 0.22, 0.00)
  colorShelf     (0.37, 0.31, 0.28, 0.00)
  colorBeach     (0.78, 0.75, 0.64, 1.00)
  colorDesert    (0.51, 0.44, 0.34, 0.50)
  colorLowland   (0.63, 0.58, 0.45, 0.80)
  colorUpland    (0.91, 0.90, 0.75, 1.00)
  colorRock      (0.39, 0.39, 0.23, 1.00)
  colorSnow      (1.00, 1.00, 1.00, 1.00)
}

Ganymede 2

Palette {
  Class          "IceWorld"
  StyleRange     (0.00, 0.00)
  colorSea       (0.30, 0.25, 0.22, 0.00)
  colorShelf     (0.37, 0.31, 0.28, 0.00)
  colorBeach     (0.77, 0.70, 0.64, 1.00)
  colorDesert    (0.82, 0.75, 0.69, 0.50)
  colorLowland   (0.73, 0.70, 0.64, 0.80)
  colorUpland    (0.69, 0.65, 0.61, 1.00)
  colorRock      (0.53, 0.43, 0.37, 1.00)
  colorSnow      (1.00, 1.00, 1.00, 1.00)
}

Brown-grey colors

Palette {
  Class          "IceWorld"
  StyleRange     (0.00, 0.00)
  colorSea       (0.30, 0.25, 0.22, 0.00)
  colorShelf     (0.37, 0.31, 0.28, 0.00)
  colorBeach     (0.60, 0.56, 0.54, 1.00)
  colorDesert    (0.49, 0.36, 0.25, 0.50)
  colorLowland   (0.75, 0.69, 0.66, 0.80)
  colorUpland    (0.76, 0.74, 0.70, 1.00)
  colorRock      (0.25, 0.21, 0.15, 1.00)
  colorSnow      (1.00, 1.00, 1.00, 1.00)
}

Blue-grey

Palette {
  Class          "GasGiant"
  StyleRange     (0.00, 0.00)
  colorSea       (0.28, 0.26, 0.25, 1.00)
  colorShelf     (0.30, 0.28, 0.27, 1.00)
  colorBeach     (0.01, 0.01, 0.03, 1.00)
  colorDesert    (0.22, 0.30, 0.41, 1.00)
  colorLowland   (0.69, 0.61, 0.53, 1.00)
  colorUpland    (0.30, 0.29, 0.27, 1.00)
  colorRock      (0.41, 0.37, 0.36, 1.00)
  colorSnow      (0.61, 0.59, 0.70, 1.00)
}

Light colour

Palette {
  Class          "GasGiant"
  StyleRange     (0.00, 0.00)
  colorSea       (0.28, 0.26, 0.25, 1.00)
  colorShelf     (0.30, 0.28, 0.27, 1.00)
  colorBeach     (0.79, 0.75, 0.72, 1.00)
  colorDesert    (0.75, 0.73, 0.72, 1.00)
  colorLowland   (0.68, 0.67, 0.64, 1.00)
  colorUpland    (0.57, 0.59, 0.60, 1.00)
  colorRock      (0.55, 0.55, 0.56, 1.00)
  colorSnow      (0.69, 0.66, 0.62, 1.00)
}

Red-brown-grey colors

Palette {
  Class          "GasGiant"
  StyleRange     (0.00, 0.00)
  colorSea       (0.28, 0.26, 0.25, 1.00)
  colorShelf     (0.30, 0.28, 0.27, 1.00)
  colorBeach     (0.08, 0.04, 0.04, 1.00)
  colorDesert    (0.90, 0.42, 0.25, 1.00)
  colorLowland   (0.62, 0.11, 0.10, 1.00)
  colorUpland    (0.90, 0.42, 0.25, 1.00)
  colorRock      (0.34, 0.16, 0.09, 1.00)
  colorSnow      (0.69, 0.66, 0.62, 1.00)
}

Red-black-grey colors

Palette {
  Class          "GasGiant"
  StyleRange     (0.00, 0.00)
  colorSea       (0.28, 0.26, 0.25, 1.00)
  colorShelf     (0.30, 0.28, 0.27, 1.00)
  colorBeach     (0.08, 0.04, 0.04, 1.00)
  colorDesert    (0.08, 0.04, 0.04, 1.00)
  colorLowland   (0.62, 0.11, 0.10, 1.00)
  colorUpland    (0.08, 0.04, 0.04, 1.00)
  colorRock      (0.34, 0.16, 0.09, 1.00)
  colorSnow      (0.69, 0.66, 0.62, 1.00)
}

Light brown colors

Palette {
  Class          "GasGiant"
  StyleRange     (0.00, 0.00)
  colorSea       (0.84, 0.73, 0.57, 1.00)
  colorShelf     (0.85, 0.75, 0.60, 1.00)
  colorBeach     (0.34, 0.29, 0.20, 1.00)
  colorDesert    (0.46, 0.38, 0.27, 1.00)
  colorLowland   (0.56, 0.47, 0.32, 1.00)
  colorUpland    (0.58, 0.50, 0.36, 1.00)
  colorRock      (0.73, 0.63, 0.48, 1.00)
  colorSnow      (0.69, 0.66, 0.62, 1.00)
}

Grey colors

Palette {
  Class          "GasGiant"
  StyleRange     (0.00, 0.00)
  colorSea       (0.81, 0.81, 0.81, 1.00)
  colorShelf     (0.63, 0.65, 0.65, 1.00)
  colorBeach     (0.58, 0.56, 0.58, 1.00)
  colorDesert    (0.61, 0.61, 0.63, 1.00)
  colorLowland   (0.72, 0.72, 0.72, 1.00)
  colorUpland    (0.78, 0.78, 0.78, 1.00)
  colorRock      (0.54, 0.54, 0.56, 1.00)
  colorSnow      (0.69, 0.66, 0.62, 1.00)
}

Dark grey colors

Palette {
  Class          "GasGiant"
  StyleRange     (0.00, 0.00)
  colorSea       (0.30, 0.30, 0.30, 1.00)
  colorShelf     (0.30, 0.30, 0.30, 1.00)
  colorBeach     (0.25, 0.25, 0.25, 1.00)
  colorDesert    (0.25, 0.25, 0.25, 1.00)
  colorLowland   (0.30, 0.30, 0.30, 1.00)
  colorUpland    (0.80, 0.80, 0.80, 1.00)
  colorRock      (0.24, 0.24, 0.26, 1.00)
  colorSnow      (0.30, 0.30, 0.30, 1.00)
}

Dark grey with more white clouds

Palette {
  Class          "GasGiant"
  StyleRange     (0.00, 0.00)
  colorSea       (0.30, 0.30, 0.30, 1.00)
  colorShelf     (0.80, 0.80, 0.80, 1.00)
  colorBeach     (0.25, 0.25, 0.25, 1.00)
  colorDesert    (0.25, 0.25, 0.25, 1.00)
  colorLowland   (0.30, 0.30, 0.30, 1.00)
  colorUpland    (0.80, 0.80, 0.80, 1.00)
  colorRock      (0.24, 0.24, 0.26, 1.00)
  colorSnow      (0.30, 0.30, 0.30, 1.00)
}
Deserts:

Olivine mountains

Palette {
  Class          "Desert"
  StyleRange     (0.00, 0.00)
  colorSea       (0.69, 0.54, 0.42, 0.00)
  colorShelf     (0.64, 0.50, 0.37, 0.00)
  colorBeach     (0.86, 0.70, 0.50, 0.00)
  colorDesert    (0.75, 0.59, 0.42, 0.00)
  colorLowland   (0.63, 0.48, 0.35, 0.00)
  colorUpland    (0.38, 0.30, 0.20, 0.00)
  colorRock      (0.09, 0.12, 0.07, 0.00)
  colorSnow      (1.00, 1.00, 1.00, 1.00)
}

Red desert

Palette {
  Class          "Desert"
  StyleRange     (0.00, 0.00)
  colorSea       (0.69, 0.54, 0.42, 0.00)
  colorShelf     (0.64, 0.50, 0.37, 0.00)
  colorBeach     (0.81, 0.45, 0.32, 0.00)
  colorDesert    (0.61, 0.31, 0.21, 0.00)
  colorLowland   (0.76, 0.45, 0.32, 0.00)
  colorUpland    (0.96, 0.57, 0.39, 0.00)
  colorRock      (0.42, 0.24, 0.16, 0.00)
  colorSnow      (1.00, 1.00, 1.00, 1.00)
}

Cream and red dunes

Palette {
  Class          "Desert"
  StyleRange     (0.00, 0.00)
  colorSea       (0.69, 0.54, 0.42, 0.00)
  colorShelf     (0.64, 0.50, 0.37, 0.00)
  colorBeach     (0.80, 0.77, 0.51, 0.00)
  colorDesert    (0.88, 0.67, 0.48, 0.00)
  colorLowland   (0.80, 0.69, 0.49, 0.00)
  colorUpland    (0.99, 1.00, 0.75, 0.00)
  colorRock      (0.56, 0.50, 0.30, 0.00)
  colorSnow      (1.00, 1.00, 1.00, 1.00)
}

Arid badlands

Palette {
  Class          "Desert"
  StyleRange     (0.00, 0.00)
  colorSea       (0.69, 0.54, 0.42, 0.00)
  colorShelf     (0.64, 0.50, 0.37, 0.00)
  colorBeach     (0.69, 0.46, 0.35, 0.00)
  colorDesert    (0.43, 0.24, 0.18, 0.00)
  colorLowland   (0.49, 0.38, 0.39, 0.00)
  colorUpland    (0.90, 0.51, 0.33, 0.00)
  colorRock      (0.37, 0.25, 0.27, 0.00)
  colorSnow      (1.00, 1.00, 1.00, 1.00)
}

Red and yellow surface

Palette {
  Class          "Desert"
  StyleRange     (0.00, 0.00)
  colorSea       (0.69, 0.54, 0.42, 0.00)
  colorShelf     (0.64, 0.50, 0.37, 0.00)
  colorBeach     (0.51, 0.35, 0.27, 0.00)
  colorDesert    (0.74, 0.58, 0.36, 0.00)
  colorLowland   (0.65, 0.52, 0.27, 0.00)
  colorUpland    (0.67, 0.47, 0.32, 0.00)
  colorRock      (0.50, 0.34, 0.24, 0.00)
  colorSnow      (1.00, 1.00, 1.00, 1.00)
}

Light turquesa desert

Palette {
  Class          "Desert"
  StyleRange     (0.00, 0.00)
  colorSea       (0.69, 0.54, 0.42, 0.00)
  colorShelf     (0.64, 0.50, 0.37, 0.00)
  colorBeach     (0.41, 0.67, 0.63, 0.00)
  colorDesert    (0.26, 0.31, 0.23, 0.00)
  colorLowland   (0.49, 0.63, 0.49, 0.00)
  colorUpland    (0.38, 0.59, 0.50, 0.00)
  colorRock      (0.36, 0.39, 0.33, 0.00)
  colorSnow      (1.00, 1.00, 1.00, 1.00)
}

Contrast colors

Palette {
  Class          "Desert"
  StyleRange     (0.00, 0.00)
  colorSea       (0.69, 0.54, 0.42, 0.00)
  colorShelf     (0.64, 0.50, 0.37, 0.00)
  colorBeach     (0.51, 0.51, 0.49, 0.00)
  colorDesert    (0.19, 0.19, 0.22, 0.00)
  colorLowland   (0.55, 0.49, 0.46, 0.00)
  colorUpland    (0.49, 0.49, 0.47, 0.00)
  colorRock      (0.42, 0.41, 0.40, 0.00)
  colorSnow      (1.00, 1.00, 1.00, 1.00)
}

Butano

Palette {
  Class          "Desert"
  StyleRange     (0.00, 0.00)
  colorSea       (0.69, 0.54, 0.42, 0.00)
  colorShelf     (0.64, 0.50, 0.37, 0.00)
  colorBeach     (0.92, 0.56, 0.26, 0.00)
  colorDesert    (0.85, 0.50, 0.24, 0.00)
  colorLowland   (0.71, 0.47, 0.29, 0.00)
  colorUpland    (0.55, 0.40, 0.33, 0.00)
  colorRock      (0.51, 0.43, 0.40, 0.00)
  colorSnow      (1.00, 1.00, 1.00, 1.00)
}


To the main question, remesh can be found in 2 places when in sculpt mode. One is in the header of the 3D View to the right, maybe you need to scroll it with the "alt+click" on your pen or middle mouse button, the second one is in the Active Tools and Workspace Settings, right above the Render Properties tab, there between Options and Workspace.

Regarding the switching of objects while in sculpt mode, since you are using the middle mouse button emulation, the alt is not working since it's used for rotating the 3D View.
You may have to use "ctrl-tab" to open a pie menu and select "object-mode", to switch back, well same pie-menu. Sadly the one keymap that could make it easier is non-modal, means it would overwrite not only the mode change in sculpting, but also in the object-mode. If you primary use sculpting it may be interesting for you non the less. In the second picture, the marked "Edit Mode" can be changed to "Object Mode", but as i mentioned it will toggle not only in sculpt mode, but also in other modes. You can always reset it back to "Edit Mode" though. It seems that you may need to switch at least once manually back to sculpt mode if you add a new object after switching from sculpt mode and select the new object, from then on it usually works fine with just "tab" to change mode, change selection and "tab" back, happy sculpting.


There are probably other ways of doing it but here is at least one. Sometimes you will need to create temporary geometry to instruct the tools what to do. In this case we need to have face normals so the inset tool could be used with depth.


Assuming it is not an issue with your keyboards shift key or an external program interfering with its function. (Network Mouse Applications usually interfere)

Goto User Preferences -> Input -> 3D View -> 3D View (Global) -> Activate Select Look for the Shift+Alt+Select Mouse Entry. It should have Toggle Selection and Enumerate checked. If it does not exist you have to create it or reset your whole keybindings.


How would I make a wave pattern onto a wall?

in order to make this kind of texture you can play with wave and noise textures as well, here is an example:

Result:

You can twek the settings for the texture pattern you are looking for, I hope it helps you.


How to get a straight edge on subdivided object

..Trying to figure out what aspect of Crease is not doing what you would want it to ..

The pink square is not subdivided.
The grey square in the foreground is subdivided, all sides but the top one with a Crease value of 1. (Set on selected edges in the Transform panel, 'Mean Crease')
On the right, all sides of the grey square with a Crease of 1, wires displayed.

(no Edge Split modifier)


Near bezier curve nodes affected when moving a node

The issue was that I needed to change my bezier curve type through the v menu. However to successfully change that I needed first to select all bezier handles in edit before pressing v and changing the type for all nodes. This is so because the nodes of a bezier curve object can be set to be different handle types and the v menu only changes the type for the selected nodes, not the curve itself.


scaling objects depending on instancer number (animation nodes)

A full procedural and vectorized approach would be as follows:

The cosine and sine are simply the parametric equation of the circle which is periodic, if we scale it based on its parameter, we get the spiral effect, the scale of the objects can be defined as a scalar multiple of the parameter as well.


Sending object data from blender with urllib very slow

using Mike Pan answer i have tried to split the code and put the networking part on a different thread see if this helps with the speed

import bpy
import urllib
import mathutils
from bpy import context
from urllib import request, parse
from math import sin, cos, radians
from mathutils import Matrix

import time
import threading

class Worker(threading.Thread):

    def __init__(self, values):
        self.values = values
        threading.Thread.__init__(self)

    def run(self):
        url = ''
        data = urllib.parse.urlencode(self.values)
        encoded_data = data.encode('ascii')
        req = urllib.request.Request(url, encoded_data)
        response = urllib.request.urlopen(req)
        the_page = response.read()

def RunPerFrame(scene):
    for obj in bpy.data.objects:
        mat = bpy.context.object.matrix_world
        loc = mat.to_translation()
        rot = mat.to_3x3().to_quaternion()
        scale = obj.dimensions
        qtX = round(rot.x,3)
        qtY = round(rot.y,3)
        qtZ = round(rot.z,3)
        qtW = round(rot.w,3)
        loX = round(loc.x,3)
        loY = round(loc.y,3)
        loZ = round(loc.z,3)
        scX = round(scale.x,3)
        scY = round(scale.y,3)
        scZ = round(scale.z,3)

    values = { 'msgInstruction=' : 'MOVE_OBJ','rotQuat=' : str(qtX) + ',' + str(qtY) + ',' + str(qtZ) + ',' + str(qtW),'objLoc=' : str(loX) + ',' + str(loY) + ',' + str(loZ),'objScale=' : str(scX) + ',' + str(scY) + ',' + str(scZ) }
    thread = Worker(values)
    thread.start()

bpy.app.handlers.frame_change_pre.append(RunPerFrame)


Where did the UV stretch option go in 2.91?

It's an overlay.
2.8 series introduced the concept of Overlays, which are all the things that are drawn on top of your mesh in the 3D view or the UVs in the UV editor.
From the manual:

The Overlays pop-over configures the overlays that are displayed on
top of images. In the header, there is a button to turn off all
overlays for the UV Editor. This option also toggles the visibility of
UDIMs tile information. The options that are visible in the pop-over
depend on the UV Editor mode.

Stretch falls into this category.


How to find what text file is open in text editor

Active text datablocks are referenced by TextEditor spaces:

bpy.types.SpaceTextEditor.text

for area in bpy.context.screen.areas:
    if area.type == 'TEXT_EDITOR':
        space = area.spaces.active
        print(repr(space.text))

# Example output with one visible text editor:
# bpy.data.texts['ui_menu_simple.py']


A simple solution with action:

You create an action with 4 rotation poses e.g. at frame 1 (North), 2 (West), 3 (South), 4 (East).

Then play the according pose dependent on the key:

Be aware:
This does align to the scene. It does not align to the camera!


Can't flip ColorRamp vertical using Mapping node (Cycles)

It looks like if you plug your Mapping node into a Converter > Separate XYZ node then put the Z outlet into the ColorRamp node, it works fine. You could also change the values of the Mapping node to have a vertical gradient (-35°, 45°, 0°).


What's the best way to build a GUI for non-blender users to control materials?

You can display any existing property in any place you want.
This means you can show properties of nodes, like the diffuse color or mix factor, in your own panel.

Example:

import bpy
from bpy.types import Panel

class ExamplePanel(Panel):
    bl_label = "Example Panel"
    bl_space_type = 'PROPERTIES'
    bl_region_type = 'WINDOW'
    bl_context = "render"

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

        obj = context.active_object
        if not obj:
            layout.label("Select an object")
            return

        mat = obj.active_material
        if not mat:
            layout.label("Create a material")
            return

        nodes = mat.node_tree.nodes
        # Note: you will have to edit these node names to use the ones in your setup
        diffuse_1 = nodes["Diffuse BSDF"]
        diffuse_2 = nodes["Diffuse BSDF.001"]
        mix = nodes["Mix Shader"]

        layout.prop(diffuse_1.inputs["Color"], "default_value",
                    text="Color of first diffuse node")
        layout.prop(diffuse_2.inputs["Color"], "default_value",
                    text="Color of second diffuse node")
        layout.prop(mix.inputs["Fac"], "default_value",
                    text="Factor of mix node")

if __name__ == "__main__":  # only for live edit.
    from bpy.utils import register_class
    register_class(ExamplePanel)

To find the names of your nodes, open the right side panel in the node editor (shortcut N) and select the node:

Here you can see the new panel on the right, and the node editor on the bottom.