Shrinkwrap only calculates based on the current frame so you just need to make your collider very very tall to avoid popping out. You can always use  a custom hidden collider object that is parented to the actual object that you want to show.
In order to make the whole pins move, I would put the shrinkwrap modifier on a simple grid, and use vertex instancing to add the pins.
Basically:

Create a grid with one vertex per pin, placed in the center of where the pin should be
Create a single pin model
Instance the pin model on the grid's vertices, and make sure it aligns correctly. Don't use the align on normals option, because shrinkwrapping may change normals, causing twisting etc.
test colliding with the grid using shrinkwrap


These are the shapes used for the custom bone shapes in the rig once the rig is generated. If you are in pose mode on a rig, you can go to the details of the bone in the property editor and see that you can reference a mesh object or empty as the new shape for the selected bone.


When I look through the camera a silver wall appears

There's nothing wrong here. That "silver wall" is just the properly lit part of the scene that the camera sees. If you go to Camera view, like you have, you get to see more of the scene than is in the camera's field of vision, and thus more than will be rendered, and the area inside the rectangle is what will be rendered from that camera in that position.


How do I enable motion blur for Mantaflow fluids?

When you bake the mesh for your liquid on the domain, make sure "use speed vectors" is checked in the mesh tab.  If it wasn't then you will have to bake the mesh again.  After that, it will automatically render motion blur if you are using Cycles.


How to show an object in viewport as it is in another keyframe, without going to that other keyframe?

Blender Does not support anything as direct as Onion-skinning like in 2D Animation (without addons at least)
Blender DOES on the other hand, support Motion paths, Which will show you essentially the same information in a more basic way. To Use it, select the object, and find motion paths in the object info tab

Click Calculate, And it should give you a result like this:

Hopefully this helps!


Weird texture issues when importing Collada from SketchUp

Thanks for the comments! Yes, it was just normal Z-fighting (no pun intended).

Once I removed duplicate vertices, I could apply the textures and everything worked fine.


Multires baking requires a multires object

I had the same problem. For me, the "apply base" button in the multires modifier fixed this.


Sculpt mode not showing the vertices/faces of a mesh?

In the Properties area in the Object tab under the Display panel check Draw all edges


The tech specs for your macbook state:

NVIDIA GeForce 320M graphics processor with 256MB of DDR3 SDRAM shared with main memory

So this doesn't meet the minimum memory requirements.  Look slike you need to stick to 2.79 or start saving for a new machine.

Just for completeness, and if you're curious, here are the instructions to check your OpenGL version.  Run the following command from the terminal:

glxinfo | grep "OpenGL version"

If you don't have glxinfo command you can install with

sudo apt-get install mesa-utils

Make sure that the version is at least OpenGL 3.3.  Even then, the memory constraint is likely to be the problem.  You can always try running blender with the following command:

./blender --debug

It might offer more information


Here is a screen capture that can help to localize the icons:

I think you should try to reinstall and report a bug if this does not fix the issue.


Fortunately I stumbled upon the material setting
For some reason, if you set your blend mode to "Alpha blend" - Eevee does not render the objects with this material at all. It sort of treats them as transparent for the Depth pass.


How to fix these weird shadowy sun rays on the spoon?

Heres now I usually go about solving this issue:

I start with a UV sphere with subsurf, and it has some wrinkles:

Heres what the geometry looks like:

Now, i add in a smaller loop cut close to the center of the circle, making sure to position it to maintain the curvature of the sphere:

Now, my wrinkles are gone, or at least imperceptible from this distance:

I hope this helps!


How to snap Origin to selection instead of closest element?

To snap the Origin Point (orange dot) choose to snap with Median
It's in the Snapping Menu, second from right.


Preview and rendered video from VSE suddenly shows nothing

Select your tracks and press AltH to disable the hide function.


How can I access pre-existing UV maps in an fbx?

All existing UV maps can be accessed by simply selecting them in the Properties Editor, Data tab in the UV map list. They will be previewed in the viewport when selected, and you need to select the active one for rendering by clicking the camera icon:

When you need to use a few UV maps in a shader, you can specify the vector input for any texture to be the correct UV map with the node not so surprisingly called 'UV Map':


Cloth Simulation
Simple Cloth simulation seems to work quite well with Wind effector.
.
Just play anim and move (G) the Empty arround.
It can be used as a proxy mesh for more detailed model with Surface Deform Modifier.

Spring Bone add-on
just a quick test ... it has gravity parametr, but they can't be influence by effectors like wind.
Download add-on from Github

Add-on in included in blend file too.


You can manipulate the Emission strength of the lamp based on the Ray Length from the Light Path node - this is precisely what the Light Falloff node does (you provide an emission Strength and it determines what the actual emission should be to achieve that result).

You can derive the different Light Falloff values from each other by either multiplying or dividing by the ray length to move up or down the scale. ie,

Quadratic * RayLength = Linear
Linear * RayLength = Constant
Constant / RayLength / RayLength = Quadratic

This allows you to get some interesting effects - for example, you could get Cubic falloff by simply dividing Quadratic by the RayLength.

To get a 'stepped' effect (where the falloff suddenly changes at regular intervals) you can use the Modulo maths function to give a stepped effect to the Ray Length as follows :

Adjusting the Modulo node will affect the size of the banding.

This can produce the following result :

Here's another useful setup for adjusting the falloff using a Color Ramp - this time using Constant falloff so the 'maximum' illumination is not affected by distance (ie, purely based on the color ramp).

The Subtract and Divide maths nodes control the offset and scaling of where the color ramp is applied to the illumination and the color ramp controls the profile. For 'stepped' banding simply use Constant interpolation in the Color Ramp and configure the ramp with the required bands.


I bought a model on fiverr in .obj but it was sent as .txt

OBJ is basically a text file. It should be fine if you renamed the file and changed the extention from .txt to .obj.


Is there a way to fix mark seams "border" which are showing in render?

When you use normal map in a shader you have to change the color space to "Non-Color". If you change the texture file you have to do it again.


Including 3rd party modules in a Blender addon

DingTo created the Windows builds of numpy. You can find some info in this task's discussion, especially Juicyfruit's wiki page should be of interest.

The compiled numpy libs were added to the library repository and are placed in the site-packages folder when you build blender.

You will have to

provide a complete, customized blender buildor
ask your users to manually place the required lib in blender's site-packages folderor
add the lib to your addon's folder and import it from there (sys.path.append should do the trick)


Rigid body objects converted to mesh from a particle system don't get simulated

If I understand correctly, you have originally assigned Rigid Body properties to your "reference" cube (the one that got duplicated by the particle system).

Even though this effectively assigns the Rigid Body properties to the child objects, it doesn't automatically add them to the RigidBodyWorld group, that is the group that the physics engine takes into consideration when baking dynamics (unless otherwise specified in the rigid body settings).

You can see that they are not part of a group by observing that their wireframe is not colored green.

There is a quick fix to this: select all your boxes and hit "Add active" in the "Physics" panel of the toolbox to the left of the 3D window.


Lasso select not working, but box select is?

Use the Tweak tool
Disclaimer: I'm a right click selecter. I don't know if there is any difference if you joined the left clikers army.
Since 2.80 version, lasso and box select shortcuts by default only works when the Tweak tool is active (see the keymap first column below).

Box and lasso select tool I think are made for early adopters to make sure to have simple select tools like the would find to expect in other software packages (photoshop...)
Back in the days (<2.79) we didn't had "selection tools" and we just used shortcuts. Tweak tool mimic that situation. I made that my default tool.


I'm not sure I follow your second (sub)question, but as far as the first question is concerned:
Node setup

The important node I think is the Map Range node, which will take the Z-component of the geometry as input (set your desired clamp ranges here) and maps them to [0, 1], which the ColorRamp node requires.
Result

In this animation, I am changing From Max in the Map Range node. As you can see, all values above From Max get clipped to the upper limit of the ColorRamp.
Hope this helps.


I've written a Blender/Bullet simulation of a Newton's Cradle that doesn't conserve energy.  Here's two animations that illustrate the problem:

It's all done with rigid bodies, and the wooden top piece doesn't participate in the physics.  The initial angle of the first ball is an adjustable parameter - 90 degrees in the first animation, 60 degrees in the second.  You can reproduce everything by running this script in Bullet 2.69.  Make sure the Tool Shelf is open to get to the simulation controls.

I suspect that it's all the same problem.


The add-on is just a wrapper for the rhino3dm package, which is currently missing on your system.

The following steps should allow you to install the missing Python package:

Open Blender and switch to the Scripting workspace.
In the Text Editor press the + New button.
Copy and paste the following script into the editor.

import bpy
import subprocess

try:
    output = subprocess.check_output([bpy.app.binary_path_python, '-m', 'pip', 'install', 'rhino3dm'])
    print(output)
except subprocess.CalledProcessError as e:
    print(e.output)

For Blender <2.83: Run the script by clicking on the Run Script button. For Blender >=2.83: Press the button with the play icon (triangle).
Enable the add-on in the preferences.


How to create basic lighting for presentation images

HDRI is the best option if you just want to present objects. you can also use Lookdev mode in Blender 2.8 for fast previewing.


Creating trails using Animation Nodes by delaying the frame of the following polygons

You can use F-Curves. F-Curves are functions that describe the value of attributes in Blender. So by evaluating the F-Curves of transformation channels at a certain frame, we can get the transformation of the object at that frame.

First, we create a group that computes the transformation of an object as a matrix and returns it. We will assume that only transformation channels are animated and that they are in order for simplicity.

We then create a loop that iterates over a float list that represents the frames we want to evaluate at.

Then we will replicate a line of matrices based on the output matrices of the loop, where the input frames are arithmetic sequence starting from the current frame. We use the indices data from a Grid Mesh to create the polygons between the replicated matrices.

In this node tree, the step size of the sequence controls the length and direction of the trail:

Blend file for AN 2.1:


First unwrap the cube (I used Follow Active Quads).
Add the default Color grid image texture as the image.
Add a new UV map (I called it decal). In order to do that open Properties Editor > Data tab > UV maps rollout and press "+" button. Select the face you want the decal on and press U >Unwrap.
Add another image texture in the second texture slot, set the UV map to decal and the set the Extension to Clip.

