Python: How to Save UV Layout With Specific Background Color?

It is not that hard to overwrite the function provide by the module itself (it is still in Python scope):
import io_mesh_uv_layout
from io_mesh_uv_layout.export_uv_png import *

def new_export(filepath, face_data, colors, width, height, opacity):
    offscreen = gpu.types.GPUOffScreen(width, height)
    offscreen.bind()

    try:
        bgl.glClearColor(0.0, 1.0, 0.0, 0.9)  # Here, a green, 0.9 alpha background
        bgl.glClear(bgl.GL_COLOR_BUFFER_BIT)
        draw_image(face_data, opacity)

        pixel_data = get_pixel_data_from_current_back_buffer(width, height)
        save_pixels(filepath, pixel_data, width, height)
    finally:
        offscreen.unbind()
        offscreen.free()

io_mesh_uv_layout.export_uv_png.export = new_export  # Directly overwrite it

In your addon, you can provide a color picker(from a color float property) for user. And after updating the value, patch the original export function on the fly. There shouldn't be any tricky part and no performance issue at all.

A more complex method is to modify the uv layout export itself:

Which needs to modify the operator itself, kind of tricky but more flexible to use:
 (Comment included)


2.8 evee - can I "mask" a mesh/material outside of a container (like a domain)?

This sound like a boolean modifier could help you.

Simplified setup, with a cube and a VolumeMesh.

Add a boolean modifier to the object which needs to be invisible outside of the volume. Choose the Intersect operation (default) and choose the VolumeMesh as the object of the modifier.


How to call F6 menu after calling solidify mesh command?

Since you are wrapping the Solidify operator inside your operator :

create a property (variable ) to hold the thickness and pass it to the solidify operator.
create a draw() function and call it ( the F6 will also call this draw() function )
you can display the menu of your operator to control the solidify operator through the property.

import bpy
from bpy.props import FloatProperty

class SolidifyDialog(bpy.types.Operator):
    bl_idname = "solidify.dialog"
    bl_label = "Solidify Dialog"
    bl_options = {'REGISTER', 'UNDO'}

    thickness = FloatProperty(
                name = "thickness",
                default = 0.001,
                min = -10,
                max = 10,
                unit ='LENGTH'
                )
    def execute(self, context):
        bpy.ops.mesh.solidify(thickness = self.thickness)
        return {'FINISHED'}

    def draw(self, context):
         layout = self.layout
         row = layout.row()
         row.prop(self,"thickness")

    def invoke(self, context, event):
        wm = context.window_manager
        return wm.invoke_props_popup(self, event)

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

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

if __name__ == "__main__":
    register()

note : wm.invoke_props_dialog() didn't work as expected , it doesn't update the view while changing the value so i switched to wm.invoke_props_popup()


The part which led me to confusion was using the auto-generated noise texture:

!! Notice the Size: 0.00.
It basically means, the/bumps dots were to be extremely small no matter how many subdivisions i applied. After I increased the size to 0.1, problem was solved:


You can get the location of a Node as well as the width and height, but the position of the socket does not seem to be available. This is likely to be because nodes can be in collapsed or expanded states and so a particular socket may or may not be visible at any given time.

You should be able to get pretty far knowing the dimensions and location of the node itself though. You know that all inputs are on the left side and all outputs on the right, and you can find out which nodes are linked to which, so you could do a topological sort and arrange the nodes with some minimum amount of spacing.


Interchanging characters within the same scene

Yes. You can control these sorts of things in many ways. You can use layers, showing and hiding objects, combining meshes into different objects, and of course Linking models from different files. It is a very broad area.


How can the Levels compositor node be used?

This node will output a single float value based on input image.

Mean is the average value of all image pixels in specified channel (combined, red, green, blue, luminance). It tells you how dark or bright the image is and can be used as such for setups that depend on how is input "bright" or "dark".
The Std Dev is how much those pixel values differ from the mean. A low standard deviation indicates that the pixel values tend to be very close to the mean. A high standard deviation indicates that the values are spread out over a large range of values.

The visualization of such data is just a grey rectangle.


Get value from a bpy.types.Scene property

You can access using bpy.context.scene likes this: print(bpy.context.scene.myprop) or set it equal to a variable: value = bpy.context.scene.myprop, also in your post, make sure you have IntProperty not InProperty like you currently have.


Set the surface displacement to Displacement and Bump or to Dislplacement only (the default is bump, which will not deform the object, and only affect the shading, creating  "fake" relief.]1

Displacement needs vertices to operate on.
Here is a simple plane with 4 vertices and dislplacement. Here's the same plane subdivided 50 times:


I don't think there's an extrusion, but there is an extension.. sliding those vertices along their edges, beyond the edges' original extents. That would be GG, either holding down Alt, or hitting C, to release the clamp.
The slide won't automatically stop at the point of the pyramid.. it can  go beyond it .. that may not be what you want.


Your blend type is set to mix. Change it to add.


It could also be way to big, try hitting the . key on the number pad and see where it takes you, if it's to big, scale it down. It also helps to set the origin to "centre of mass" or "geometry" and resetting its location with alt+g.


How do I achieve this color effect in the compositor?

You can use a hue correct node and using the saturation controls select the color range you want to affect:


What are the valid types for the type parameter in bpy.context.scene.node_tree.nodes.new(type)?

The correct type for this would be: 'CompositorNodeIDMask'.

Too create a new ID Mask node the line would be :  C.scene.node_tree.nodes.new('CompositorNodeIDMask')

If this is confusing, at least they have a pattern so you have 'CompositorNode'or'ShaderNode'or'TextureNode' plus the node type like 'ShaderNode'+'ObjectInfo'.

For the full list of node types see these links: shader nodes, compositor nodes and texture nodes


Rendering video sequence editor by scripting

It seems that by specifying:

bpy.data.scenes["Scene"].render.filepath = "/Users/***/Blender/mkv/"

Blender tries to create the file with the directory name (I actually thought that Blender added automatically the filename with the start and end frames...). I changed it to:

bpy.data.scenes["Scene"].render.filepath = "/Users/***/Blender/mkv/" + str(n_strip) + ".mkv"

inside the loop and it now works perfectly.

Kudos to batFINGER for the hint.


Symmetrize seems to be stuck on the wrong axis

The symmetrize operation will happen on the Y local axis, your armature is not correctly oriented. You should also align your armature to the Global front view. So in Object mode, rotate your armature 90° on the Z axis, apply its scale and symmetrize again.


Background video is way too bright when rendered

So for this clip, I was able to fix it by turning off and on all the render passes (Z, Combine, Vector)... strange that it worked since I didn't actually change anything at all. Must be a small bug, no matter since it's easy to fix!


Snap an inset face to edge instead of in the center?

This only works when there are open edges.
You need to remove some faces to make it work.

Remove the bottom face
Inset and uncheck Boundary
Done


Why video appears in lower left corner when offset is checked in strip transform parameters?