Both image textures are on the same material. The material is not specific to any face, it is on the entire model. The UV maps control where the textures go.

Here is the result, default Color grid as the texture and the blender logo as the decal.


The same thing happened to me.

I tried different ways to render an animation and finally found a way to solve this problem in Blender 2.8. Go to View > Viewport Render Animation.

In this way you can solve it.


Is there a way to delete bones that don't have any weight assigned to them?

This is a little round-about, but if your zero-weight bones have their deform-attribute toggled off, there is a plugin to convert IK-Chains to FK-Chains whose side-effect is tossing out all the non-deforming bones from the armature.

Take a look at it here:
https://github.com/chinedufn/blender-iks-to-fks


Yellow/orange outline just means that the object(s) are selected. So, do you mean you just want to DESELECT the object(s)? If yes, then you can go to menu Select > (De)select All or shortcut A (toggle Select/Deselect All).

BTW, why do you learn version 2.79? The keymap is using RIGHT click for selecting object, and doesn't go away with left click on empty space. This will confuse you if you are not familiar with it. And the problem that you asked this is you skipped the basic of Navigation in Blender. So I recommend you to use version 2.8x with the LEFT click for selection, and it's more intuitive for new users coming from other programs.

This is manual for selection in 2.8x : Selecting Manual


Adding a color effect strip to the video sequencer using Python without the operator?

@batFINGER to the rescue! The answer to my question can be found here: https://blender.stackexchange.com/a/142392/111345 for anyone else that needs it.


In general, the format should not matter as each is supposed to bring the same data into Blender, as long as the format is supported. The unwrapping though does not depend on the format.

Not that format does not matter, but it really has no influence on the unwrapping, as that is based on the geometry that is generated from the data read in/generated inside Blender.
While i usually use fbx or obj, i believe the format can be chosen based on ease of handling with all eventually involved software and their support of it.

Update based on the video in the comment:

The situation of not being able to select loops will come up if the geometry does not offer Blender a continuous edge flow, thus only the edge or only the edges to a certain part will be selected. Most likely caused by either N-gons or Triangle-faces. In that case one would have to manually select with shortest path selection Ctrl+LMB or change the geometry to a more quad-based version with a clear flow of the edges.

I'd suggest to un-triangulate manually if the object is not too complex and thus allow an easier workflow from there.

In regards of the format, i had both fbx and obj files i imported with quads, so in your case, try to export the objects without triangulating them.


Your viewport overlay is turned off.
Upper right corner, the icon with two circles is grey :).


how to snap several vertices to the same z.position

You can select the vertices and then hit S+Z+0+Enter. Then they'll have the same Z-Position.

S is the shortcut key for "Scale". Z is the the axis to scale on and 0 is the amount to scale by.

Or, if you wanted to align the vertices to a specific vertex, you can:

Select the vertex you want to align to
Hit Shift+S and select Cursor to Selected.
Change the pivot point to 3D Cursor
Select the other vertices and hit S+Z+0+Enter.

Or alternatively (without the need to change the pivot point to 3D Cursor), you can

Select "Snap Element" on the 3D Header and select "Vertex"
Then select all the vertices except the one you want to align to
Hit G to grab
Then hit Z to constraint the translation to the Z axis
Hold Ctrl and hover the cursor over the vertex you want to align to until there's a circle over the vertex (don't hold Ctrl if the "Snap during transform" option is on)
Then click (or hit Enter)


UNLINK does not work to convert particles into new/original meshes

I found the answer on this page: Can not find unlink object data in Blender 2.8

In Short: Go to Object Menu --> Relations --> Make Single User.

'Unlink' doesn't seem to work anymore in Blender 2.8. Things disappear when I unlink.


Find center of geometry of a set of objects

I think selecting the object and pressing Shift+Ctrl+Alt+C would do the trick.
Similar question - How to recenter an object's origin?


UV Sculpt tools not working at all in 2.82.7?

Ok, it got solved through recreating all UVs from scratch again. I still have no idea what happened (probably a bug of sorts), but now it works. Sad that it made me lose a couple hours of work, though.


Override a material on a Linked object (2.92)?

There are several ways to do this.
Using Object color.
This is quite limited way but it's easy.
You can use object color in node editor and the tricky thing is then you make an instance of the object it will use an object color of the instancer, replacing the original object colors.
So here is the workflow. You use an object color in the node tree:

Next, then you instance the object, use object color to set color for all objects inside the instance:

For this method, no proxy or overrides required, but you are limited to one RGB+Alpha color per instance.
Using Drivers
One of the solutions is using drivers. Let say, I have a character, and I'm going to drive the color of his clothes:

So I created a bone, that will drive this color. Then I pressed RMB on Y Location of this bone and select copy as new driver:

Next, I pasted this driver in Fac field:

Now, then I move this bone color makes blue.

That's all. Then you will use your character via proxy or library override, you will always make a local copy of pose, and changes in this pose will drive color in material.


The problem with combining Euler rotations from different axes is that the order of rotations is significant. For example, rotating along the y-axis then the x-axis is not equivalent to rotating along the x-axis then the y-axis.

One way monkey looks to the right the other it points down

Since the final rotation is dependent upon the order of individual rotations, we are unable to absolutely determine the rotation from the x and y coordinates. However, if we assume that rotation only occurs perpendicular to displacement, we can approximate the appearance of an object rolling by rotating it when the location changes.

For this approach, we store the object's previous position in order to calculate the difference in location. We create a rotation matrix with the magnitude for the angle and the normal as its axis. Then, we combine the rotation matrix and extract its Euler rotation. The script makes a modal operator which rolls the active object when it is called.

import bpy
from mathutils import Matrix, Vector

class RollOperator(bpy.types.Operator):
    bl_idname = "transform.roll"
    bl_label = "Roll active object"

    def execute(self, context):
        dx = self.dx / 100
        dy = self.dy / 100

        matrix = Matrix.Rotation((dx**2 + dy**2)**.5, 4, Vector((-dy, dx, 0)))
        matrix *= context.object.matrix_world
        context.object.rotation_euler = matrix.to_euler('XYZ')
        context.object.location.x += dx
        context.object.location.y += dy
        return {'FINISHED'}

    def modal(self, context, event):
        if event.type == 'MOUSEMOVE':  # Apply
            self.dx = event.mouse_x - event.mouse_prev_x
            self.dy = event.mouse_y - event.mouse_prev_y
            self.execute(context)
        elif event.type == 'LEFTMOUSE':  # Confirm
            return {'FINISHED'}
        elif event.type in ('RIGHTMOUSE', 'ESC'):  # Cancel
            context.object.location = self.location
            context.object.rotation_euler = self.rotation_euler
            return {'CANCELLED'}
        return {'RUNNING_MODAL'}

    def invoke(self, context, event):
        rotation = context.object.rotation_euler
        location = context.object.location
        self.location = location[0], location[1], location[2]
        self.rotation_euler = rotation[0], rotation[1], rotation[2]
        self.dx = 0
        self.dy = 0
        self.execute(context)
        context.window_manager.modal_handler_add(self)
        return {'RUNNING_MODAL'}

bpy.utils.register_class(RollOperator)

After running the script, add a shortcut key to start it. This one used ShiftQ in the 3D View.

With the operator, the monkey rolls as it moves.


Freestyle rendering in EEVEE show's up on top of other greace pencil objects, how do i fix it?

I can imagine why this is happening: Grease Pencil is not considered by Freestyle at all. Thankfully, you can change freestyle to be “as render pass,” put the grease pencil objects on a separate view layer, and composite the Grease Pencil over the freestyle over the main view layer.


Lets say you have a reference object (Red) and a deformed object (Blue), while both have the same mesh structure, the vertices indices are different, we want to align the vertices indices so that we can create proper shape keys and smooth morphs.

The solution rely on computing a look up table for vertices based on their closest vertex in the reference object using a KD Tree. In order for this to work, an instance with the same indices structure of the deformed object has to roughly align with the reference object, if the deformation is too extreme, you will have to try to align the deformed object manually someway. This can be done by snapping the vertices manually, roughly aligning them using sculpting or proportional editing, for instance, I am going to duplicate the deformed object and try to align it using proportional editing:

It doesn't have to be precise, it just have to good enough for the algorithm to work.

Then we are going to send that to Animation Nodes where we sample both the vertices locations of the reference object and the duplicated object we just edited. Then I am going to create a KD Tree from the reference object's vertices locations and use the Find Nearest Point Node to find the indices of the nearest vertices in the reference object. If we view the indices of the vertices of both objects and cross reference them with the output indices in the node tree, we will find that they indeed match:

Notice that the output list tells us that the vertex at index zero should be at index 32, the vertex at index 1 should be at index 15, the vertex and index 2 should be at index 22, and so on. If we now get the vertices from the deformed mesh at the output indices, we will get the vertices in the same order as the reference object but in the locations of the deformed object:

The edges and polygon indices of the new mesh are that of the reference mesh. All you have to do now is output the mesh and use it to create your shapekeys.


How do I add a texture to a model in 2.82?

The texture button is here (not available in edit mode):

To add a new texture, click here:

I strongly suggest to have a look at tutorials on youtube like this one:

https://www.youtube.com/watch?v=j-ncKGhDih8


How does blender convert a color's value to a numeric value?

A math value of 0.5 is like assigning RGB values of 0.5 each, which is a HSV value of 0.735.
I don't know the logic underneath this choice, I think it's about linear and logarithmic perception of light.


i connected the two vertex but now i can't seem to select the other face on the top half?

You must have connected the 2 vertices with F (fill), which won't separate the face in 2 separate faces, but just create an edge between the 2 vertices over the existing face. If you want to connect the 2 vertices in order to cut face in 2 parts, choose J (join).


How to properly render a curve/thin object in Cycles?

Two setting for the curve you need to change, to change the curve's resolution.

First to add more loops along the length of the curve change the Resolution of the curve.
The Preview setting controls the amount of loops displayed in the 3D view. The Render setting controls how many get rendered, if it is set to 0, then the Preview number is used.

To add more points around the circumference of the curve change the Resolution of the Bevel.


You could use some vector math to select the right facing verts (deselect all verts and run this in object mode in the text editor, or paste in the console)

from bpy import context as C
from mathutils import Vector

for v in (v for v in C.object.data.vertices if v.normal.dot(Vector((1,0,0))) > 0):
    v.select = True

alternately, to select the left side, change the Vector to (-1,0,0). Top, (0,0,1) etc.


My bad, tangents successfully appears in shader when I switched viewport shading to "Material".

Testing code:

import bge

cont = bge.logic.getCurrentController()

VertexShader = """
    attribute vec4 tangent;
    varying vec4 frag_tangent;
    void main()
    {
        frag_tangent = tangent;
        gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
    }
"""

FragmentShader = """
    varying vec4 frag_tangent;
    void main()
    {
        gl_FragColor = frag_tangent;
    }
"""

mesh = cont.owner.meshes[0]
for mat in mesh.materials:
    shader = mat.getShader()
    if shader != None:
        if not shader.isValid():
            shader.setSource(VertexShader, FragmentShader, 1)
shader.setAttrib(bge.logic.SHD_TANGENT)

It works great when viewport is in right shading mode.

Thanks :)


Yes, you can use the displacement map of those textures as a brush.
I make and use textures for brushes in this video: https://www.youtube.com/watch?v=OxEmHaVlc4o


Combine png image with a background color for a shader

There are multiple options, but the easiest would be :

Put a hue/saturation/value node between your image texture and the principled BSDF, then tweak the hue to get the desired color.
Note : The downside is that you have to "guess" which hue you will get by tweaking the hue factor value.
Since your texture is black and white, you can use that as a mask to get the desired color. Insert a mix rgb node between the image texture and the bsdf, then tweak the Color2 input to get your color like so :

Note : You can disconnect the Color1 input from the mix RGB node and set any color you wish for the numbers.
You can also use a mix shader and use the color for the factor, that way you can have a different roughness value for the numbers and the rest of the clock for example. I have used diffuse shaders for the sake of simplicity but you can use Principled bsdfs :

Edit :
Since your image may not be exactly black and white, it could mess up the masking factor. I'd recommend inserting a color ramp, setting it to "constant" and moving the white slider to 0.5 like so :


Creating a path with differential equations

When I have understood you correctly, you have already the solution of your diff eq, and you know x0, y0, z0 as parameters of this solution, defining the start location. When you run under Python a loop by incrementing t in discrete steps, you will be able to create a 3d chain of vertices with these coordinates and use this polygon as path for animation (convert to a curve, if needed). Since I am a newbie myself, I cannot provide any code, however.

Greetings from Germany, Tschöbbel


There is an add-on bundled with Blender called Loop Tools which has an option for this.

Enable it in CtrlAltU > Preferences > Addons:

The operator you want is accessible through W > Loop Tools > Space:

In Edge Select Mode (CtrlTab > Edge), select the edges which you want to equalize:

Before/After:


Is there a way for me to "edge slide" the heads along each bone shaft?

Yes.  Each bone's head and tail lie in a particular axis for that bone-- the Y axis.  So if you select a head and move it in that axis, you'll be edge sliding the head along the bone.
Switch to normal orientation, individual origins pivot.  (In edit mode, normal orientation will use each bone's local axes for the transform, while local orientation will use the armature's local axes.)  Select as many heads or tails as you want.  Translate constrained to Y axis (g Y move mouse confirm for me).


How to track an object to a specific property in the Blender Game Engine

Simple change. The syntax for the "Steering" actuator calls for a target field, not a track _object field. So your new snippet looks like this:

def target_prop(cont):
self = cont.owner
objects = self.scene.objects

test = [o for o in objects if self["Cube"] in o]
test.sort(key=lambda o: self.getDistanceTo(o))

target, *_ = test

act_track, *_ = cont.actuators
act_track.target = target

for act in cont.actuators:
     cont.activate(act)

you can see the only change is line #11


Clear selection with a
All click can be done in the outliner window
In the outliner window show groups.
Click on first group
Shift click on the second group.


How to follow a path by curve points rather than length?

Manual solution

You could achieve this manually.  Start by giving the object a Follow Path constraint and setting the target to be your curve.

In this example, we have 3 control points (of a Bezier curve) and 20 frames.

Go to frame 1, and keyframe Evaluation Time to 0.  Also make sure to set Frames to 20. (these settings are found in the Object Data tab of the curve).

Now, go to frame 10 and slide the Evaluation Time until it appears that the object is at the same location as your second control point and keyframe it.  (being in Edit Mode allows you to see the control points)

Finally, repeat the above process to ensure that object will be at the third control point at frame 20.

Python Solution

If you have too many control points to go through by hand, then scripting this would be possible too.

The script could start off by calculating the lengths of each segment of curve.  You'd have to numerically integrate the formula for the cubic Bezier curve (numerical integration because it can't be solved analytically).  If you could successfully install SciPy into Blender, you could use their integration functions, otherwise you could write your own script using Gaussian quadrature or any other numerical integration algorithm).

Once you have the lengths, the user could input a list whose n-th entry specifies at what frame the object should reach the n-th control point.  Set the Frames property of Path Animation to the last frame in the list.  For each entry in list, set the Evaluation Time to be the sum of lengths of segments up to that control point divded by the total length multiplied by the last frame.


How to set camera to view the whole floorplan?

Your camera clipping end value is too small. Try setting it to 15' or more.

The floor plan is 14' 8.58" away from the camera, but the camera end clip value is 8' 4". This means that no objects further than 8' 4" away from the camera will be displayed in the camera view.

Also, make sure that the camera clipping start is smaller than the distance between the object and the camera, for the same reason.


Why is render stacking less efficient (noisier) than rendering normally?

Cycles uses Quasi Monte Carlo sampling:

http://en.wikipedia.org/wiki/Quasi-Monte_Carlo_method

That means it will try to evenly distribute samples so rendering converges faster. If you render multiple times with different seeds however then this even distribution is lost because it mixes different distributions without ensuring that the combined result is even too.

Since Blender 2.78 there is a sample offset command line option to avoid that problem, where you can set it so that each render uses a subset of samples from the same distribution.


I can't say about how to fix the rotation but might I suggest just adding an object like a circle and setting it's origin to the center of mass of your character then parenting the armature and it's hierarchy to that object and just going from there.


Position 3D cursor in X without changing to oobjects surface Y

Goto View tab

Expand 3D Cursor section

Change the Location coordinates

To snap object to the 3D cursor, click  RMB or press W.


Why did my mesh disappear after using remesh modifier?

For this modifier object has to be a 3D. Your N is only 2D.

To clean up go to edit mode, select all vertices and press X > Limited Dissolve.

Or select all vertices and press F (Make Face)

For more info https://docs.blender.org/manual/en/latest/modeling/meshes/editing/basics/deleting.html


Problem overlapping two meshes for baking

ALT+G clears location of any mesh. so it brings mesh to origin(0,0,0).
similarly Alt+s to clear scale and Alt+R to clear rotation.

The two meshes are different, resulting different center of masses (geometrical origins) one of the meshs center of mass may be higher, so even if you clear location i.e set to origin they are not quite over-lapping.

In order to correct it, select all bottom vertices of anvil ( easy in wire mode ) shft+s-> cursor to selection then tab out to object mode shift+alt+cltr+c change origin to 3d cursor. Do same for two meshes.

Then press Alt+G the should be overlapping. In fact Andrew specifically mentioned these in previous videos.


Baking normals can be tricky. If the normal of the lowpoly object is roughly the same as the highpoly object, the bake will be that bluish-cyan-pink that we like. However, if the normals points in opposite direction, the bake will be the inversion of those colors, as the yellow-brown-red.

Then why does the normals point in opposite direction? That could happen if the highpoly object intersects itself. The baking process have difficulty to find the correct face, with the correct normal.

Here are some images with a good and bad case:

In the second case the highpoly mesh intersects with itself. The lowpoly object can't be projected on the highpoly with a good result.


Last element deformed when using Array Modifer and Bezier Curve

I think I figured it out. @moonboots was right that the curve handle was wonky, hence it was pointing the track in a weird directly. My solution was to set the Handle Type in the Edit menu for the curve to "Vector" (Using Shift + V) and I can get straight lines and not have to deal with rotation. Here's the result:


Distributing hairs evenly along the surface

You might be looking for even distribution. It is located under the advanced settings.


Go in the Properties panel > Object > Visibility, disable Diffuse.


I want to change default settings of '2d animation'

Color 2 is the world color.

You can set the size of the camera canvas in the render resolution panel (and then use scroll wheel or Ctrl + Middle Mouse Button to scale the view in the 3d window).

Color 1 is a viewport matte with transparency, it can be set going in object mode, selecting the camera, and varying its "passepartout" value.

Then you can go to the file menu, defaults, save startup file, to mantain your settings in any new project.


How to get list of all images in a scene with python

If you just want to iterate over the images:

import bpy

for img in bpy.data.images:
    print("name=%s, filepath=%s" % (img.name, img.filepath))

Note this could contain 'render result' and materials which you might want to filter.
See the docs to see what attributes could be interesting like 'file_format', 'filepath', 'filepath_from_user', 'filepath_raw'...


How to voxelize and extract blender data?

I just read your question statements and comments.
Generally your approach is fine in my opinion. I try to supply some details here. Hope them help.

External or internal?

Luis B suggested in his comment:

  Have you tried using the Blender Python API to create an internal Python Script(as opposed to an external Python program)?

I think an external script may be more suitable in this case.
The conversion from a geometric representation(which is created by Blender) to computation representation(i.e. something like Eulerian grid) should be coupled with your simulation, not Blender.

For example, the computation grid may be staggered, or you want to use adaptive grid(such as an octree rather than a uniform grid), etc.
All of these requirements depend on your simulation's setting.

How to do the voxelization?

I assume you are using mesh geometry to represent elements and boundaries in your simulation.
Then in this case you need to traverse all meshes and decide which mesh the point belong to.
For convex mesh you can shoot one ray and check the intersections with the mesh. Two intersections means a point is outside this mesh. Also you need to handle the special case which a point is just right on the surface of mesh.

This process will be slow. But I think it is ok since you only run it once for each simulation configuration.

If you do want to optimize its performance you can consider using some data structures like BVH(bounding volume hierarchy), kd tree or spatial hash.

Things get much simpler if you can use procedural objects. For example you model a sphere using distance field function like $x^2+y^2+z^2-1=0$ rather than polygons. Then it is easier to decide whether a point is in a geometry(evaluate the distance field function and a negative value indicates the point is inside).


How do I create a realistic translucent material?

If you're just looking for the frosted glass effect, try something like this. Basically it's just a high transmission value (for transparency/translucency) and a mid-level(ish) roughness (to make it more opaque - "frosted"). I added a bit of subsurface as well, but it's probably not needed. The "Bump Map" setup is optional too, but I just wanted to give some "micro-bumps" on the surface:

If you want more transparency (see through it more), you can try this setup. You can control the "frostiness" and transparency/translucency using the IOR of both the Fresnel and the Refraction BSDF, as well as changing the Roughness on the Glass BSDF.


Set custom location for import/export helper

My guess is you want the filebrowser to open at this location. My suggestion on this would be to set up default path properties in your addon preferences (if an addon).

class ImportDefaultPathsAddon(AddonPreferences):
    # this must match the addon name, use '__package__'
    # when defining this in a submodule of a python package.
    bl_idname = __name__

    default_obj_path = StringProperty(subtype='DIR_PATH')
    default_collada_path = StringProperty(subtype='DIR_PATH')

    def draw(self, context):
        layout = self.layout
        layout.label(text="Import Paths")
        layout.prop(self, "default_obj_path")
        layout.prop(self, "default_collada_path")

Then in your layouts, menu  or panel button

def draw(self, context):
    user_preferences = context.user_preferences
    addon_prefs = user_preferences.addons[__name__].preferences

    layout = self.layout
    op = layout.operator("import_scene.obj")
    op.filepath = addon_prefs.default_obj_path

    op = layout.operator("import_scene.collada")
    op.filepath = addon_prefs.default_collada_path

The user would need to set the paths when the addon is enabled.

PS I've looked at other methods of doing this, and can also suggest ditching the ImportHelper subclass altogether and write your own invoke and parameters.


It is there in the UV menu on top, maybe update blender?
If you can't find it, you should be able to search it by name with F3 key on 2.8
I can find it by typing export uv.


Shrinkwraps Not Following Head - Pupil Shrinkwrap Not Staying On Eyes When Rotated

Here is the Link to explain what I would change

These are the primary things I felt I would change if this were my own.

I would use an Empty for the focal point (instead of a bone) and parent it to the armature.

I would get rid of the two empties at each pupil.

I would tell each pupil to track (constraint) to the "NEW" focal point empty.

I would tell each pupil to pivot (constraint) to the "Head" bone.

Here is the result of doing these four things.


What's the meaning of 0 to 1 space in UV?

It is actually a coordinate system in percentage of image size.

A coordinate [0,0] corresponds the lower left corner, and [1,1] is the upper right corner (depending the the render engine/software.

It is made in such way that unwrapping is actually image size independent, so that if at a later time, you decide to use a larger image or an image with different dimensions the UV map still works and adapts (with distortions) to the new image format.

It is not a Boolean value nor is it limited to the 0~1 range, it is a float and can take on any value like -3.2, or 158.56.

The image will tile infinitely in X and Y axis repeating at every 1 unit, so for values bellow 0 or above 1 it will tile the image so that coordinate [2,2] will show the same part of the image as [1,1].


Vertex color bake to texture causes wrong color margin

Give some margin

If you inspect closely your uv, you should se than there are no margin and some colors that are not exactly aligned with the uv grid.

This happens because the uv grid (which depend on the number of faces) has different size from the pixel grid (which depends on the baking texture size). You can try to match these with some calculations.... or you can re-unwrap the model in the following way:

set the smart uv margin tho a proper value (for a 1024x1024 tex I set 0.05) and than bake with a minumum bake margin of 1. Setting a margin allows a certain tollerance between color, avoiding overlaps and pixel-grid issues.


Can a quaternion be used to convert between coordinate systems?

I'm not into quats at all, but here's something I noticed, which may or may not be of any use.

Swap y and z in a matrix and look at the quat:

>>> Matrix(((1,0,0,0),(0,1,0,0),(0,0,1,0),(0,0,0,1))).to_quaternion()
Quaternion((1.0, 0.0, 0.0, 0.0))

>>> Matrix(((1,0,0,0),(0,0,1,0),(0,1,0,0),(0,0,0,1))).to_quaternion()
Quaternion((0.9999999403953552, 0.0, 0.0, 0.0))

# both matrices give different orientations, but not the quats!

And here's a custom space matrix:

>>> Matrix(((1,0,0,0),(0,0,-1,0),(0,1,0,0),(0,0,0,1))).to_quaternion()
Quaternion((0.7071068286895752, 0.7071068286895752, 0.0, 0.0))

>>> Matrix(((1,0,0,0),(0,0,1,0),(0,-1,0,0),(0,0,0,1))).to_quaternion()
Quaternion((0.7071068286895752, -0.7071068286895752, 0.0, 0.0))

Note the difference 1.0 / 0.0 vs. 0.7 / 0.7 (whereas the matrices are normalized, with using zeroes and ones only) - it might not be enough to negate the sign of a quat component.

I suggest you create a custom matrix for the space conversion and cast it to quat.


The reason you see this behavior is because the link to the texture is broken. I found that Blender has difficulty "remembering" the location of the texture when moving a file or even opening the same file on a different computer. Relink the textures should fix your problem.


How can I make a light trail without using particles?

You can use a mix between an Emission and a Transparent node and use a Gradient along the axis, with the Texture Coordinate UV socket.
If you're using Eevee you can use Bloom to make it look like a ray (the Emission Strength needs to be pushed high enough), if you're using Cycles you'll need to do it in the Compositor.


CPU and GPU - does CPU work with or alongside the GPU?

If you've selected to use both the GPU and CPU for rendering, the GPU will work on a single tile while each CPU thread will also work on a tile. In this case, you will see the GPU rendering single tiles much quicker than the CPU threads can render their respective tiles. However, if your GPU does not have enough video memory to render a scene, Blender will use your CPU to render. Unless you're working with massive scenes, I don't think that's the case here.

To find specific render times, go to Blender OpenData to view the benchmarked times for various devices. Note that this is for that specific device(s) being used to render. Since the hardware you're interested in isn't in the top 50, go to the Raw Data section and find the relevant benchmark times in the JSON file (which you can do by importing the file to Excel). It's not the most user-friendly, but you can also search for benchmarks 3rd parties have done and posted online.

I do not believe that your render times will be halved. To my understanding, if you're only using your GPU to render, the CPU will be doing physics calculations (hair, collisions, object transformations etc.) while the GPU deals with rendering actual scene once the CPU has calculated the aforementioned things.

When it comes to multicore processing, things get a bit tricky. Many calculations cannot be done in multiple threads and must be sequentially calculated. For example, consider an object parented to another during an animation. Blender must first calculate the parent's position, and only then can it calculate the position of the child relative to the parent's position.


How do I get rid of these wrinkles in texts

Every polygon needs to get broken down into triangles.
As your mesh has a bad topology, this is expected and would not behave differently in any other software or version.
Solution: Retopologize your mesh, at least subdivide it.


Directional audio based on direction the camera is facing

Drive the volume of the speaker.

There are three vectors of interest.

The direction the camera is facing (-Z local axis) in global coordinates.
The direction the speaker is facing (-Z local axis) in global coordinates.
The line between the camera and speaker.

In test script below, the angle between the camera vector -Z axis direction and the line between the camera and speaker are converted to global coordinates and normalized.  The dot product is used to drive the volume of the speaker.

Notice this doesn't look at whether the speaker is facing the camera, as this can also be achieved by setting the cone attributes of the speaker.

For convenience running the script will add drivers to Speaker.volume.  (Note will cause problems if speaker objects are sharing speaker data) for each speaker object in scene.

Will be verbose to the system console as there are print statements. Could look at the angle between vectors, or drive the mute property.

import bpy
from mathutils import Vector

context = bpy.context
scene = context.scene

def speaker_vol(spk, name):
    cam = scene.camera
    cmw = cam.matrix_world

    cam_vec = (cmw * Vector((0, 0, -1)) - cmw.translation).normalized()
    spk_obj = scene.objects.get(name)
    if not spk_obj:
        return 0
    smw = spk_obj.matrix_world
    spk_vec = (smw.translation - cmw.translation).normalized()
    print(spk.name)
    print(cam_vec)
    print(spk_vec)
    print(spk_vec.angle(cam_vec)) # angle in radians
    print(spk_vec.dot(cam_vec))
    return max(0, spk_vec.dot(cam_vec))

# register this driver
bpy.app.driver_namespace["speaker_vol"] = speaker_vol
# set up the drivers
speakers = [spk for spk in scene.objects if spk.type == 'SPEAKER']
for spk in speakers:
    fcurve = spk.data.driver_add("volume")
    driver = fcurve.driver
    driver.use_self = True
    driver.expression = 'speaker_vol(self, "%s")' % spk.name


How to make textures made in Blender appear in Unity3d?

Most likely you will have to import your texture to Unity as well as your model, then edit the object you have imported and its material. You often have to reassign the texture to the material inside of Unity to make the texture appear.


Thx to Serge L I could figure out with different tries of the denoiser size and the amount of samples to get rid of the artifacts, the shadow/color lines could have been caused of the to dark scene so they mostly disappeared with more or brighter light, now Im happy with the result and can go on thx for the help guys.


Access the systems clipboard buffer from Python?

You can get/set the clipboard via bpy.context.window_manager.clipboard

See: http://www.blender.org/api/blender_python_api_2_72_release/bpy.types.WindowManager.html#bpy.types.WindowManager.clipboard


double instance of sound when using VSE-scene strip in another scenes VSE

The answer is with AV-sync.

If you have multiple scenes with audio, then make sure that only the one you're currently working on is set to AV-sync.

If you do happen to get a sound instance running that is not apparantly attached to a scene, you can stop it by switching to the scene with AV-sync and start/stop playback once from there, that will stop the "wild" sound instance.

Here's a little script-snippet that will turn off sync on all scenes, then set AV-Sync for this scene only (tested with blender 2.7x - not with 2.8)

import bpy

for scn in bpy.data.scenes:
    scn.sync_mode = 'NONE'`

bpy.context.scene.sync_mode = 'AUDIO_SYNC'


How to read a bone's quaternion rotation and convert from local bone to world space

Based on some simple experiments it seems that

debone = Matrix([[1,0,0,0],[0,0,-1,0], [0,1,0,0],[0,0,0,1]]) #because bones are wacky
m = armature_object.matrix_world * poseBone.matrix * debone
o2.rotation_mode = 'QUATERNION'
o2.location, o2.rotation_quaternion, o2.scale = m.decompose()

will align o2 with poseBone (unless o2 has a parent causing its matrix_local to not be identical to matrix_world)


Making a reflection on a glossy object based on each frame of the video

If I understand correctly, you want to create a glossy object and have it reflect an environment comprised of moving images from a video...

You don't have to map the reflections into the object, just give it a glossy shader and let it reflect the environment.

It's on the World that you need to map your video image and let it reflect on the ring:


How do I draw on an object in blender? Tips on creating resistor

Roughly,
I built your scene. I generally use Cycles so there may be a better way in Internal, but this works pretty well.

First, add a material by clicking the (+) button. You will be presented with this page.

Make the suggested edits, such as changing the diffuse and specular colors and increasing the specular intensity from 0.5 to 0.7. You can rename the material to something like pill or resistor body.

Next, click the other plus button, the one next to the light grey drop down menu. This will give you a new material slot. Change the diffuse, specular, and intensity values for your next color (red, green, or orange according the picture). Repeat this step for the next two colors. Don't worry that they are not yet showing up on your model.

Now, press tab to enter edit mode and use Ctrl+R to add loop cuts. Do not left or right click yet. Press (4) at the top of your keyboard and move your mouse around your object until the loop cuts are positioned around the main cylindrical body.

Now left click to confirm. Change into edge select mode and select only the loop cuts you just made. It might help to hold Alt and right click on the edge. Key Ctrl+B and drag your mouse outward to create strips. Just don't drag too far. Change to face select mode. Select the faces where you want a certain color to be (using Alt+loop again), select that material in the materials panel, and click assign. You should now see a colored stripe on your model. Repeat for the other stripes.

Now tab back to object mode and change the rotation so that it is only rotated 90 on the x axis (no Z rotation.) Tab back into edit mode and select the smallest loop of faces on either end where you want the wires to be. Key E, S, Y, and drag outward to desired length. Now extrude once more, but just a little bit. Rotate each end 45 degrees on the x axis so they are pointed half downwards. Now key E, Z, and drag down a bit beyond the desired length. Tab out of edit mode.

Almost there...

Shift+A, Mesh, plane. S to scale it up. Drag down on the z so that only the resistor and the part of the wire that you want visible is showing.

Rendering

Go into the tools panel, the tools section, and shade Smooth. Drag the light over the resistor so that the shadow will cast directly down. In the light's object data panel, up the samples to 5. Set up the camera to point where you want it, up the resolution on the render panel to 100% (in the dimensions box). Click Render!

My finished result:


How to make cigar (not cigarette) texture?

I know you're ultimately using an image texture, but as an example (and possibly for reference), here is how this material can be made completely procedurally using blender's shader nodes (works in both Cycles and EEVEE).

Since this is procedural, there are no need for image textures or UV unwraps - it is simply "plug and play", so to speak. The whole thing, all in one go. The graph looks a bit scary, but it actually looks more complicated than it is - For example, there are at least 10 nodes (all MixRgb) in that graph that do nothing more than make a given texture "lighter grey" in color. I will break it down the best I can, and I will also provide the .blend file at the end, so anyone who wants to mess with it can have a go.
To begin (as I always do when making procedural textures), I thought about what main components I am looking to recreate, and then devise a "Category" for each of them. Looking at the cigar in your image for example, I see that there are diagonal lines where the "paper" is wrapped around the cigar. I also see that since the object is made of "tobacco leaves", that there will be leaf veins and slight warping consistent with a dry leaf surface. Since the tube is stuffed and rolled by hand, I also notice surface deformation consistent with a slightly imperfect roll. Two more components, which I added for zeal, are the "crumpled" ash and, obviously, a glowing ember. I then sought out to make a "section" for each of these.
Starting in the order I listed, I began with a section for the diagonal "wrap lines".  This section probably gave me the greatest difficulty of the whole graph - using generated coordinates, it's rather difficult to get a single line to "wrap around" and continue along all 3 axes (although I'm probably forgetting something obvious - how embarrassing when someone inevitably points it out). For me, it took isolating the X-axis vector and using only that. Though the lines look like they are part of a continuous diagonal path in the image I posted, they are actually "loops" that connect to themselves on the backside, not a "spiral" so to speak.
The lines look light in the picture, but they will eventually be used as part of a Bump Map, so subtlety is key - differences too great between light and dark show up very strongly for the most part, and a shorter contrast range tends to give a more natural look. Also note - in the images I display below, you will see a combo of a Diffuse BSFD connected to a Material output popping up like Waldo - This is just as a quick way to make the map I'm showcasing show up in the preview window. You do not need these in your map (except for the material output at the very end).

The next section I made the "leaf veins. I used the distance output of a Voronai Texture to get the "cell shape", but before this, I employed a little "trick" using a Noise Texture to warp the input vector ever so slightly by using a Vector Math Node. This is responsible for the little "ripples" in the veins. I employ this trick in a few sections of the graph because generated textures are often too "linear" or "straight" and need a bit of warping to look realistic. I clamped the light/dark with a ColorRamp because I wanted very thin lines to make the veins.

Sticking with the leaves, I also needed a "dry leaf" warped surface. For this, I used another Voronai Texture, with the same "warped" input vectors, but I changed the scale slightly. The ColorRamp in section does nothing at the moment - I was using it for testing purposes, but found that everything works best with the full available contrast gamut. I then mixed (multiplied to copy the darks only) this "leaf deformation" with the vein texture. As you can see from the image, the veins are rather sharp, whereas the warping is so subtle in its contrast that you can barely make out the light and dark areas - this is on purpose - I stress again, a little goes a long way.

The next thing to tackle was the "tube deformation" caused by a hand-roll. This I accomplished easily through the use of a scaled down Noise Texture. As you can see in this (and many of my) example(s), I used a MixRGB to mix the noise texture with white. This not only has the effect of making the eventual Bump effect more subtle, but it also brings the base (lowest) value up from pure black. I need this because I often multiply my B&W values to carry the darks over only, and this stops areas of the texture from "bottoming out" at pure black which would make them unable to pick up any further dark detail (this is a bit complicated I know, just remember that black = 0 and anything multiplied by 0 also becomes 0. If you don't want a pure black (0) section, don't multiply it by any other texture that has a 0 in that section, or you will get pure black)

For the ash, I used another "warped vector" combined with a gradient texture to make the lines, which I then sectioned off to the "end of the cigar" using a ColorRamp. To give it "crevices" and dark spots like real ash, I multiplied it by a Musgrave texture. As you can see, a full multiplication factor of 1 gave me undesirable results so I had to scale it back a bit. This caused some of the light colors from the Musgrave texture to penetrate through the black areas, despite the multiplication. This is ok, however, as it will be dealt with later when I begin employing Masks.

Lastly, for the embers, I used yet another noise texture, Run through a ColorRamp to give it some "burny" colors. Again, as you can see the ember covers the whole cigar in the image, but will be appropriately "sectioned off" by masks as I mix it with other components.

Speaking of masks, here's one I made for the embers. Only the section that is white will allow the texture to show through, the rest will be blocked.

And here's one I made to section off where the "ash" will go. In this image, I'm showing the result of the ash texture "constrained" by the mask.

I also made some "dimple spots" that cigars tend to have, and mixed it with a simple noise texture to get some additional greyscale variation. I then gave this mix some "tobacco colors" with a ColorRamp node, and then mixed the result with the inverted values I took from the leaf vein/deformation combo.

Next was just a matter of mixing it all together, using the masks I made as mix factors in order to "guide" the textures to their appropriate sections. I made some other adjustments too, however it would be simply too verbose to explain them all. Basically it was just a matter of slightly adjusting values to my liking (the MixRGB's "adding" to themselves, for example, is just a quick way to brighten the light values a few steps) , and using different mix arrangements to get the most desired result.

I also made a "Height Map" from the B&W values I had from the different "sections" I've made, combining them also with masks, in such a manner that they will represent the deformation properly (white/light=high black/dark = low). I made the ash "high", as it tends to expand from the end of a cigar as it's burning. I then made this into a Bump Map by connecting it to the height input of a Bump Node. and then using that as a "Normal Map" so to speak (connected to normal of Principled BSDF).

Lastly, I wanted the ember to "glow", so I masked off just the ember and connected it to an Emission Shader. Because an Emission Shader is a shader and not a color map, it cannot be combined with the rest like the others using a MixRGB. Instead, a Mix Shader must be used.
Also, if you notice in the image, I have a roughness map connected using a mix with a Value Node. This is simply because I liked the value .832 for my roughness, but wanted to make sure the ash and ember section were absolutely not shiny, so I mixed the value with pure white mask I made for just that end section. If you want the cigar to be a bit shiner, like in your photo, you can lower it, however I don't recommend going below 0.65. The rest of the BSDF values, I didn't move from the defaults.

When I connected the two through the Mix Shader, I used the "ember mask" as a mask for the mix because I didn't want the dark section of the "ember/mask  mix" to copy over to the final shader combo .
Mixed all together, with the Bump Map connected, and the emission mixed in, the final result looks like this:

As promised, the .blend file is here for all those who want to have a look -


How can I get particles (confettis) to fall on a sphere, follow its surface without penetrating it and fall off when reaching the "equator"?

For the rotation, make it Dynamic in the particle settings

For the intersection, create a second sphere and make it a collision object (this will be your hit box) and enable Size Deflect in the particle system, then scale down the second sphere until the particles hit the first sphere near its surface (because the size deflect will make the particles deflect a few centimeters from the surface). Of course delete the collision from the first sphere.

For the stickiness, for confetti you should use 0 stickiness, 0 friction (or at least low values of it) and 1 damping


Removing Location Keyframes from LocRotScale?

Try opening the graph editor with your dragon selected, and go through the drop down menus for it and see f there is a separate key frame sequence for location. If there is, you can select it and delete with x. I'm sorry I don't have access to a computer at the moment otherwise I would provide screenshots and a less vague answer. I will update this when I can.


Imported object shows aligned to the wrong axis

Most import/export types have an option to alter the Forward and Up alignment. Try some different options to find which one matches your exported data.


I've found a way to get rid of all the animations. Using the information given by sambler, i deleted everything inside the NLA editor, after that I went on to the action editor and shift + x all animations and now they are gone.


Difference between Ctrl P > Follow Path and Add Object Constraint

CtrlP > Follow Path parents the selected objects to the active object (=curve), enables Path Animation in the curve's Object data tab in the Properties Editor and adds an F-Curve for the Evaluation Time property. An F-Curve Modifier is added to that F-Curve of type Generator (first order expanded polynomial).

Adding a Follow Path constraint to an object and target it at a curve only relocates the object (apparently to one of the end points of the curve), you need to click Animate Path to add an F-Curve with modifier (1st order exp. polynomial generator again) to the curve object in order to let the object move along the curve.

If you don't want that offset when using a Follow Path constraint, select your object and a curve,
CtrlP > Path Constraint. It adds a Follow Path constraint, creates the F-Curve with modifier for the the curve and does not translate your object.


Using python to create freestyle line groups

To mark a freestyle edge use MeshEdge.use_freestyle_mark

Here is some pretty ugly demo code to select every second line of edges in the x direction, that works because mesh is aligned x, y.

import bpy
import bmesh
from mathutils import Vector

context = bpy.context
mesh = context.object.data
N = 30
TOL = 0.0001

# clear all freestyle mark edges

for e in mesh.edges:
    e.use_freestyle_mark = False

def edge_by_value(e, axis, value):
    v1, v2 = e.verts
    return getattr(v1.co, axis) == getattr(v2.co, axis) and abs(getattr(v2.co, axis) - value ) < TOL

bm = bmesh.new()
bm.from_mesh(mesh)
bm.edges.ensure_lookup_table()

x = -3
while x < 3:

    edges = [e for e in bm.edges if edge_by_value(e, "x", x)]
    print(x, len(edges))
    for e in edges:
        mesh.edges[e.index].use_freestyle_mark = True
        mesh.edges[e.index].select = True # selected
    # every second edge
    x += 2 * 6 / (N - 1)

mesh.update()

Running with this line of code

    edges = [e for e in bm.edges if edge_by_value(e, "x", x)
               or edge_by_value(e, "y", x)]

Probably a better approach is: if you know the index order of the edges, would be using row/col integer modulus and div on the edge index.


When you get the array you want with AN, delete the AN nodetree and the objects will remain (you may have to be in +1 frame).

This will give control of the objects back to you. However each object copied from the group instance will share the Vertex information. Go to the Object Data view and create Single user for each object.

You can now bring in these objects into AN to manipulate again as you wish.


Shader with golden logo, normal map and or displacement map

You need to make one and unique material with this kind of node organisation (very simplified). You need to use the logo alpha output into the factor of the Mix Shader in order to make a mask and see the background. Of course the left part can be as complicated as you want, with Bump or Normal nodes plugged into the normal socket of the Diffuse etc:


Select words without indentation in text editor

def execute(self, context):

    bpy.ops.text.move(type='LINE_BEGIN')
    bpy.ops.text.move(type='NEXT_WORD')
    bpy.ops.text.move_select(type='LINE_END')
    return {'FINISHED'}

This selects whitespace at the end of the line.


How can we build shape keys for protruding eyes?

Click the 'Apply Shape Keys in Edit Mode' button right after you make a new Shape Key, so that your shape key is based on the previously made shape key(s).

Also, depending on how your rig is going to be setup, you may have to change the shape keys to blend relative to the previous position, rather than 'Basis' in the blend section too.  But it depends on how you want your bone controls to drive the shape keys.


there is a "noise" node that is generating the problem. try to switch to 2d.

check this to more details:


mtl file after exporting comes without texture map (map_kd ...)

The problem is that the .obj exporter requires a material setup using the Principled Shader in order to write an .mtl with the map_Kd attribute. Unfortunately the documentation is still work in progress for Blender 2.8, that's why this wasn't previously documented.

The fix for your problem is to replace the Diffuse BSDF nodes with the Principled BSDF. Then you can simply plug your texture into the base color socket of the Principled BSDF, set Specular to zero and it should export as expected.


How to render video with sound? (VSE has audio)

I don't know why, but in your blend file (instead of screenshot) audio codec haven't selected . When I select it, everything is fine. Doublecheck this.


Lighting looks strange and planes are disappearing

In Edit Mode with everything selected, go to Mesh menu (Blender 2.79b)/Normals/Recalculate Outside.  See if that helps.


rendered video is different from preview

I'm having the same issue. Turns out that the Proxy render size under View Settings, Really destroys the accuracy of the video in preview.
Notice how the 'Text' and 'Character' deviates from its original location.

Images and Videos are not affected, But  Text, Any sort of animation is affected.
The solution I found for myself is to fix all the glitches manually in full render settings.
Edit:
Turn on AV Sync. You will find it under Timeline-> Playback -> AV Sync (check mark).


Simple keyframe question in Blender animation

Your mistake was to animate the cube while you should have only used the bone. There were two different animations: the cube and the bone. If you choose to parent your cube to a bone (with ctrl P > Set Parent to > Bone), then use the bone only to control the cube. By the way, in the Dopesheet bottom menu, click on the arrow button, it allows to display only the keyframes of the selected object, it will help.


The shortcut is F9 or you can access it through Edit > Adjust Last Operation.

Quoting from the Manual:

After an operation is complete you can tweak the parameters of the operation afterwards. In editors that support it, there is a “head-up display” panel in the bottom left based on the last performed operation; dependent on mode and context. Alternatively, you can create a pop-up with F9 which does the same thing.


You have doubles , flipped normals and ngons in your meshes.

Select the object named mask, enter edit mode and do the following :

-select all vertices , press w and remove doubles.
-recalculate normals with ctrln

result :


How to append text to the end of a Text datablock with Python

Write nothing first

Yes it writes at the cursor location, but will notice then seeks to file end. As mentioned in doc string

>>> t = D.texts['Text']
>>> t.write(
write()
Text.write(text)
write text at the cursor location and advance to the end of the text block

Simply write nothing to seek to EOF

t.write("")

Alternatively can set the cursor, as an example have used ints greater than existing lines and character length to make sure the cursor is at EOF.

 t.cursor_set(44444444, character=44444444)

in both cases may require writing a new blank line.

t.write("\n")


Faces get distorted when scaled or moved

It's difficult to see from your screenshot but:

1.) A plane, by definition, is two dimensional.  A face in Blender is simply a plane.  Once you edit the face in a way that destroys the two-dimensionality, Blender doesn't quite know what to do with it, because it expects that the user understand graphics and geometry.

2.) Yes, most certainly.

3.) You must subdivide the face in a way that "allows" it to remain two-dimensional.  Triangular faces, by definition, are two dimensional, because for any three given vertices, they exist in the same plane.  Therefore, subdividing it into triangular faces is the easiest way to resolve this:

4.) Most certainly not.


How can I rotate and scale a texture in cycles?

You need to switch the order of the nodes. "Texture mapping" needs to go before "image texture"


Is there and existing Blender renderer REST API service?

Perhaps you should take a look at RenderStreet.
I used it for my work as well, what i like about it is that they provide a plugin in Blender, from which you can upload a blend file. Then they do the rendering, they do an estimate of the cost (which can change over time, since your render frames can get more complex); you can ask someone else to pay ahead your render time (ea your manager, or your custommer). And they have web interface that looks quite well on a mobile phone. you can pause / start (multiple) jobs, and they have also FTP access to download your end result.

You might get cheaper elsewhere, but the fact that they offer such billing, and preview made it very easy to combine with real work.
Their support is also quite good, and their speed is blazing.

For sure there other render farms, and even amazone scripts.
But in a work situation this might be as close to saas in a "company-sense-work" way as one might get.

And if you a little bit more time left, you might find an old Coin minner who sells his hardware (that's my current situation), i ussually use that now unless i have to finish something in one day, then i go to a render farm solution.

(oh you might edit the script of renderstreet to make it even more Rest Alike, or ask their support to create it for you).


Change Object's Location on local Z-Axis using Slider

Applying rotation accumulates

As I was poorly trying to point out in comment applying the translation matrix from value will have a cumulative effect. (no matter what direction)

Use the delta value calculated from previous value.

Other minor changes, use self in the setter getter, rather than relying on  bpy.context.object is self  If you want context possibly better to use an update method instead.

Using ob.get("propname", default) gives a default value even when the property hasn't been set.

EDIT.  Changed this to moving "locally globally" this way our slider value is global and won't be affected by local scale. (Move 1 unit globally in local z, akin to translate operator)

Example below working in 2.8. (Minor change @ to * or back).

import bpy, mathutils
from bpy.types import Panel, Operator
from bpy.props import FloatProperty
from mathutils import Matrix, Vector

#get, set methods of the floatproperty
def get_locationZ(self):
    return self.get('locationZ', 0)

def set_locationZ(self, value):
    z_axis = Vector((0, 0, 1))
    delta = value - self.get('locationZ', 0)
    v = (self.matrix_world.to_3x3() @ z_axis).normalized()

    self.matrix_world.translation += delta * v
    self['locationZ'] = value

class VIEW3D_PT_ToolPanel(Panel):
    bl_space_type='VIEW_3D'
    bl_region_type='TOOLS'
    bl_label='Cylinder'
    bl_context='objectmode'

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

        row = layout.row()
        row.template_ID(context.view_layer.objects, "active") # context.scene.objects (2.7x)

        split=layout.split()
        col=split.column(align=True)

        if obj is not None:
            col.prop(obj, 'myFloat', slider=True)

#floatproperty
bpy.types.Object.myFloat = FloatProperty(
name = "locationZ",
description = "Set the location on local z axis",
min = -100,
max = 100,
soft_min=-10,
soft_max=10,
step=1,
subtype='DISTANCE',
get = get_locationZ,
set = set_locationZ)

#Register
def register():
    bpy.utils.register_class(VIEW3D_PT_ToolPanel)
#Unregister
def unregister():
    bpy.utils.unregister_class(VIEW3D_PT_ToolPanel)

if __name__== '__main__':
    register()

As a side note the new elementwise @ multiplier works as expected for M @= T  For 2.7x found using M = T * M a more reliable option.


Is there a way to place a material over other materials (subdermal base)

Try using the Principled shader. It has SSS, diffuse, and roughness all built in. Connect the subdermal texture to the SSS color input, the skin texture to the color input, and set the SSS amount to something other than 0. You will probably have to adjust the subsurface radius to get it looking right. If I recall correctly, you want the red value (the top one) to be the highest by a fair bit, then green, with blue slightly below green. The radius is essentially the 'depth' of the scattering effect for each light color (RGB). Human skin is red when you shine a light through it, so that is why you will want the red value to be higher. I believe the radius is in blender units, so keep that in mind with the scale of your object. You don't want the radius to be larger than the width of your model, as that will make the entire hand translucent, and look fake.

Some other things to consider to get great looking skin is some subtle bump and a roughness texture (using the Principled roughness and normal). That will really help make the skin look realistic, as skin has some subtle reflections and surface texture.


Low res texture in UV map with repetitive polygons

In the UV Editor (as shown in your picture), select one of the 'sides' (position the mouse cursor over one and hit L) then hit ctrl P - this will make it fill the image vertically at 64px high. Now scale it by half S (.5). Do the same with all the other 'sides' (not the top or bottom), they should now sit neatly one on top of the other, and be 32px high.
Position the 2D Cursor on one of the vertices at the bottom of the 'sides' (select a vertex and hit shift S > Cursor to Selected),

and then set the pivot to 2D Cursor.

Now grab G the 'bottom' and position one of it's vertices on the 2D Cursor and then scale (S) until the next vertex lines up as shown.

Do the same with the 'top'. Now all resolutions should be the same and the sides will be 32px high. I hope this solves the problem.


How to make an object completely transparent?

The following material setup should give you a completely Transparent material that cannot be affected by light etc.

You can add a material and set the specularity and alpha to 0 and disable shadows but the easiest way is to not render the object at all. Open the Outliner and untick the camera beside the object.


How to make a good glow effect around a sun?

You could use a blend between a volume shader and an Emission shader to achieve this effect.

The trickier part would be to make it loose density as it moves away from the star center, fading into black.

For that you can use Cycles Gradient texture, set to some form of spherical falloff, so density decays as distance from the center increases.

Make sure you use Object texture coordinates and adjust the scale with a Vector Mapping node.

Use a color ramp to adjust density progression and color variance.


Adding a skirt / border to object with sharp corners leaves gaps

Import the svg curve.

Scale it to some size that is workable.

SVGs are imported as curve objects. You don't need to convert them to mesh in order to extrude, you can do that in the geometry section>extrude.

(I changed the color for visibility to the blue state that Texas should be)

Then create a new curve object, I will name it "Lip Curve" that has the profile shape you are looking for. Make it small, much smaller than the other object. To make sharp angles select two control points, press V to access the handle type menu, and select "vector"

Use the "Lip Curve" as taper object for the Texas Outline.

You can clean up the object a bit by lowering the resolution for the curve (in this case I lowered the preview resolution for the curve from 16 to 1)

Note that I'm getting a double lip on the object because this particular curve was created thicker in the vector drawing program (inkscape, illustrator, etc) So when it is imported into blender that thickness will be made out of two parallel curves to give it thickness.

To further refine the shape and do cleanup of overlapping segments convert to mesh and manually fix imperfections.


Importing a complex SVG to Blender from Illustrator - Problems with Fill

I don't think that the intricacy  of your design is the issue here but how Illustrator is combining the many different paths. It looks like there are way too many points to create the curvature of  the paths. I suspect those extra points are the result of compunding the paths. Even in segments that are straight there are many points in a straight line.

A cure to most of the problem is converting the Handle Type to Vector

but in the areas where there are still too many control points the problem persists. Maybe there are open paths somewhere? Illustrator has tools to check for open paths.

I suspect that the paths need to be simplified and streamlined before they are exported from Illustrator to avoid the problems you are facing.


How to make a procedural white birch bark material in cycles?

Making a birch shader completely procedurally is quite a challenge, this is my version:

(download blend file below)
Like the other two answers already say: you achieve these effects with stretched noise textures, color ramps and mix nodes. It takes quite a bit of time and experimenting to figure out which noise looks best for the specific surface. I mainly used the standard noise and musgrave noise.
Unfortunately I can't walk you through the whole shader, but here are some steps that helped me:

research the node wrangler add-on to prevent headaches

work from large-scale noise to small-scale noise. Here I created the big random blotches first, after that the horizontal lines and at the end the tiny black spots. That helps keeping the proportions right. It needs to look right from distance first, keep the details for later.

look at your noise textures isolated. With the node wrangler add-on activated, you can Ctrl+Shift+ leftclick a node and a viewer gets created.

stay between values of 0 and 1. When you start to mix the different noise textures for more complex noise, always look at the isolated result and make sure that the values don't go negative or exceed one. Your shader won't break when you have values below 0 and over 1, but it makes it much harder to work with, because these values can't be displayed.

group components to keep your overview... but: don't group them too early. Isolating nodes doesn't work in groups and this makes it really hard to "debug" node-groups, when you want to find one specific pattern.

Here are the horizontal lines I used:

create noise texture
scale on z axis by mapping coordinates (i used 4, 4, 40 in scale)
a high contrast color ramp for sharp edges
i used only the R channel of the noise

The result of that color ramp could then be used to

mix between shaders (as a factor in mix shader node)
create a mask, e.g. for colors or shader properties like roughness
be mixed with other noise patterns to create more complex and interesting noise
...

Here is the file:


Blender 2.8 : python code to switch shading mode (between wireframe and solid mode)

As to why the script generates an error:
When directly clicking on a button on the screen Blender understands the context of which workspace (tabs across the top of the screen) and area (window within the screen) you are accessing.
Your code fails to identify where exactly you want to apply the change.

import bpy

my_areas = bpy.context.workspace.screens[0].areas
my_shading = 'WIREFRAME'  # 'WIREFRAME' 'SOLID' 'MATERIAL' 'RENDERED'

for area in my_areas:
    for space in area.spaces:
        if space.type == 'VIEW_3D':
            space.shading.type = my_shading


Once you have your thresholds set, disconnect the noodles on the inside of the group and reconnect them.  For whatever reason the values don't update properly while actively in use anywhere down the chain.


How to keyframe the volume of a speaker with python

Volume is a data property, not an object property.
Don't use:
obj.keyframe_insert("volume")

But use:
obj.data.keyframe_insert("volume")


How to Keep Rig Always In Front in Blender 2.8+?

What do you mean by permanently doing that in the proxy?
I would say select the armature and then in the inspector you go to the bones and go to visibility or something like that and then click always in front.
feel free to comment below


What could cause an object disapear only in Edit Mode?

shift+t moves object's texture space - it has nothing to do with visibility.

You may have some modifier the effects of which is not visible in edit mode, or, more likely, you hid everything with h. To unhide the geometry hidden, you can go to edit mode and hit alt+h to unhide everything.

To reset the location of object's texture space if you moved it accidentally, you can set the values to 0 in the Properties Editor, Mesh tab, under Texture Space:


I have an idea, that you can use compositing to achieve this task:

I created 2 render layers, one for color (I make them solid using Emission node):

And this for the baked shadows (and objects with real shadows are holdout, to make a transparent on their place):

And multiply shadows with color in compositing nodes this way:


How to make the trees on the grid not through the grid? (Speedtrees, origin problem)

The orange dot in the center is the object's origin (the root of your tree). To move it down to the Z=0 position (the ground), switch to Edit mode and move all vertices of the mesh up.

Another option is to use the 3D cursor (and Shift+S menu), or move the origin directly in Object mode.


Camera is offset from path it is following

Use Alt + G to reset the location of an object. Alternatively, you can just set the location coordinates to zero in the N panel:


I'm not sure what you want, but it looks like you are using an alpha over node on two image without any transparency. This means only the image in the bottom input is used:

To do what I think you want to do, you need to render the sky as transparency. To do this, enable Transparent in render settings > Film:

You also seem to have deselected the layer with the model in the renderlayer. Ensure the layer you want is selected:

Once that's done, you should get a result like this (ignore the scale node, I needed that to scale my sky image to the render size)


If you are using the decimate modifier, make sure you Apply the modifier to make the change real.


camera different position/view on render

F12 always renders the active camera. If you want to move active camera to current viewport position, press Ctrl+Alt+Numpad 0.

After that, you may want to press Shift+F to fine tune the camera view.


Final:

As far as I know your best shot would be with Curve modifier. It will not be perfectly even though but I don't think it's possible to preserve 1:1 edge length with any modifier.

Steps:

Add Curve > Bezier Curve.
Rotate it 90 degrees on X axis.
Select Plane and add Curve Modifier.
Choose BezierCurve.
Move a Plane on X axis.


If you are talking about user preferences and startup file, you can access your old blender directory:
go to the appdata/roaming folder (type Windows Key+R and then %appdata%) go to the blender foundation folder. Then 2.78 => and open userpref or startup .blend depending on what you want to get in the new version. Then save user prefs (Ctrl+Alt+U and save user prefs) and save the startup file (Ctrl+U)

Or alternatively copy these files into 2.78c\config, but I'm not sure if this will work


Texture showing up in render preview, but not in final render

Strange things happen here, I suppose this is buried somewhere in Color Management or somehow the way Alpha is treated. If you turn off 'Transparent' in the 'Film' Section, the renders become identical.

left: Viewport Render, right: Final Render, with Transparent turned off

The thing is that the ViewPort Render seems to Comp the Alpha against a different Color Value than the Final Render. If you render the image with Transparent Background, and Comp it using an Alpha Over node, you get these results here:

The Split Viewer Node shows you (with a percentage slider) in this setup the raw render on the left, the comped image on the right. The darker you make the background, the more you see the texture. If the background becomes white, the texture disappears. So I have the suspicion the Render View node comps the Alpha values against white background, the Preview render against the checkerboard background.

See these tests of the very same render for comparison:


Why is my half resolution render taking a quarter of the time of the full one?

That is simple math, area doesn't scale linearly, it has a quadratic relation to the dimensions of the shape, if you double the size you quadruple the area hence a four times the render time.

If the area of a $4 \times 4 = 16$ and you halve it then $2 \times 2 = 4$ which is one fourth

Hence you get a quarter of the area and consequently one fourth of pixels to calculate; that's about four times less computation power required leading to roughly one fourth of render time, give or take, for the same scene and settings.


import bpy
bpy.ops.object.text_add()
ob = bpy.context.object
ob.data.body = """Line1 some text
Line2 more text
Line3 more text"""

""" in Python denotes a multiline string. You can also Just use the newline character \n:
ob.data.body = "Line1 some text\nLine2 more text\nLine3 more text"

as well as many other techniques: Pythonic way to create a long multi-line string


Specific selected object won't export to STL while others will

I've figured out the issue. My file -- and example file -- has two 3D-view panels open. Each of these permits layers to be selected as visible or not in the usual way. The main viewport has layers visible for my object (the example tetrahedron). However, a second split window, also set to 3D View, has only other layers selected to be visible -- the layer containing the tetrahedron is NOT set to visible in this other, minimized window.

It turns out that setting the tetrahedron's layer to visible in this second window suffices to make the object export properly. So it appears that the Export code is reading the layer visibility from one viewport (the most-recently-created one?), even if this is not the main viewport.

Here is a clearer example of a situation in which the selected object will not export. Note that the lower window (now not minimized) has a layer not containing the target object selected for visibility.

A hint about this came from an answer to another question (STL empty on export (Python API), answer by Azukikuru) which refers to visibility. Visibility turned out to be the key here.


You can't.

To understand why, it would require dissecting a typical JPEG transfer curve.

The TL;DR is that a typical display referred photograph encoded to sRGB can only encode approximately two and a bit stops over middle grey, where middle grey is mapped to 0.18. 0.18+0.18 is one stop to 0.36, 0.36+0.36 is two stops to 0.72, and 0.72+0.72 is 1.44 for three stops, which the display linear linearization maxes out at 1.0.

Any particular photograph represents well over this dynamic range of course. As a result, the method the camera or software uses to encode the additional stops back into the scene is using a unique and custom transfer curve. Once in the display referred encoded domain however, that original transfer characteristic is lost and unrecoverable.

You can guess, estimate, etc., but it will never be even remotely accurate due to the number of stops compressed into the image and the limited dynamic range of an sRGB transfer curve.

Scene referred imagery is vastly different than display referred, and as such, it is very much a one-way street in terms of data flows.

In addition to this, .HDR is a less reliable storage format for scene referred imagery as compared to .EXR. Avoid it when possible.


Why is my object black in rendered shading mode?

My best guess is that you are not actually in render mode. I just downloaded the exact file you linked, opened it, pressed z and went into render view, and the material was not entirely black, it showed up as below:

What process are you using to go into render mode? It works fine for me with your same file, so I would guess that you are in some other mode of displaying it.


Blender won't import .3ds file despite working in Photoshop

what i think is that its not the issue of blender or max or maya.... the extraction conversation step has resulted in a corrupted file... which however photoshop is able to read(given that photshop is not meant for 3d)...if you have windows 10... try opening it in window 3d viewer and if it is viewable there.. export it in obj format


One option would be to select both vertices you want to connect and press J which will connect vertices and cut through edges along the way, BUT this option sometimes does not take the path you want.

You could also press Ctrl+R (loop cut) to cut through the edges you mentioned between the two vertices, this will though not go all the way to the 2 vertices. Then you can select the vertex you want to connect on one side and connect it with the closest one generated by the loop cut, same for the other side.

Lastly you can use the knife tool K and click on the first and then on the last vertex, in the view like in the picture it might be a bit hard to select the lower vertex though, for that you can start the cut and rotate the view to select the lower vertex.
Press Space or Enter to confirm the cut.

Visual version:


As far as I can see in the picture and the material node provided from creator (which contain some errors in my opinion) the reflection is achieved by simply mixing a glossy shader and a diffuse shader.

The sharpness of the reflection is driven by the "Roughness" value of the shader:

High Roughness value

Low Roughness value


You wouldn't want to sculpt the buttons but instead use a separate object for that. I would probably just create one and the use the array and curve modifier to position them. Repeating objects along a path


How to set absolute bounding box dimensions of a group of selected elements (vertices, edges or faces)

Here is a script that I wrote to accomplish this. It simply calculates the bounding box of the selected vertices, then scales in such a way that the new dimensions become what you set the values to be.

Here is the add-on that was requested in the comments:

https://github.com/ekaj2/MeshTools

To download from GitHub, simply click the green Clone or Download button, then choose "Download ZIP". Once you have the zip downloaded, unzip, then load the .py file with Blender's add-on tool in user preferences.

Here is the add-on that I wrote (I would recommend downloading the add-on from GitHub to ensure you have the latest updates).

# Copyright 2016 Jake Dube
#
# ##### BEGIN GPL LICENSE BLOCK ######
# This file is part of MeshTools.
#
# MeshTools is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# MeshTools is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with MeshTools.  If not, see <http://www.gnu.org/licenses/>.
# ##### END GPL LICENSE BLOCK #####

import bpy
from bpy.types import Panel, Operator, PropertyGroup, Scene
from bpy.utils import register_class, unregister_class
from bpy.props import FloatProperty, PointerProperty

bl_info = {
    "name": "Mesh Tools",
    "author": "Jake Dube",
    "version": (1, 0),
    "blender": (2, 78, 0),
    "location": "View3D > Mesh > Transform > Set Dimensions",
    "description": "Sets dimensions for selected vertices.",
    "category": "Mesh"}

def calc_bounds():
    """Calculates the bounding box for selected vertices. Requires applied scale to work correctly. """
    # for some reason we must change into object mode for the calculations
    mode = bpy.context.object.mode
    bpy.ops.object.mode_set(mode='OBJECT')

    mesh = bpy.context.object.data
    verts = [v for v in mesh.vertices if v.select]

    # [+x, -x, +y, -y, +z, -z]
    v = verts[0].co
    bounds = [v.x, v.x, v.y, v.y, v.z, v.z]

    for v in verts:
        if bounds[0] < v.co.x:
            bounds[0] = v.co.x
        if bounds[1] > v.co.x:
            bounds[1] = v.co.x
        if bounds[2] < v.co.y:
            bounds[2] = v.co.y
        if bounds[3] > v.co.y:
            bounds[3] = v.co.y
        if bounds[4] < v.co.z:
            bounds[4] = v.co.z
        if bounds[5] > v.co.z:
            bounds[5] = v.co.z

    bpy.ops.object.mode_set(mode=mode)

    return bounds

def safe_divide(a, b):
    if b != 0:
        return a / b
    return 1

class SetDimensions(Operator):
    bl_label = "Set Dimensions"
    bl_idname = "view3d.set_dimensions_mt"
    bl_description = "Sets dimensions of selected vertices"
    bl_options = {'REGISTER', 'UNDO'}
    bl_context = "editmode"

    new_x = FloatProperty(name="X", min=0, default=1, unit='LENGTH')
    new_y = FloatProperty(name="Y", min=0, default=1, unit='LENGTH')
    new_z = FloatProperty(name="Z", min=0, default=1, unit='LENGTH')

    def invoke(self, context, event):
        bounds = calc_bounds()
        self.new_x = bounds[0] - bounds[1]
        self.new_y = bounds[2] - bounds[3]
        self.new_z = bounds[4] - bounds[5]
        return {'FINISHED'}

    def execute(self, context):
        bounds = calc_bounds()
        bpy.ops.object.mode_set(mode='EDIT')
        x = safe_divide(self.new_x, (bounds[0] - bounds[1]))
        y = safe_divide(self.new_y, (bounds[2] - bounds[3]))
        z = safe_divide(self.new_z, (bounds[4] - bounds[5]))
        bpy.ops.transform.resize(value=(x, y, z))

        return {'FINISHED'}

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

        box = layout.box()
        box.label("New dimensions:")
        box.prop(self, "new_x")
        box.prop(self, "new_y")
        box.prop(self, "new_z")

def add_button(self, context):
    self.layout.operator(SetDimensions.bl_idname, icon="PLUGIN")

def register():
    register_class(SetDimensions)
    bpy.types.VIEW3D_MT_transform.append(add_button)

def unregister():
    unregister_class(SetDimensions)
    bpy.types.VIEW3D_MT_transform.remove(add_button)

if __name__ == "__main__":
    register()


Vertex Colors are held in 8-bit sRGB format rather than 'raw' (linear) RGB. Therefore, what actually appears to be 0.5 in sRGB space actually refers to a different 'raw' value - hence the need to convert. See How to convert image pixel values from 8bit to 32bit properly? - answered.. but why byte image buffer is stored with non-linear color values? for some related discussion and links.


The first thing I noticed when I looked at your blend document is that the mesh for your shoe is reversed. If you go into edit mode, select all vertices, and select "Recalculate" from the "Shading/UVs" menu, they should face back the right way. You need to do this for the solution to work.

First, add a "MixRGB" node to your material, as well as two "RGB" nodes and a "Fresnel" node. Connect each "RGB" node to one of the inputs of your "MixRGB" node, and attach the "Fresnel" node to the "Fac" input of the "MixRGB" node. The layout should look like this:

Next, connect the "Color" output of the "MixRGB" node to your "Diffuse" shader. Now, whichever "RGB" node you connected to the bottom of the "MixRGB" node becomes the edge color, and the top "RGB" node becomes the inside color. The final material layout should look like this:

To show that this works, I set the outside color to red, and the inside to green, and this is the result:

Of course, for your case, you can set the inside color to a light brown, and the outside to a darker brown. I hope this helped! Happy Blendering!
Cheers,
Graves Broderick


Weird flickering in my model when I rotate the camera and even if it's fixed

This is likely because your mirror modifier is copying and mirroring each side independently without culling one side. Check you mirror modifier options and check bisect then check or un-check flip to choose which side to delete and which side to mirror.

Probably what you did was apply the mirror modifier at some point.


Try selecting the source of emission set your key frames back to 0 (it must be 0 even if your animation starts on key frame 50) and hit alt+a, this should reset the animation or I might have missed the boat entirely, ether way it doesn't hurt to try


Select object that is not rendered.
Go to Properties Editor > Particle System > Render > Show Emitter