Offset and Crop are working in pretty odd ways: https://developer.blender.org/T74323
The best way to deal with them is to use the Transform Tools add-on(until they're fixed):
https://github.com/doakey3/VSE_Transform_Tools
After installing, you'll find the Transform options in the Toolbar in the left side of the Preview:

(Btw. in order to get Transform Tools working, you'll need to update Blender to 2.83)
In the latest beta of 2.90 the bug you mention may have been fixed.


Play with the Screw modifier.

Create a circle.
Hit R X 90 Enter.
CNTL-A > Rotation and Scale.
Edit mode. Select the circle. G X 2 Enter.
In the Modifiers palette, select Screw. By default, you will have generated a torus.
Screw: 1.5 (play with this value).
Iterations: 3 (play with this value).

That gets you your barberpole pillar. From there, experiment :)


You can transfer lower-poly simulation into high-poly mesh with Surface Deform modifier. Lower-poly or mid-poly sim is also easier to control and weight-paint.


How do you texture multiple objects with a single image?

USING TEXTURE ATLAS ADD ON

Instal an add on in User Preferences (Ctrl+Alt+U).

Select all objects in Object mode then press '+' button in the Texture Atlas panel.

Press Start Manual Unwrap button.

Go to the Edit Mode, select all meshes (A) and unwrap it as you like (in my case U-->Project from View (Bounds)), then press Finish Manual Unwrap button.

It will create one UV map for all the pieces.

JOINING, UNWRAPPING, SEPARATING MESHES

Remove doubles for all your pieces (in Edit Mode press W-->Remove Doubles) and join all objects in Object Mode with Ctrl+J. Unwrap it in Edit mode, then separate meshes with P-->By Loose Parts.


Internally, when you create a linked duplicate, blender does not actually duplicate the object, but it has another reference to it, thus, when you edit the objects, you are editing all linked duplicates the same way. You need to break the link  between the two if you want to edit those elements separately.

Since I am pretty bad at explaining these sort of things without demonstrating, here are two helpful links about duplicates and linked duplicates.

I would advise you to look at these two links How to unlink a linked-duplicate? and Duplication -- Blender manual.


There is an addon called F2 (comes bundled with Blender by default) which could speed this up.

To enable the addon go to File > User Preferences > Addons (or Ctrl+Alt+U) and search for F2 and enable it.

Once enabled, this addon adds two new functions to the F key, one of which should speed up your workflow considerably (the other is described here).  Just create the first face of the spiral, then select the inside edge of the new face and hit F to create a new face along the spiral.  Then keep pressing F until you have filled the spiral.


You cannot select mirrored faces. If you want to select them, you need to apply the modifier and from this point you can make the 2 half different.


How would I setup a model for use with SSR in another game engine?

Turns out it was working, just not in the way one would think.
So, basically, what was happening was that it was not only reflecting off of the default world, but also onto the in game world. I didn't look close enough to notice, but that's what was happening.
In order to "fix" this, you need to set the enviroment map to an empty white (or black, or any other color for that matter) so that your true reflection will be overlayed on top.


Active camera not changing according to markers in viewport

Untick the "Use Local Camera" Button in View Tab.


The easiest way (I think) to create a Mobius ring is to use a bezier curve with an extrude value.

Add a bezier curve

Extrude and move the curve points into a rough circle.

Increase the 'Extrude' value on the curve properties to give the curve thickness:

The trick is to pick one of the middle curve points and press Ctrl+T to start the 'Tilt' tool. This will allow you to rotate the curve point. Type 180 while using this tool to completely flip the curve point.

You should end up with something like this:

There are actually 4 points in this curve but the last 2 are exactly on top of each other (lower left) to complete the circle.
Convert the curve to a mesh, enter edit mode and merge the start and end vertices using the Alt+M 'Merge' menu.
However, this may cause shading issues as the normals wont know which part of the mesh is 'inside' and which is 'outside'.


Baked normals not calculating gradient smoothly when using a depth map

Your saved image doesn't have enough color informations.
Save baked pass in OpenEXR format that can save information in unclipped bit depth.


Is it possible to have separate meshes for the same object i.e one for topology and one for materials and textures?

Not really.

Closest Match to What you Describe

The closest you could get would be to UV unwrap both objects so that they shared the same UV space (perhaps using project from view if they are pretty flat), and then bake the second object out to an image file, which you would then apply to the first object as an image texture. You would probably just bake the basic diffuse (i.e. the basic colours), as you would want the glossy or any other shaders you were using to be dynamic.

In honesty though, this doesn't really resemble any workflow that I am familiar with.

Possible Alternative

If I have understood your basic problem, it is that you want to texture the first mesh in a way that you can't do by simply using the polygons that you have (because you would have to alter the geometry to match the lines that you want). To keep the geometry intact, you want to Unwrap the first object, assign a blank image texture to it, and then use Blender's Texture Paint tools.

If you only care about painting a colour or image, you could just paint this straight on and use it as the colour input to a diffuse shader. You could mix that with glossy or any other share you liked, but obviously the effect of the latter would apply to the entire mesh.

If you need something more complex (e.g. different shaders on different parts of the model) you would paint yourself one or more masks (black images, with white indicating where you want the desired surface) and use these masks as a factor input in Cycles to apply different shaders to different areas of the mesh. This would allow you to (for example) have a Blue shiny area in one part of the mesh, and a Red dull area in another part of the mesh.

If you don't like Blender's Texture Paint tools, you can (of course) do everything I describe above using an external editor like Photoshop or Gimp.


How to cut a complex shape into a curved surface?

In complement to the answer given by Patdog (which stay the good answer corresponding to the exact question), you can also work on the ring on a flat surface and make the torch shape after, as it is easier to use the boolean modifier or other technics to make the rings when flat.

Here a stack of modifiers, starting from two flat shapes (the ring part and a slice to complement the torch) :

The slice is repeated using an array modifier and the ring part as 'start cap'
The curve gives the vertical shape for the torch
The simple deform makes the circular shape of the torch

The vertices on the border of the rings part and these on the border of the slice part need to correspond (same amount, same position)

You'll need to adjust a bit the two base objects positions relatively to their centers in order to have a good junction with the array modifier (so make sure to work with rounded measures in cm for instance).

The amount of repetitions given by the 'count' of the array modifier will lead the torch diameter.

The curve (used in the curve modifier) shape can be adjusted on top of the stack so that you can see immediately the result on the rounded torch.

Once you have adjusted all as you want, you'll need to apply the modifiers and remove doubles to complete the junction of the simple deform bending.

The bottom part of the torch (with the texts) can be done the same way : a bent flat surface.

In both cases, just make sure to have the good/enough inner geometry so that the bending can be done smoothly.


count down on button press in blender game engine

Yes, easily through logic bricks and using a text object.

In this example, the property start rules if the countdown is started. When Spacebar is pressed start becomes True, then the Text property gets decreased each 60 frames (that is, 1 second).

Example blend file provided below.

Example file:


How can I update a mesh's physics while in the game engine?

An ideal way, in my opinion, is to have the entire character surrounded by a bounding box which will be used to have basic collisions with map entities (examples: walls, barrels, floor). Also, we can have a separate object, your character model, that will be used to have collisions with specific entities (example: bullets, rays). Your character model will have a simple python script that will ensure that his mesh updates every tick, making accurate collision. Furthermore, since the character model is contained in the bounding box, it will constantly collide (as they should be parented), meaning that your player will instantly launch off! We can fix this by changing both objects' collision group and collision mask. The collision group identifies which group of collisions it is in, and the collision mask identifies which groups it collides with. An object's collision mask and collision group is located in the physics tab.

This way, we won't have the character model get stuck and have jittery movement when playing animations (as the collision area will change shape), and specific collisions will work as you have your character model serve for that purpose.

To update the character's mesh every tick, use the following:

import bge

def update(cont):
    own = cont.owner
    own.reinstancePhysicsMesh()

if __name__ == "__main__":
    update(bge.logic.getCurrentController())


bmesh.ops.rotation() by default rotates the mesh about objects the local axis and the default center of rotation is the object local axis origin.

Bmesh.ops.rotation() has five inputs bm, cent, matrix, verts and space. bm corresponds to the the mesh to rotate, the center of rotation  which is a vector, matrix corresponds to the 3x3 rotation matrix by which you want the mesh to be rotated by and verts corresponds to the vertices in the mesh bm you want to apply the rotation.
The space corresponds to the space in which the object is to be rotated in and is represented by the rotation matrix of that object with respect to the global. By default the space is set to local space or correspondingly the object's rotation matrix.

One can select an object, say a cube, and go to blender interactive console. Go to edit mode and then type in the console

mesh = bmesh.from_edit_mesh(bpy.context.active_object.data)

Which will store mesh data to 'mesh'. You can then go ahead and vary the parameters say if one types

bmesh.ops.rotate(mesh,matrix=M,verts=mesh.verts)

for some rotation matrix M, then you can see the entire mesh rotated by the matrix M  about the objects local axis after the view port updates. If you type in this code

bmesh.ops.rotate(
    mesh,
    verts=mesh.verts,
    cent=(0.0, 1.0, 0.0),
    matrix=mathutils.Matrix.Rotation(math.radians(90.0), 3, 'Z'))

Then it will rotate the vertices about the point (0,1,0) in local space and about the current local axis Z by 90 degree.

Other mesh operators and information can be found in BMesh Operators Documentation


How to tell which function is causing errors from bpy.app.handlers?

You can write functions which intercept the existing functions and print out information, eg:

Given the following test example:

import bpy
def test_handler_a(scene):
    print("  Some Pre Handler", scene)
bpy.app.handlers.frame_change_pre.append(test_handler_a)

def test_handler_b(scene):
    print("  Some Post Handler", scene)
bpy.app.handlers.frame_change_post.append(test_handler_b)

This script sets up intercepting functions that print out all handlers that run:

import bpy
import sys

def intercept(fn, *args):
    print("Intercepting:", fn)
    sys.stdout.flush()

    fn(*args)

    print("... done")
    sys.stdout.flush()

for attr in dir(bpy.app.handlers):
    if attr.startswith("_"):
        continue

    handler_list = getattr(bpy.app.handlers, attr)
    if not isinstance(handler_list, list):
        continue
    if not handler_list:
        continue

    print("Intercept Setup:", attr)

    handler_list[:] = [lambda *args: intercept(fn, *args) for fn in handler_list]


Yesterday I found out how to control the particle's speed.
You can do this from "Timestep"!

You can find it in the "Particles" tab in the "Properties" window. Then go to "Physics" menu. Over there is the "Timestep" slide, which by default is on "0.040" which is quite fast. So if you want slower the particles you can change this to "0.005" or even for very slow motion you can set it to "0.0005".

And most of all!!! You can keyframe the particles "Timestep", so you can do nice and cool animations. I have made a quick demo in which you can see that. It's here: Particles speed test in Blender .

I hope I was helpful!

P.S.
I want to apologize about my bad english (it's not perfect).


The question, what is the result of first converting  a Bezier curve to a mesh and then back to a curve is still interesting. But I found a way to solve my original problem. I think it is not a work-around but the proper way of doing it. I needed to extend a Bezier curve by a new curve of fixed precomputed length. This is what I do: I generate an auxiliary  polygon of the desired length exactly in the place where I need the extended curve with the help of "measurelt".  Then I extend the Bezier curve following the polygon. Then I delete the auxiliary polygon.


Try it with the Tissue addon:

Enable the addon. Create a lowpoly version of your helmet (the size of the pattern will depend on the size of your faces) and create the hexagonal pattern:

In Object mode, select the pattern, then the helmet, and in the N panel > Edit > Tissue Tools > Press Tesselate:

It has created this net, it has some flaws that you can correct. Keep your helmet where it is (or bring the highpoly), make it invisible, select the net, give it a Shrinkwrap modifier with the helmet as Target:

Go in Edit mode and bring some correction to the topology so that you only keep hexagons or kind of, the Shrinkwrap will help to keep the vertices on the surface of the helmet:


IBL with cycles: can I use a different background image from the one that affects the model?

The Cycles render engine uses a ray-traced system, in order to render, so there are multiple rays casted while rendering, and you can use the Lightpath node, in order to determine the type of ray; Take a look at this node setup:

You will get this effect:

Note that I added a RGB Curves node in order to reduce the brightness and contrast of a instance of the image, which is only visible to the camera; The white circle and oval in the image represent the same area, yet look different. Maybe I exaggerated the effect a little bit...

Also, you can do logical operations such as OR or AND in order to use multiple ray types; If you want more details on this, ask it as a new question.


Need help with rotating different faces of a rubik's cube with python API. When different faces are rotated sequentially some cubes start to act up

Gimbal lock has been occurred for using rotation_euler. Can you try rotating matrix_local or matrix_world. It also has the advantage of simplifying the calculation of the rotation position from the rubik cube origin.


It is because LookDev don't care about lighting, materials,etc. It just gives the quick view of how render will look.
So first of all add a lamp to viewport by Shift+A and click Lamp>Sun, Grab it by pressing G and take it on top of your object.
Edit:
I missed out to look the rendering engine you have selected, It should be Cycles. Change it to Cycles by going to render settings and click on Rendering engine dropdown and select Cycles.

  EEVEE is not capable to show reflections and stuffs.


Animate MakeHuman character with BVH using Three.js

The simplest process to achieve character animations, created from makehuman in Blender is the following:

1. Install makewalk. This is a Blender addon that should be contained in a folder called blendertools in your makehuman folder.

Drag the makewalk folder into your blender addons folder. On windows, it is c:\users*your_name*\appdata\roaming\blender foundation\blender\2.78\scripts\addons

Then, within blender, go to setting, addons, hit the refresh button on the bottom of the window, and search for makewalk, and enable it, then save your settings

2. Install the .mhx2 plugin to export from Makehuman and import into Blender. The addon consists of two seperate parts - one addon for makehuman and one for Blender.

Download information and instruction on how to install can be found here

3. Create your character in Makehuman, add a mocap skeleton, and export as mhx2, taking note of the setting shown below

4. Import the mxh2 model in blender.

5. Download motionbuilder compatible bvh files. Here is a source with thousands of motion capture files https://sites.google.com/a/cgspeed.com/cgspeed/motion-capture/cmu-bvh-conversion

6. In blender, with the makewalk addon, attach the bvh file to your character's armature.


How to set the easing of keyframe with Python (fast, slow, etc.)

To select the keyframe points with frame = time of the scale fcurves, and set easing to 'EASE_IN'

import bpy

context = bpy.context
obj = context.object

action = obj.animation_data.action
fcurves = [fc for fc in action.fcurves if fc.data_path == "scale"]
#fcurve = action.fcurves.find("scale", index=0) # location.x fcurve
time = 1 # frame
for fcurve in fcurves:
    # iterate thru keyframe Points and change easing of those at frame = time
    for kfp in fcurve.keyframe_points:
        # ('AUTO', 'EASE_IN', 'EASE_OUT', 'EASE_IN_OUT')
        if kfp.co.x == time:
            print("scale.%s easing set to EASE_IN at frame %d" % ("xyz"[fcurve.array_index], time))
            kfp.easing = 'EASE_IN' #  auto

alternatively can create an action, fcurve and keyframe points eg make a new action with scale fcurves and add one keyframe (40, 3.9) with easing 'AUTO'.

import bpy
context = bpy.context
# create a new action and assign it to object
action = bpy.data.actions.new("ScaleAction")
context.object.animation_data.action = action
# fcurve data_path
data_path = "scale"
# (frame, value) for keyframe point
time = 40
value = 3.9
for axis in [0, 1, 2]:
    # new fcurve
    fc = action.fcurves.new(data_path, index=axis)
    # add a new keyframe point
    fc.keyframe_points.add(count=1)
    for kfp in fc.keyframe_points:
        kfp.co = (time, value)
        kfp.easing = 'AUTO'


I assume that by "Blender Manual" you mean "Blender Internal".

The foam data layer is just an ordinary vertex color layer, you can see it in the object data, you can change it in the vertex paint mode, and Blender Internal can render it - see "Vertex Color Paint" and "Vertex Color Light" in Material/Options.


In your node setup you mix Transparent with Translucent. Translucent is not a good choice, it is generally mixed with an opaque node, it is made for objects like leaves, which are opaque when light hits from the front, and gets transparent when light hits from behind, which is not how smoke works, plus if you mix it with a Transparent it might be completely transparent on one side.
You should use a mix between Transparent and Diffuse or Emission, like that:


Click this button:

The if the little camera is grayed out, it means that the object is not visible in the render
If the eye is grayed out, it means that the object is not visible in the preview


Can we execute custom Python functions from driver expressions?

Your custom driver must add itself to the list of drivers BPY is aware of.
See the example here:
https://docs.blender.org/manual/en/dev/animation/drivers/workflow_examples.html#driver-namespace

import bpy

def driverFunc(val):

    return val * val    # return val squared

bpy.app.driver_namespace['driverFunc'] = driverFunc    # add function to driver_namespace


Round the coordinates of a model that outputs to a text file?

Round just returns a rounded version of your variable, it doesn't change the variable. Your code should read something like:

xloc = round(obj.location.x, 2)


How to change subdivisions after adding a grid

Immediately after adding the grid (See here for details as to why it has to be immediate) you can access various options at the bottom of the 3D toolbar (where it says Toggle Editmode in your screenshot) such as the x and y subdivisions:

You can also access these options (again, immediately after adding the grid) by pressing F6.

So you should:

Add the grid.
Increase x and y subdivisions as desired.
Then scale the grid up as much as you want.


Final result

One method is to create a volumetric cylinder and distort it by rotating it around the origin by an amount that varies based on the distance from the origin.

First, create a volumetric cylinder. This is achieved by calculating the distance from the origin in just two of the three dimensions (it's effectively a circle projected along the remaining axis). This can be achieved using the Dot Product vector maths node using the following arrangement (assuming the cylinder is to be produced along the 'y' axis) :

The Dot Product used in this way (with the same vector on both inputs) produces the square of the length of the vector. The following Power(0.5) node calculates the square root of the squared length - ie, the actual vector length. The Less Than node controls the radius of the cylinder.

NOTE : The Geometry Volume Sampling step size has been decreased to 0.010 in this example in order to improve the volumetric precision (at the expense of render time). Also, the Light Paths Volume Bounces has been increased from zero to 3 to allow multiple scatter bounces (see the properties panel at the right-hand side of the image).

In order to rotate the cylinder we need to use a rotation matrix similar to

X = x * cos(angle) + y * sin(angle)
Y = -x * sin(angle) + y * cos(angle)

Since we already know that the 'y' coordinate is irrelevant (since the cylinder is unchanged regardless of where along the y-axis it is viewed) we can simplify this by only actually needing to calculate in the X coordinate. This is therefore achieved with the following additional nodes :

NOTE : Varying the Value input node rotates the volumetric cylinder. The Multiply node multiplies the input value by 2*pi, converting the input value to radians - so 0.0 to 1.0 produces one whole rotation.

To produce a spiral we can simply vary the rotation based on the distance from the origin. This can be achieved with another Dot Product/Power node combination with the following additional nodes :

Increasing the Value input varies the number of turns of the spiral.

Note, however, that the spiral is stretched into a thin ribbon as it is rotated. To counteract this we can simply add additional nodes to vary the thickness of the original "cylinder" based on the distance from the origin :

Thickness controls how much the cylinder is scaled based on the distance and Bias controls the starting thickness at the centre of the spiral (prevents it collapsing down to a point).

Blend file included

Note that this is a very much "brute force" method of generating a spiral - and it can only produce a spiral with two "arms" (unless you were to truncate the spiral at y = 0 - in which case it would have a single "arm").

Another approach is to generate the spiral directly - rather than distorting a cylinder - by calculating for each 'sample point' the closest point that lies on the centreline of the spiral. Calculating the distance to the centreline of the spiral allows us to determine whether that point lies within the spiral. This produces more versatile results and does not require manual adjusting of the thickness. It can also generate spirals with any number of 'arms'.

To achieve this we need to be able to calculate the closest point on the centreline of the spiral. For any point in the volume we can determine a number of things about this 'closest point'

It lies on the 'plane' of the spiral - in our case we can use z = 0
The sample point in the volume is along the direction of the Normal of the centreline from the closest point - ie, it points away from or towards the origin.
The centreline distance from the origin varies based on the angle that the spiral centreline makes in the plane of the spiral (and, therefore, also its normal).

This allows us to calculate the closest point of the centreline for any point in the volume. Once we know the 'closest point' we can simply calculate the distance between it and the sample point to determine whether that point in the volume lies inside or outside the spiral (based on our desired "arm" radius).

Firstly, the angle to the origin - this can be calculated using standard trigonometry using the arctangent, since tan(angle) = x / y so atan(x / y) = angle. This will only give a result over half the rotation before repeating for the other half, so we need to include additional nodes to add 180 degrees (or 'pi' radians) for the second half of the rotation - ie, when the sign of the y-coordinate flips between positive and negative. This yeilds the following nodes to determine the angle from the coordinates :

The distance from the origin can be determined simply using the Dot Product and a Power(0.5) maths node (again, passing the same vector into both inputs of the Dot Product calculates the square of the distance, the power(0.5) takes the square root, resulting in the actual length of the vector) :

The modulo function is used to determine which rotation around the spiral arm is the closest to this point and this, adjusted based on the angle (calculated as above) gives us the point on the spiral that is closest to this sample point in the volume.

We can add in some nodes to allow the results to be adjusted (eg, varying the thickness based on the distance so that it thins out towards the ends of the arms) and this produces the following material :

To make it easier to reuse, we can create a node group that takes the vector in the volume, the desired properties of the spiral (number of "arms", "twistedness") :

This can be used as follows :

Now you have a configurable volumetric spiral, the only remaining challenge is to use this to produce a believable galaxy :

To make each galaxy different we can use the Object Info 'Random' property to generate the spiral properties to produce the following result :

Blend file included


the tutorial is telling you to set bones in the wrong position and then reverse many of them? anyway, you are in pose mode, that is intended to use when the rig is correct, and you wish to animate it. to correct the armature, you must me in edit mode...

so, select the armature, go to edit mode, select the bone gone wrong, press W and select "switch direction".


Edit keyframe values from graph or dopesheet using Python

When editing the value of the keyframe you have to set both handles as well. Example on how to set the value based on our famous Operator Simple template (should work for the dope sheet too):

import bpy

class SimpleOperator(bpy.types.Operator):
    """Tooltip"""
    bl_idname = "object.simple_operator"
    bl_label = "Simple Object Operator"
    bl_options = {'REGISTER', 'UNDO'}

    my_float_y : bpy.props.FloatProperty()

    def cpoints(self, context):
        ctrl_pts = []
        for c in context.selected_visible_fcurves:
            for k in c.keyframe_points:
                if k.select_control_point:
                    ctrl_pts.append(k)
        return ctrl_pts

    @classmethod
    def poll(cls, context):
        areas = ('DOPESHEET_EDITOR', 'GRAPH_EDITOR', 'TIMELINE')
        if context.area.type in areas:
            return True
        else:
            return False

    def invoke(self, context, event):
        wm = context.window_manager
        return wm.invoke_props_dialog(self, width=450)

    def execute(self, context):
        sel = self.cpoints(context)

        for k in sel:
            k.co = (k.co.x, self.my_float_y)
            k.handle_left = (k.handle_left.x, self.my_float_y)
            k.handle_right = (k.handle_left.y, self.my_float_y)
        return {'FINISHED'}

    def draw(self, context):
        lay = self.layout
        lay.row().prop(self, "my_float_y")

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

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

if __name__ == "__main__":
    register()

    # test call
    #bpy.ops.object.simple_operator()

Alternatively you can use an invoke_props_popup:

See: How do I get invoke_props_popup to work?


Your problem may lie in the fact that you used Cycles render while he tutorial is in, Blender render. This changes the UI and settings. Here is a video link by: Blender Guru, That hopefully may help you. https://www.youtube.com/watch?v=4_niVFliJ0E
You can change render engines after you have done the hair and it will keep what you have done.


Why is the symmetrize function cutting a face?

2 steps to solving this.

Firstly, to mirror to the other side of the head, your origin point needs to be in the center of the head because the orogin is the point everything is mirror from.
Then
Immediatly after symmetrizing a menu in the lower left will appear saying "Symmetrize". Click the triangle and a drop down will appear. Change the direction until you find something that fits your intention. It appears that you want to select X+ to -X in your object transforms, but this could depend on your objects rotation because the symmetry is local to the object's rotation as apposed to constant to the world scale.


My bone is affecting vertices not assigned to it?

If you created the weights with automatic weights then mesh proximity is what determines the automatic weights. This is a common problem.
Do not depend on eyeball inspection of the problem area. You may not be able to see fine differences of color.  Paint it zero weight for the problem bone.
I suggest you add another bone for the neck to create more precision

Bones have many options, the Blender User can actually see the weights for a single vertex in the [edit mode] with display of weights enabled. See image above.  This is not a tutorial.  BSE may have other tutorials as well as the site that rhymes with noonoob.


This issue is likely caused by pinning the data-block's properties after an object was deleted. The property tabs can be restored by unpinning.

Description of the pin functionality in the manual:

  By toggling on the pin icon to the right, Blender can be told to
  display in that editor only the currently shown data-block’s
  properties, disregarding further selection changes. Toggle off that
  pin to switch back to default behavior, showing active data-block’s
  properties.

Alternatively you can also uncheck Load UI when opening a project through File > Open in Blender, which ignores all UI settings stored in the project file. This can be helpful for example when loading a project from older versions of Blender with a different UI layout.


Multi-line Text in blf (with multi colour option)

Building on the previous answer, now you have to think about line-height. A reasonable line-height for typesetting is the height of capital M x 1.45. But the coefficient can range between 1.2 and 1.45 (See the wikipedia article on Leading. These values are suggestions, and for HUD text or UI information use the value that seems most pleasing and doesn't cause the text to be too close or too separated vertically.
Take for instance the default line-height of Blender fonts.

1 / 0.682 = 1.46    # it's only a suggestion anyway.

A multi-line version of the script from the previous question, might look something like this:
def draw_string(x, y, packed_strings):
    font_id = 0
    blf.size(font_id, 18, 72)
    x_offset = 0
    y_offset = 0
    line_height = (blf.dimensions(font_id, "M")[1] * 1.45)
    for command in packed_strings:
        if len(command) == 2:
            pstr, pcol = command
            #bgl.glColor4f(*pcol) -> Blender 2.7x
            blf.color(font_id, pcol[0], pcol[1], pcol[2], pcol[3]) # Blender 2.8x
            text_width, text_height = blf.dimensions(font_id, pstr)
            blf.position(font_id, (x + x_offset), (y + y_offset), 0)
            blf.draw(font_id, pstr)
            x_offset += text_width
        else:
            x_offset = 0
            y_offset -= line_height

x = 60
y = 100
RED = (1, 0, 0, 1)
GREEN = (0, 1, 0, 1)
BLUE = (0, 0, 1, 1)
CR = "Carriage Return"
ps = [("Blue ", RED),("Yellow ", BLUE), CR, ("White ", GREEN)]
draw_string(x, y, ps)

You aren't limited to single words either:
ps = [("Blue Steel", RED),("Yellow Monk Fruit", BLUE), CR, ("White as an otter", GREEN)]
draw_string(x, y, ps)

produces this. (and note I forgot on purpose to add a space after "Fruit" to show how words are separated).

caveat: Don't change the "Carriage Return" string to something with 2 characters, it's a place-holder to keep the code simple and its length must be anything other than 2.


How to emit particles at intersection of faces (Scan animation)

Material
Dot pattern texture with appearance controled by Radial Blend texture.

Laser line is shrinkwrapped line, just for illustration, you will use your laser :)
Particles
They looks better, since there is not a deformation on surface curvature. I wanted to use the same Radial blend texture as factor for Emission, but I had some dificulties to get it work for particle system. So here is a version with particles emited from Shrinkwrapped line of vertices suggested by Rich Sedman
Works nice like real one in term - light string follows surface and keeps empty places where light cant touch surface (like in tail part).
Issue is distribution. I wasnt able to set even release particles from vertices.


Blender Rigging: Mesh's arm won't bend despite changing weight

The arm has some bad weight painting. If you look at the vertex weights panel you will find that eight bones effect the mesh movement for the arm, the most effect comes from Bone.005 which is the clavicle - between the neck and shoulder, and even a leg bone on the opposite side of the character is in the list. Bone.007 at the end of the arm only contributes 0.118 to the movement.

Use the panel to remove the effect from the unwanted groups. The copy button at the bottom will copy the weights from the active vertex to the other selected vertices. Note that it only copies the weights, any zero weighted bones will remain in the list and not be removed completely.


Technique or Tool for uniform mesh spacing?

Since they are located on the same distance from the centre you should be able to use scale from 3D Cursor (placed at centre) with Only Origins set. If you need to an exact distance that will need to be calculated.

Or in Blender 2.79b


From what I've read you can add pngs as texture information after they are rendered and then Select the Pack All option to save the png with the blend file.

But why do you want it to all travel together? Normally the objective of rendering is to get the images out of Blender so that you can use them on your website or something.


Baking normal maps from compound high-poly models

You can bake several objects into your lowpoly.

Simply select all of them, then maintain Shift and select your lowpoly. Make sure the lowpoly is outlined in yellow (meaning it is Active) while other objects are outlined in orange (meaning they're Selected).

In the baking options, check "Selected to active", and hit the "Bake" button.

While many objects can be selected at the same time, only one can be active. It's usually the last selected object, and its name appears top left of the viewport.


All you have to do is select one armature, shift select the other one, and then press Ctrl+J to join them.

Then shift select the two meshes that go with the armatures, and join them too.

Then all you have to do is select the mesh, shift select the armature, and press Ctrl+P. Then select the armature deform option.


One option is to select the camera (you will see the yellow selection on the border) and use G  to move or R  to rotate the camera.
another option is to lock the camera view by pressing N  on the viewport to open the sidebar> View > Lock Camera to view


I figured it out, sorry for the long delay. I was using a constraint on the foot bone (I think it was limit distance) to keep it from detaching, but that messed with the rest of the rig so it freaked out. I just deleted that constraint and it fixed itself.


Transforming vertices, edges or faces affects surrounding areas

You have accidentally enabled proportional editing. It can be disabled by clicking on the button shown in the screenshot below or toggled by pressing the O shortcut when using the default keymap.


Baking normals from high poly model to low poly issue

The problem could simply be in which order you selected the two meshes for baking. There are 2 levels of selection in blender when you select two or more objects: selected and active. The active shows with an orange outline whereas the other selected but not active object shows as darker orange/red. Make sure you first click on the high poly then on the low one when selecting:

BAD:

GOOD:

Note:

The baked normal map looks like it is for the knife on the bottom.  The area around the round holes seem like a smooth gradient whereas it that was the knife on the top poly, that area would show as flat.

You can see the issue in the mesh here:


The solution for me was to switch to edit mode Tab, select all vertices A, and apply (Snap to Symmetry).


Local variable referenced before assignment in script node?

The problem is that you don't assign a value to the 'Always' variable in all cases.

AN takes your code and makes a function from it that is executed by the Invoke Subprogram node. The generated code looks like so:

Line 16 throws the error here because you haven't used 'Always' before.
You can fix by changing your code to something like this:

if Bool == 1:
    Always = 1
else:
    Always = 0


Add a vector normalize node and a color ramp before the Z input on the defocus node. Playing with the sliders on the color ramp you should be able to find the point where you want to focus.


Color Mixing with textures and different objects?

Well, since Cycles is a physically-based engine... you can use a physically-based solution :).


I can't apply any modifier to my animation channel

You accidentally disabled the f-curves modifier on this channel. It's the wrench icon. Click on it to enable it.


Without seeing exactly what you were trying to do, it is hard to know how to advise you. But some general advice about using Booleans, pre version 2.91:

Both shapes should be closed volumes, with all normals pointing outwards
The shapes should not have self-intersections
The shapes should not intersect each other in such a way that edges, faces, or vertices of one shape exactly overlap edges, faces, or vertices of the other.

If any of these things is not true, Boolean might work but it is not guaranteed. This is probably why sometimes you tried, it worked,and other times it did not.
Blender 2.91 (to be released in late November) has a new Boolean solver that does not have problems with the second two of the above points. You can try it now in the daily alpha release builds of 2.91.


Yes, it is possible to do this with the current YafaRay v3 versions. You can use the "Mask Object Index" render pass, for example, using the mask render pass that includes the shadows in the mask.

For example:

I have uploaded the example scene here: cornellbox-yafaray-shadow-mask.blend.zip

I hope this helps. Best regards!!


Gradient shader according to the polygons size

You're using generated texture coordinates.  Generated texture coordinates are generated by looking at the bounding box of your object (before any deforming modifiers, but after any generative modifiers).  They range from 0 at the bottom, left, front of your object to +1 at the top, right, back of your object.  Because your drawer has a different bounding box, this means they are different coordinates.
You can revise your existing material to use different coordinates, although this is going to require some other editing.  Probably simplest is to make all objects from the material use the object coordinates of the larger cube.  However, object coordinates range from -1 to +1 instead of 0 to 1-- or at least, for your purposes they will-- and so you'll probably need to map them a bit:


Blender 2.8 Import Function does not find .obj or .ply file for import

Dragging it into Blender won't help, as Blender's drag and drop handling doesn't auto-check the file type and apply the relevant importer (unfortunately!).

It's possible that when you select Import > Wavefront (.obj) the file is being filtered out of the view for some name-based reason. You can disable filtering in the top right corner to view all files without extension filtering.

If none of that works and the importer is having some problem with the actual file, you'll get some sort of error message in the system console. But it doesn't sound like you've got that far yet.

"trying to open that file directly with Blender even causes Blender to CTD with no error message."
That one would be a bug, then. It should be able to notice that you're trying to use Open on something that's not a .blend file and not crash, but it seems you have discovered a case where that isn't happening.


One way to do it if your bounding box fits the object's dimensions:

1.) Select the Mesh Cube and then add the other object to the selection

2.) Copy the Dimensions and rotation info to the Cube

3.) Add Child Of constraint to Cube and select the object as the parent

4.) It will go wonky, so press the Set Inverse button in the constraint

5.) Finally, Restrict Selection so that it can't accidentally be manipulated


You can change the size of the grid to accommodate your needs, or you can change the scale of the whole scene.
To change the scale of the grid in the 3D view.
For 2.8X Open the overlay controls.

And change the scale and number of subdivisions.
For 2.7X
Press N to reveal the properties shelf.
On the Display section you can change the grid floor number of lines and scale.
The left side of the screen will show info on the scale of the units used.
From the wiki:

Lines defines the number of lines that will make the "floor grid" up. If N is the number defined, there will be a total amount of N/2 lines at each side of X and Y axes. For odd values of N, the amount of lines will be rounded down.
Scale defines the distance between grid lines, either in the "floor grid" and the infinite grid.
Subdivisions defines the amount of lines into which the infinite grid should be subdivided. Level of subdivision depends on zoom, in predefined orthographic views.

To change the scale used for the scene:
Other way to deal with large (or very small) objects is changing the scale on Properties->Scene->Units->Scale

Note that changing the scale for the scene in the Units Section will affect the size of the grid, but changing the size of the grid in the 3d viewport will not change the scene's scale.
Besides the floor grid, Blender has some built in measuring tools that you might find useful.
For 2.8, in Edit mode (Tab), open the Overlays section and you can choose to enable the boxes for Edge Length, Edge Angle, Face Area or Face Angle.

For 2.7X, in Edit mode (Tab), enable the numeric panel (Kbd>N) and look for the Mesh Display section, to enable display of edge and face info of an object.

When dealing with very large or very small objects they might seem to disappear from view due to the clip distance on the viewport. If that happens you might need to change the start and end clip values.
See this question: Why does part of my model disappear when I zoom in on it in the 3D Viewport?


If you're talking about the halos, they are actually controlled by the material settings. You can change the size there. Just make sure your editing the correct material. The particles will use the material specified in the Render portion of the particle settings. E.g. if "Material" is set to 1, then the particles will use the first material in the list.

I think what you actually want is for the halos to go away, and to use smoke instead (they're different techniques).


There is no built-in way to perform that task.

Many rigs provide python scripts that show panels in the 3dview for controls such as layer display and IK/FK switching, many also include scripts that snap IK bones to the position of FK bones and vice versa.

You can find the rigify scripts that are included with blender within the addons folder where you can look at how this can be achieved.

Most animators will tend to use one or the other depending on the actions being animated, keying the IK/FK influences on a transition frame when they change over. I believe you will find it difficult to be using both on every frame and only create extra work for yourself.


Increase your solidify-moifier to a thickness of 0.2 and bake again.


How do I speed up Blender Game animation?

You can speed up the playback of the animations by increasing the 'Animation Frame rate' speed in the Render properties editor.


You can acheive this with Cycles material nodes using the 'Gradient Texture' node.

Setting the gradient node to 'Quadratic sphere' (and with a little offset from the vector mapping node) restults in this (on a plane with uv basic unwrapping):

To control the scale of the 'Quadratic sphere' in the result above I scaled the UV's as scaling using the vector mapping node node seemed to scale it towards the corner.

For a linear gradient you can simply set the Gradient Texture to 'Linear':

For different colours you can simply use a colour 'MixRBG' node and use the factor of the gradient texture instead of the colour and connect it to the 'Fac' of the mix node.


My only suggestion is you could bake some of these maps to a single texture and apply the same texture to multiple objects. Only issue here is that you would have to UV Unwrap everything, which is a killer task with a scene as dense as this one. If you are interested in the baking process, Grant Abbitt has a pretty straight-forward tutorial for this.


This is a somewhat trivial task given the code is basically already there

Data contained in the same csv with columns like:

loc_x,loc_y,loc_z,rot_x,rot_y,rot_z

import bpy
import csv

f = start_frame = 1
frames_per_row = 10
csv_path = "C:/Book3.csv"

ob = bpy.context.object

with open(csv_path) as file:
    csv = csv.reader(file, delimiter=",")

    for row in csv:
        ob.location = [float(v) for v in row[:3]]
        ob.rotation_euler = [float(v) for v in row[3:6]]
        ob.keyframe_insert("location", frame=f)
        ob.keyframe_insert("rotation_euler", frame=f)
        f += frames_per_row

If two files need to be used you can either zip them beforehand or keep track using the keyframe. It is also possible to use quaternion rotation.


What is the point of Blenders camera sensor width?

Cameras in Blender are made to resemble cameras in real world. The size of the sensor is important when you need to match content created with a real camera with your CG, and that happens really often. Obviously, you might have a hard time to match your camera if you don't enter the correct sensor size. You should search for it online for the specific camera model your content is captured with.

You may also be used to real world cameras so it is easier to reach some desired result if you already know what to expect from some settings or parameters because they match real cameras.

If you have a look, you can see that Blender even comes with lot of presets matching real cameras:


How to solve my skin showing in my walk animation?

You could remove this part of your mesh, but you could also use the Mask modifier:

Select the part of the skin mesh you want to make invisible, create a vertex group.
Give your skin object a Mask modifier, select the group.
Invert the selection with the double arrows button.
Now this part of your mesh is invisible.

For more complexe meshes you should check out the Mesh Deform modifier method: create a cage around the clothes, give your clothes a Mesh Deform modifier with this cage as Target, and instead of parenting the clothes to the armature, parent the cage...


Apply face normal orientation to object Local Pivot Point orientation?

Not trying to be picky, but just to make asking easier in the future: in Blender the pivot is what you’ve selected to be the point you rotate around. What other software like 3ds Max calls the pivot, in Blender, is called the origin. I think that’s what you’re talking about. This is a serious shortcoming of Blender, the fact that you can’t directly modify the origin. There is an addon called BS Modify Pivot that does what you need. An alternative is that you move and rotate the object to the place you need it to be and then do the opossite move and rotation to the mesh in edit mode.


Grease Pencil with Pressure makes lines disappear

You have pressure disabled for Strength pressure (the pen icon), and a very small radius for the line stroke.
Use larger values.


Does Blender 2.8 still have skeleton sketching?

Blender 2.8 doesn't have this feature anymore. The reason is that the feature was rather obscure, not used by many people and the implementation had several bugs. You can see the discussion in ticket T52809 in the official bug tracker. The commit rB36773e35f6009693562330137435271922758b95 removed this feature back in April 2018 from the master branch.


I gave a try with this node setup, you need a mix between Translucent/Transparent/Subsurface Scattering/Glossy/Glass and at the end, plug the Principled Volume into the Volume socket of the Material Output:


You find the material properties in the Default Layout on the right side:

Your object already has a default material you can change the color by changing the settings in the section Diffuse.

To create more materials first create a new slot '+' symbol and press new.

Transparency is setup by ticking Transparency and ajusting the Alpha Slider.

If want to assign materials to single faces select the face and material in Edit Mode and press Assign.

Since you just started:This is only a tiny part of what you will learn about materials.

Please checkout the resources we already collected here:

Beginner's Reference


How can I tell what part of the model the UV map is from? (In Blender)

UV Face Identification and Coordination

Image above.  Open two windows. One with the mesh in [edit mode]. We assume one UV. One with the UV image editor with the texture selected.  If you select faces of the mesh model you will see them highlighted in the UV editor window with the default settings.  You can change the setting indicated by the yellow arrow are to keep the Selection in Sync.  You may select faces in either the UV Image Editor or The 3D View Window with mesh in edit mode.

Notice the face selection mode.  The red seam allows the blender user to move the islands.

Face Size

Relative Face size in the UV Map and face size of the mesh model can be different and this is a flexible feature. Same scale is not necessary. We might imagine we want more detail in the face of some character than we want on the bottom of the foot.

Changing Island Size


Is it possible to hide curves' guides in edit mode?

Those black lines are the normals for the curve.

Blender 2.79:

You can change the way they are displayed in the "Curve Display" tab.

Blender 2.80

To make them smaller change the normal size.

To make them disappear uncheck the normals box.


Can Blender still be used commercially since Java licensing has changed?

Blender is made with Python and C/C++, not Java. Also Blender is free and open source software that can be used commercially in any condition.
In completement a link to Blender's licence page.

Blender is released under the GNU General Public License (GPL, or
“free software”).
This license grants people a number of freedoms:
You are free to use Blender, for any purpose
You are free to distribute Blender
You can study how Blender works and change it
You can distribute changed versions of Blender

The GPL strictly aims at protecting these freedoms, requiring everyone
to share their modifications when they also share the software in
public. That aspect is commonly referred to as Copyleft.
The Blender Foundation and its projects on blender.org are committed
to preserving Blender as free software.


how to interpret the camera world matrix?

The solution is so obvious, I must be getting old :( Anyway, the world matrix of the camera is a transformation matrix, not a viewing matrix. To obtain a viewing matrix out of it, you need to invert (transpose) it and zero out the translation part.

Explanation:

We set all Euler angles of the camera to 0, so the local axes are aligned with the world axes (the "identity", non-transformed camera):

We see, that this camera is viewing in the negative local z direction, if we rotate by 90 degrees around the x axis we get the picture in the question. The columns of the world matrix being the transformed axes of the "identity" camera:

x column: [1,  0, 0]
y column: [0,  0, 1]
z column: [0, -1, 0]

To obtain a viewing matrix of the camera (for OpenGL, say), we need to transpose (write the columns as rows) and set the translation part to 0:

[1,  0, 0,  0]
|0,  0, 1,  0|
|0, -1, 0,  0|
[0,  0, 0,  1]

we can see the projection plane is formed by the world x- and z-axes, the local z-axis of the camera is aligned with the world -y-axis, but we view along the negative camera z direction, hence the world y-axis and so can see the cube.


This isn't exactly procedural, but it's OK for a one-off, maybe.

Create a single segment.

Start with a whole 36-section circle, rotated, inset,and translated in Edit Mode as shown, so its origin is at the center of an edge, at World 0. We're working in XY, Z out of the screen.

Select out the bottom segment, V rip the internal edges, and P separate by loose parts into 3 objects. Parent the point to the midsection, and the midsection to the base.

Make hierarchies of left and right segments.

ShiftD duplicate all the parts of the segment in place, and place the origin of the duplicate in its bottom-left corner. In Object Mode, with Snap set to 'Vertex'  Shift D X duplicate it to the right, and snap the duplicate to the original, in one move.

Shift R repeat the move, until you have 18 segments, not counting the original, which you can delete.

Do the same on the left, this time with the origins of the objects at the bottom-right corner, stopping at 17 segments.

Now we have to parent the base of each segment to the next, working towards the center. This is tedious, so you can do it with this little script, having selected the (bases only)  of the right and left-hand groups in two batches, switching the reverse parameter in the script appropriately:

import bpy

obs = bpy.context.selected_objects

# set reverse = True for right (positive X) segments
obx  = sorted (obs, key=lambda ob: ob.location[0], reverse=False)

for i in range(len(obx)-1):
    obx[i].parent = obx[i+1]
    obx[i].matrix_parent_inverse = obx[i+1].matrix_world.inverted()

Now when you set the Pivot to 'Individual Origins' and rotate the bases in Z, a curl results:

.. and R Z10 closes the right half of the circle. This rotation is keyable. On the left, it's R Z-10

When all the segments are present and selected in the curled position, and all thrown into Edit Mode simultaneously, they can be UV mapped together with 'Project from View: Bounds'. Then they can all share the same material, and all acquire their own UV map into the image texture.

Then you're kitted up to animate the rotations, and later the translations of the segment-sections.


Snap individual vertex of the selection to closest vertex

If you don't mind if the extra vertices are removed, you can use remove doubles and in the tool settings (F6), set the merge distance to something higher (probably in the range of .01 and .1). This will merge close vertices that are closer than a the merge distance.


How can I create a model like this? (see image)

There may be multiple ways of achieving this but I will be using metaballs for now as they offer a quick solution. Add metaballs on the fly, adjust, when you get an acceptable mesh, convert it to mesh ( alt + c), sculpt, add armature and pose it to achieve the final look.


Is there a way to round corners on material level?

A straightforward solution has been added to the most recent Blender distributions (after the released version of 2.79b, so you must download newer updates of 2.79b, or 2.80 Alpha, from https://builder.blender.org/download/ to enable it).

There's a single node (Input > Bevel) that fakes bevelled normals. Of course it won't change the geometry, so it doesn't look great from too close, but it can enhance pretty convincingly the specular/reflection at the edges.


objects.delete doesn't remove completely

Selecting the objects and letting bpy.ops.object.delete() remove them may not be a good idea, not least due to the performance of the bpy.ops calls. Maybe you can get the list of the selected objects using bpy.context.selected_objects. Then iterate over the objects and call:

for obj in bpy.context.selected_objects:
    if(obj.type == 'MESH'): #Maybe this is superfluous in this case
        bpy.context.scene.objects.unlink(obj)
        #material.users count is not reduced yet, even if object is gone from the scene
        bpy.data.meshes.remove(obj.data)
        #now material.users count is reduced by one
        #(Just be careful with the above call, since multiple objects can share the same data)
        bpy.data.objects.remove(obj)


Python: How can I change custom property for multiple objects at once?

Instead of accessing the ECollider like this: object.ECollider now I access it this way: object['ECollider'] and everything works fine. Full code modification:

def set_collider(self, context):
    selected_objs = context.selected_objects
    collider = context.active_object['ECollider']
    for obj in selected_objs:
        if obj != context.active_object:
            obj['ECollider'] = collider

bpy.types.Object.ECollider = EnumProperty(
    items=[('NC', 'None', ''), ('BC', 'Box Collider', ''), ('SC', 'Sphere Collider', '' ), ('CC', 'Capsule Collider', '')], name="Collider", update=set_collider
)


Create a cycles material from rendered picture

Something like this?

Or with mix nodes

I moved your light meshes a bit to fit the ref image and also changed the background from 2 to 1 to get darker shadows.


How can i model these grooves in my mesh correctly?

The easiest way would be to make each part of the mask a separate object. I would copy your faceplate as many times as many parts I need, and then reduce each copy into needed part. This way the parts would have proper shape, fit together, and have correct topology.


Shader Editor: graph multiple shader trees simultaneously

You can split your screen into as many Shader Editors as you want (which this post explains well) and pin a different node tree to each one.  You can also make parts of your textures reusable and instance them in other materials by making them a Node Group.  Then a change to the group will be reflected everywhere the group is used.
Say you have a part of a material you want to make reusable:

Select the nodes and press Ctrl + G to make a group.

The inputs and outputs will be made automatically depending on what was already in use.
You can copy and paste this Node Group to other materials, or pressing Shift + A and selecting Group you'll find it at the bottom of the menu.  My example has the default name NodeGroup.

You can see it is instanced because it will display the number of users.

You can also see that the Node Group can be used for different things in different materials.  You can group up as many nodes as you would like, indeed including BSDFs.
A change made inside the Node Group affects all of these objects.

This is where leaving one Shader Editor pinned inside the group may come in handy.  If you want a single user copy, you can make one by clicking on the button that displays the current number of users.


Background image not visible: What am I doing wrong?

Essentially you forgot to show the background images.

In the UI, you do this by pressing on the checkbox in the Properties Panel (N) --> Background Images.

In python, you do this by accessing the show_background_images property of the 3D view region within the 3D view space (within the 3D view area). This is what your space_data variable is referencing.

Another thing you could do (added in the last line below) is move directly to viewing through the camera when the script is done, to immediately see your BG image.

import bpy
filepath = r"C:\test\trees.jpg"
img = bpy.data.images.load(filepath)

rv3d = None
for area in bpy.context.screen.areas:
  if area.type == 'VIEW_3D':
    space_data = area.spaces.active

    rv3d = space_data.region_3d # Reference 3D view region
    space_data.show_background_images = True # Show BG images

    bg = space_data.background_images.new()
    bg.image = img
    break

cam = bpy.data.cameras.new("Camera")
cam_ob = bpy.data.objects.new("Camera", cam)
bpy.context.scene.camera = cam_ob
bpy.context.scene.objects.link(cam_ob)
bpy.context.scene.objects.active = bpy.context.scene.objects["Camera"]

rv3d.view_perspective = 'CAMERA' # Go to camera perspective to see your BG iamge


Vertex normals are determined by the interpolated face normals of the connected faces. When you have the transform orientation set to Normal the Z axis is aligned with the vertex normal.
Trouble is that there is no way for blender to know how to align the manipulator on the corners. It still has the Z aligned correctly, but that is not helping you here.

See in this image I have a mesh similar to yours, selected at different times in two different spots. Note that even though the manipulator is pointed in the "wrong" direction in the bottom corner, it is still correctly aligned with the vertex normal (blue line on each vertex).

As a work around you could align the view to one of the faces, with ShiftNumPad 7. Then change the Transform Orientation (in the 3D view header) to "View".


How do I "show" my UV Map after loading a new image?

I'm adding this to show the gif below. This should not happen, imho. You enter the mesh edit mode, and in the UV/image editor, you see the uvmap and the current mapped image. Then, you simply select another image.


The post you reference in your question is almost 10 years old and appears to rely on Blender features and APIs that are no longer available.

The code is definitely not for an OSL shader - so using a Script node will not work - it's actually a python script.

The first 'import' statement attempts to import 'Node' from package 'Blender' - as far as I understand it, this was the old package for API calls to interface with Blender that has since been replaced with package 'bpy' (blender python).

It is possible to create such an effect in the compositor using a similar technique to that apparently used in the original script.

To achieve this in the compositor we need to be able to determine the location of each pixel in the image so that we can determine how far each pixel is from the a grid used to position each of the halftone circles, scaling the circles based on the brightness at that point. The pixel location isn't directly availabel to the compositor nodes but we can use Blend Textures, which vary across the image, and feed those into the compositor to derive the X and Y location.

Start by swapping to the Texture properties panel and click 'New' to create a new texture. Give it a meaningful name (such as 'HorizontalBlend', set the Type to 'Blend' and set the direction to Horizontal. Ensure the Progression is set to Linear.

Repeat for 'VerticalBlend' (click the '+' to add a new texture), setting the direction of this one to Vertical.

These textures can be accessed in the compositor to determine the X and Y location in the image.

In order to create the halftone pattern we need to be able to split the image into a series of grid cells. Each cell will represent one 'blob' of the halftone pattern whose size will depend on the brightness of the rendered image at that point.

The following nodes can be used to generate an array of 'blobs' that we can use for the halftone :

This will produce something like the following :

The position in the image is split into a series of bands by the Modulo function (smaller values produce narrower bands). This is then multiplied up to the range of 0.0 to 2.0, 1 is subtracted (so the range is -1.0 to 1.0) and the Absolute node reverses the sign of the negative values. This results in a value that starts at 1.0, reduces to 0 at the grid line, and increases back to 1 - ie, the distance from the grid line. The same is done in the other dimension and the results combined (with pythagoras - a^2 + b^2 = c^2) to give the distance from the centre of each circle.

We can turn this into the halftone image by simply comparing the distance to the nearest centre with the brightness at the current point in the image. This produces the following rudimentary halftone :

To refine this a bit we can slightly change the pattern by offsetting each alternate row - this will produce a hexagonal arrangement of blobs that produces a more pleasing result :

Adding Mix nodes we can add a splash of colour for the two halftone shades and the background (set to black by setting Environment Ray Visibility to disable visibility to the camera) and the foreground (drawn using Freestyle as white lines) and nodes to allow fine tuning of the halftone (the Divide and Subtract nodes).

To finish this off we can add nodes to allow the horizontal and vertical dot pitch and better adjustment for the colours, brightness and contrast as well as Blur nodes to allow the effect to be softened (blurring before the halftone removes hard edges and fine detail that would interfere with the pattern, whereas the blur after the halftone softens the 'blobs' themselves) to produce the following nodes :

By unchecking the camera visibility of the environment (so it appears black) and by adding pure white edges using Freestyle we can achieve the following result :

Blend file included

EDIT
I've extended this to produce a colour halftone by simply splitting the image channels, duplicating the nodes, and re-combining the result. You could potentially change the dot pitch on each channel for different halftone effects.

Here's the node tree (apologies for the scale but it's included in the blend below) :

The coloured original :

And the coloured halftone :

Blend file included

You can also experiment with the dot pitch to use different pitch per channel. For example :


My answer works for the Cycles-Render-Engine:
In the Properties Editor select the World tab.  There you find the menue Ray Visibility (only in Cycles!). Uncheck all the boxes except Camera. If you want to see the world-environment in the reflections check the Glossy-Ray.


How to create drivers but maintain the ability to modify the property?

Custom Properties and Delta Transformation

Delta Transform Location X component with Driver cooperate nicely with regular Location. You may grab and move object with g.  Formula is in tooltip. See Arrow. Image above.  Emphasizing difference between regular object Location and Delta Location.
I am trying to prioritize various issues you have in your question above.  So some things I may say you might already know.  Same as in any candidate answer.
You may also create a Parent/Child relationship in Blender. Two objects selected and then Control P your object to another object to combine locations and have independence.
https://www.youtube.com/watch?v=kq3Ja-nNv7Q
For the near future ... I suggest you use the datapath only when self is data in the object panel,  in a Python Script. Self does not always refer to an object as displayed in the object panel. Self  might refer to a Modifier or Constraint or Material Setting or Fluid Setting ... depending on the panel with the driver.
The Blender Python Console Window and the OS owned text Console window are two different windows.
You wrote [pyFunction(self, target)]
In your function please add
print(type(self))
to see the text name in the Text Console Window.  The Python Console provides a python environment in a Blender Window. Text Console can show print results from a Script and may be provided by the OS. Menu / Toggle Console Window.
A driver on a location or delta location can refer to another custom property of a different object.  Final location is a combination of location and delta location.  Thus if driver controls delta location, then (regular) location can be be free for UI interaction control.
The same can be said analogously of rotation.  Other techniques exist.
Allow the driver to refer to a different custom property value.  Indirection can solve or introduce any problem.
Custom Properties have all the conveniences of other standard values of Blender.  They are keyframe capable.

Display of Custom Properties. Image Above.  Click the Add button, enter value. Please know there are default limits which can be edited.  Click the edit button.

Driver referring to custom property with offset as part of the expression or formula. Here I entered two properties on one object for purposes of less image editing.  You have more freedom than that.
Any object can hold custom properties which is similar to Python Dictionary. See [custom properties] which appear in the panel.  When the property is numeric for example it can be keyframed.  The keyframed property can be seen in the graph editor and manipulated like any other graph window curve.  The Driver can refer to those properties. Custom Property CRUD Create Reference Update Delete is possible.  If the user interface is inadequate perhaps the creation of a custom property can be another question.
Keep in mind Python functions can be registered for access in drivers.  This can explained more fully in another question or search.
And the driver can access the custom property by object name and property name or path.
Please note that it may be useful to create an independent object to hold custom property values.  Blender can complain with messages in the console window when it deems references for a cyclical dependency.  Blender may be arguable too strict about that.  But see the messages in the console might interfere with your needs.
A constraint can copy the location of another object if desired but is more dominating. I would test carefully to see the differences.


Blender dosn't interpret the Colorspace of the imported Image in the Compositor correctly

Blender does not support ICC profiles - this can be a problem if the image has any ICC profile that is not sRGB.

If you have a calibrated/profiled monitor, since Blender does not support ICC profiles color would also be sent to the monitor as sRGB instead of the monitor's profile so it would differ from software displaying images correctly taking monitors profile into account.

If your color management settings are set to filmic or have any looks, the image will be changed according to that.


How can i edit value in Measure tool 2.8

Press N to bring up a side panel. With a target edge/vertex selected, go to Item and adjust the position of it using the fields shown below. Press and hold LMB to use slider, single press to enter a value. Note that you can enter math expressions, so entries such as -1 + 52 / 2  or  10m - 5cm are completely valid.

Edit:

The amount you want to change the length by will be the amount you will need to change the location in the corresponding axes. In this case, I've extended the length of the rectangle below by 2.75 ft by moving the Y-axis position of the edge by 2.75 ft

Depending on the orientation of your object, you may need to add or subtract to the value for the X, Y or Z axis.


The mesh uses a modifier to deform based on the position of the armature. By default the deformation from the armature is not visible while in edit mode but can be turned on if you want to. The button highlighted in red will show a 'shadowy' version of where the mesh would be based on the armature. The blue highlighted button is only visible if the first one is enabled and when enable the mesh will be shown fully deformed while in edit mode.

As for Unity - check that you are exporting the action and that Unity is using the action and not just the default pose position.


Due to the lack of information provided I cannot be entirely sure what the problem is. My guess is that you do not have enough resolution in the cylinder for it to deform.

Select the cylinder and go into edit mode

Add some edgeloop along the height of the cylinder, Ctrl R -> mouse wheel up to increase the number of loops

Go into object mode and select the cylinder and the armature, in that order.

Parent the mesh to the armature, Ctrl P -> With Automatic Weights

Now you can go into pose mode and pose the bones as you desire.


The second Particles System not working Properly

There should be 2 particle systems on the object (there's only one in your file). The second particle system modifier should be in the bottom of the stack.

You will setup it as desired, the main option to change would be start and end frame.
Starting frame should be roughly the same as the end frame of the first system. Values from the lesson didn't work well so I changed them - while particles of first system die at frame 26, particles of the second one burn at 23.

However to make second particle system emit particles from the faces exploded by the Explode modifier you should enable Use Modifier Stack option:

The reason this wasn't mentioned in tutorial is because Use Modifier Stack option was added starting from version 2.68.


Trying to find a way to make a true pixel screen

I still think UV map could be quite handy:

Scale the UV maps into individual pixels by scaling them to 0
Connect the UV map to Image texture
Use Mapping node to animate it


Solved the problem with a work-around nodes solution instead of the straight glass BDSF. Maybe not straight physically, but looks better in this case.

Thanks to all for your advices.


Change relative offset to 1.35.
Result:

Explanation:
What shall Blender do? It is mathematics. You give a circle (curve) with a radius. You give the width of one part. You give the offset.
If it doesn't fit - it doesn't fit. Blender can just overlap or leave a bigger gap. Blender cannot change mathematics. ;)


Using cycles generated textures in the displace modifier

The only workaround seems to me is that you have bake the textures out to the uvs and then plug them into the displacement.


Why does rotating an object on its axes in a different order result in a different final rotation?

If you go to the top middle of your screen you will see its literally called local. Change that to global and you should be rotating on the global x and y axis and z axis.
In the second gif the objects origin is at the corner of it (were the 3d cursor is) Fix this by selecting the object and right clicking then setting the origin to the geometry and it should be fixed.


If I Put In OpenEXR Frames For HDR Would I Be Able To Use Blender To Export The Video As HDR

Your EXRs are scene referred, and while Blender cannot encode to HDR10 or Dolby Vision, those EXRs are perfectly acceptable to encode to HDR via Resolve or like software.


model a shape something like a raspberry

Take a look at Dupliverts, that allows the duplication of a base object at the location of the vertices of a mesh. In other words, when using DupliVerts on a mesh, an instance of the base object is placed on every vertex of the mesh.

Or try the Tissue add-on by Alessandro Zomparelli

It allows you to copy a selected object (Component) on the faces of the active object (Generator), adapting its bounding box to the shape of quad-faces.

Thread on Blenderartists.org with more examples here


You could go to Blender Guru for some tutorials; Also there's CG Cookie.


Blender 2.78a crashes when setting up IK system

Blender shouldn't crash if you do something like this, so this is possibly a bug. Please try a recent daily build from the buildbot to see if it has already been fixed. If not, please report it at our bug tracker.


" ***stack smashing detected***:  terminated" on choosing an object

Well, I've learned much. I wanted to report a bug, and on the website, one of the suggestions was to download the newest version before reporting a bug, so I downloaded 2.79.7. When I opened my project and selected an object, Blender still crashed, but it rewarded me with new information...as I remember, the information said something about sRBG display not supported, defaulting to "NONE.", and I needed to check my User Preferences file. I looked through the User Preferences thoroughly several times, but found nothing relating to sRBG or any choices regarding that. So I downloaded 2.78c, which still supported sRBG, evidently, because when I selected an object, it didn't crash.
Joel Gomes da Silva was correct with his answer about using older versions, but curiosity and stubbornness prevailed, and I learned a lot. Thank you Joel!


I am rendering with multiple RTX2080ti GPU's in a windows 7 pro system and I am getting very good and stable results.
What I did was the following;

Download the latest experimental 2.79 version that supports RTX.
Replace the complete content of the C:\program files\blender foundation\blender
folder with the experimental 2.79 version. This will force windows to treat the
experimental version to run as an installed application, much better results!
Do not use the latest Geforce driver but find and install version 417.35

Good luck!


OptiX™ won't work on simple plain picture.

From the original research: Interactive Reconstruction of Monte Carlo Image Sequences using a Recurrent Denoising Autoencoder [SIGGRAPH 2017]

  We therefore frame the problem as a reconstruction of the final image (rather than denoising) from these sparse samples - (page 98:2)

  End-to-end training allows our network to automatically learn how to best utilize auxiliary pixel features, such as depth and normals, with no guidance from the user.

It is base on training data from IRay render engine, with all the useful feature like Depth, Normal.

If you provide a single image without these information, it will not work since OptiX treats them as a plane rather than a scene. OptiX didn't learn how to denoise a plane with noise (or bad at it).

There are a lot of denoiser to remove noise from single image, but OptiX is not the one aim to do this job.


How do I add a background image as a camera lens?

You can do this by adding a Background Image. To do this, go into the 3D Viewport and press the N key to open the panel on the right hand side. Scroll down to the very bottom, and you should see an option Background Images. Go ahead and enable it.

Now add an image and change the view from All Views to Camera.

Now in the camera view you will have a background image that transforms with the camera.


Do you have active modifiers on the object? Some modifiers will recalculate on every mesh change that occurs during dynamic sculpting.


Manipulating the UV coordinates of a face is usually done via the bmesh API.  Here is an example extracted from http://web.purplefrog.com/~thoth/blender/python-cookbook/barber-pole.html

def spiralUVs(mesh, xPlus):
    # add a UV layer called "spiral" and make it slanted.
    mesh.uv_textures.new("spiral")
    bm = bmesh.new()
    bm.from_mesh(mesh)

    bm.faces.ensure_lookup_table()

    uv_layer = bm.loops.layers.uv[0]

    nFaces = len(bm.faces)
    for fi in range(nFaces):
        x0 = fi*2/nFaces
        x1 = (fi+1)*2/nFaces
        # assume a quad; 0..3
        bm.faces[fi].loops[0][uv_layer].uv = (x0, 0)
        bm.faces[fi].loops[1][uv_layer].uv = (x1, 0)
        bm.faces[fi].loops[2][uv_layer].uv = (xPlus+x1, 1)
        bm.faces[fi].loops[3][uv_layer].uv = (xPlus+x0, 1)
    bm.to_mesh(mesh)

Other examples that manipulate UV maps include http://web.purplefrog.com/~thoth/blender/python-cookbook/expand-uv-to-fit.html and http://web.purplefrog.com/~thoth/blender/python-cookbook/uv-from-geometry-cubic.html


Why is this object facing the wrong way when exporting to three.js?

Nothing's necessarily wrong, your object just isn't going to be in the same position in ThreeJS as in Blender because the default orientation of the axes is different.

Now, the export system takes care of this. I suspect that your object rotated to make up the difference perfectly, and that the problem is in fact your camera! The same values will cause a different rotation in ThreeJS than in Blender.

You could go to the trouble of manually adjusting to your camera to compensate, but fortunately that isn't necessary. Blender and ThreeJS both have built-in "lookat" functions (here and here, respectively), so you can just export another object to orient them to accordingly (though Blender looks at the entire object while ThreeJS focuses on a single vertex, so make sure the object you use is a small one if you want precision!).


Apply "Scale" in Object Mode first.

Try one seam from top to bottom. Probably in the back so it's not visible. And a second seam around the bottom outside edge and another around the top outside edge.

You can then export the UV Layout and bring it into an image editing program like Photoshop or Gimp and arrange your labels etc. Then save that (Less the UV map) and bring that into Blender as your texture.

If your UV map comes out like this (Vertical) you can rotate the UV Map 90' just like in the Editor. "R" + 90


2.8 setting up different viewport shading options for different viewport windows?

Thanks guys, so looks like what I'm after is...

1) Setup 4 viewports (don't use Quad View),

2) Make all of them Ortho viewports except the top right viewport (ie make it Perspective)

3) Then in the perspective viewport  select the blueprint Empty object and in Object Data turn off Display Perspective

Giving me wireframes against the blueprints, but a solid view of the tank in a perspective view without the distraction of the blueprints, ie...

Thanks again.


How to compare small changes made in the graph editor?

I'd just make a copy of the object/armature and parent it to an empty and move the empty aside:


This is actually a known issue with From Instancer option (see here for more on that). Good news is that it's just a viewport bug, it renders just fine.

Quick tip as well since you'll have to render the image to see any updates: If you use emission shaders only you can render noise free with 1 sample in Cycles and it's super quick. Won't help with diffuse/glossy/glass etc., but for just previewing colors it may help.


How do I disable the coloured lighting in the viewport in 2.8?

The warm light comes from the studio light. You can either change to a different HDRI texture by clicking on the light probe image or enable Scene World to use the current configuration of the world background for Look Dev instead.


What type of transform are you using, moving, roatating scaling?
How are you "dragging", from the transform manipulators?

If so either use hotkeys instead, G for moving, Rfor rotating, and S for scaling. That will allow you to input an axis constraint with X,Y or Z and then iput a distance, factor, or angle afterwards.

Just type the value and look in the bottom left of the 3D View header. + and - will toggle positive or negative values. You can even input simple math expressions by entering formula mode by first typing an asterisk (*), then typing down any math operations desired.

If you still want to use the transform manipulators then the only way to introduce precise values is either from the operator properties on the bottom left of the Toolshelf (T key) or from the operator popup by pressing F6 after transforming.


as your bone is not completely aligned with the global X axis, rotating it on the global X axis makes it rotate on its local Z. If you align it completely with the global X axis in Edit mode, it won't happen any more. Once aligned:

Not sure why you need to rotate it on the global X axis though, just keyframe rotations on its local Y axis.


The basic problem you have is the topology. Avoid faces that have more than 4 vertices. Those will not work for what you want to do.
All of those examples don't work because of those n-gons.
Start with a shape like this:

You can create all kinds of "unusual shapes", but you have to have the topology in mind when creating them.
Then you will be able to appreciate the difference between all of the proposed ways to mix smooth and hard edges.


How to close a section of a sphere flat while retaining closest shape?

This can be accomplished pretty easily with the knife tool.

I first positioned the object how I wanted it, and then pressed k, clicked on one point outside the mesh, then moved the mouse to the opposed side, and clicked to create a cut like the one above. Then all you need to do is delete all the vertices of the sphere to the right of the cut, and the knife tool will have created a smooth edge for your sphere segment.

One possible issue is that the knife tool only does the half of the sphere facing you. In that case, delete the half of the sphere you can't see, and use a mirror modifier to duplicate the side with the knife cut so it makes a full sphere again.

Final result:


Simply use the Array modifier instead.

Add an empty and flip it in X and Y axis
Add Array modifier > Object Offset and target the empty
Done

You can flip the empty either by scaling to -1 or through Object > Mirror


How to find find all possible arguments to classes in bpy.types.*?

To answer your question directly.

An existing instance is always passed into classes from bpy.types, however this is not common usage when creating new classes in the Blender Python API.

Blender/Python types aren't instantiated by calling the classes.

To create a new object for eg:

obj = bpy.data.objects.new("name", None)

not:

obj = bpy.types.Object()

There is one use-case for calling a class, and that is to create a new instance of existing data (however this is quite esoteric and not normally useful in practice).

This example creates an instance of a subclass of bpy.types.Object.

>>> class MyObjectSubclass(bpy.types.Object):
...     def my_helper_function():
...         print(42)
...
>>> obj_a = bpy.data.objects.new("name", None)
>>> obj_b = MyObjectSubclass(obj_a)
>>> obj_a is obj_b
False
>>> obj_a == obj_b
True
>>> obj_b.my_helper_function()
42


Go to the top right and make sure this little guy is enabled other wise EEVEE just uses the Material Preview Settings, with preloaded HDRIs.


It seems you used the BlenderKit Asset Library addon to get models in your scene. It seems to work with Instancing of collections. I think for the Import Method of the asset library you chose Link. (personally I would have used Append)
If i open your file there is only geometry data for 3 objects (the ground, the background and the mountains). The other geometry is not in your file but somewhere else, and it is linked to your file.
Possibly the file paths of the missing objects are not correct (maybe the files where moved), and your blender file can't find the needed files/objects/geometry.
One way to solve this is to Append your objects in the future. This way they become part of you blender file, and are not dependent on correct links/file paths.
(Be aware though, the problem might be something different all together, but since i don't have the files that are linked to your blender file, it is hard for me to tell.)


Spin tool is not shown in toolbar when trying to spin a curve

The spin tool does not work with curves, it's specifically made for meshes. There aren't really any alternatives other than rotating around the 3D cursor.

To rotate around the 3D cursor:

Press . to set the pivot point to the 3d cursor.
Position the cursor at the center of the turn.
Extrude e and rotate the curve.

Tweak the handles so it's curved:

If you don't care if the object is a curve you could convert it to a mesh (Altc) and work with it from there.


Blender is not a preset it is only what Blender has become.
If you make a custom keyconfig and call it "Swap MMB" and change keyconfig that is what Blender and Blender 2 7 X and others are now.
In order to change everything back to default you have to make a new entry and call it something else. EG "Default" change all of keyconfig back to the original configuration, now all Blender and Blender 2 7 X and others are also.


Normalize mix shader fac to .75 as midpoint instead of .5

ColorRamp (or RGBCurve) as Value Remapping Tool

While the transformation could be certainly achieved with several math nodes, I would suggest to take advantage of the ColorRamp node:

  The ColorRamp Node is used for mapping values to colors [and so to other values] with the use of a gradient.

The transformation you want to achieve is linear, with a different slope depending on which side of the range you fall into, but in any case is linear. We'll set up a Linear gradient for the node, then add a slider in corrispondece to the input value midpoint

Pos = 0,5 in this case

and then set the value you would like to be mapped to

V = 0,75

This means that we are asking Blender to make a linear remap of the incoming value from black to white (0-1) with a midpoint (0,5) with a value of 0,75.

Note how this kind of set up should be done without Color Management models transforming your scene data. After that, you should be allowed to set it up like you want and everything should works fine. It's just an easy way to avoid being confused while seetting up the remapper.

Same thing can be done, and perhaps is visually more clear, with the RGBCurve node:

Values before the 0,5 point are change "faster" than the values that comes after. The midpoint has a new value of 0.75. You can change the handle type to Vector in the menu that appears once the wrench icon is clicked.

Here's a try with the values proposed at the end of the question: