How do I change the default blender controls to allow for left click drag/box select? Like in the maya preset controls

Open Blender, go to the splash screen, click on interaction, then on the drop-down menu, press Maya.


In BGE is there a way to apply gravity to the inside of a sphere

To figure out a basic implementation of a "spherical gravity," let's look at how gravity works in normal, Newtonian physics. Here is the equation that you probably learned in high school physics:

$$F_g=\frac{G\cdot m_{\text{earth}}\cdot m_{\text{object}}}{r^2}$$

where $F_g$ is the force on the object due to gravity, $G$ is the gravitational constant, $m_{\text{earth}}$ is the mass of the Earth, $m_{\text{object}}$ is the mass of the object, and $r$ is the distance between the Earth and the object. Since $G$ and $m_{\text{earth}}$ are always the same on earth, we often simplify the equation as follows:

$$F_g=9.81\cdot\frac{m_{\text{object}}}{r^2}$$

The only issue with our formula is that we don't have any direction for our gravity. In normal physics we just assume that it is straight down (if we're getting technical, $9.81$ is a vector quantity that gives us our direction). We can't make this assumption inside of our sphere. To find the direction, we can multiply our gravity by the normalized location of our object (a vector with a length of $1$ pointing directly at our object):

$$F_g=9.81\cdot\frac{m_{\text{object}}}{r^2}\cdot\hat{\mathbf s}$$

where $\hat{\mathbf s}$ is the normalized location vector.

Now that we have a formula to calculate the gravity, we can write a Python script. This script must be run every logic tic on every object that will be affected by gravity, like this:

Script:

import bge

radius = 20
g = 9.81

obj = bge.logic.getCurrentController().owner
loc = obj.worldPosition
len = loc.length

try:
    gravity = loc.normalized() * obj.mass * g / (radius - len) ** 2
except ZeroDivisionError:
    gravity = [0,0,0]

obj.applyForce(gravity)

This will find how far the object is from the origin, then push it away from the origin, using a linear interpolation to vary the force from 0 at the center, and 9.8 at the edge of the sphere (defined as 20).

Here is an basic example .blend file. You can move the sphere with A, S, D, W, Q, and E. It will start motionless in the middle, then become pulled faster and faster as it gets closer to the enclosing sphere. Tapping Spacebar will make the sphere jump towards the origin.


This is a pretty solid tutorial:

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

But all I really did to find it is google Blender Texturing video.

Try looking on BlenderCookie, too.


Your card is no longer supported supported starting with blender 2.67.
Quote from the manual:

  NVIDIA CUDA is supported for GPU rendering with NVIDIA graphics cards. We support graphics cards starting from GTX 4xx (computing capability 2.0).

And even if you made it work, (See this post) that card has only 16 cuda cores. Rendering on CPU is going much faster...


'context' error when trying to bevel an object with Python

You should avoid using ops when possible, see here. As for you code:

import bpy

# generate the cube and make it selected and active:
verts = [(-1.0, -1.0, -1.0), (-1.0, -1.0, 1.0),
    (-1.0, 1.0, -1.0), (-1.0, 1.0, 1.0), (1.0, -1.0, -1.0),
    (1.0, -1.0, 1.0), (1.0, 1.0, -1.0), (1.0, 1.0, 1.0)]

faces = [(0, 1, 3, 2), (2, 3, 7, 6),
        (6, 7, 5, 4), (4, 5, 1, 0),
        (2, 6, 4, 0), (7, 3, 1, 5)]

me = bpy.data.meshes.new('Cube')
ob = bpy.data.objects.new('Cube', me)
bpy.context.scene.objects.link(ob)
ob.select = True
bpy.context.scene.objects.active = ob
me.from_pydata(verts, [], faces)
me.update()

# bevel the cube
bevel_mod = ob.modifiers.new('Bevel', 'BEVEL')
bevel_mod.width = 0.2
bevel_mod.segments = 5
bevel_mod.profile = 0.7
bevel_mod.material = -1
# we use ops here since there is really no other way
bpy.ops.object.modifier_apply(apply_as='DATA', modifier=bevel_mod.name)


Why is my cube projection messed up in one scene but not the other?

Cube projection will project the mesh from 6 view directions ignoring the seams, and depends where the mesh located in 3D space and its rotation, UVs position will be calculated in UV/Image Editor.

  Blender offers several ways of mapping UVs. The simpler projection
  methods use formulas that map 3d space onto 2d space, by interpolating
  the position of points toward a point/axis/plane through a surface.
  The more advanced methods can be used with more complex models, and
  have more specific uses.

UV Mapping a Mesh


Blender 2.83.1 Can't find render bake option in cycles

It took a while before I figured this out. I watched video after video still not knowing how to do it. Until a few days ago I figured it out. I needed to bake a normal map and I still did not have the bake option. Then this popped into my head: "I wonder what happens when I switch it to CPU mode instead of GPU.". After I switched it to CPU I saw the bake option. After about a month I figured it out. They really should add that to the documentation or make it more clear.
TL;DR:
Make sure you use Cycles and use the CPU.


Yes, you can.
When not in camera view,  like this:
For the camera view,  like this:


Why are the drops so large on a water simulation?

You can consider the 'domain' to be made up of a 3-dimensional grid of cells. Each cell is a cube and Blender calculates the properties (density of fluid, motion of fluid, etc.) for each cell.

The Resolution setting indicates how many 'cells' should be included in the simulation - effectively the number of cells along the longest edge of the domain.

So, for a domain in the shape of a cube and with Resolution set to 300 you would have a grid of 300 x 300 x 300 cells - ie, 27 million individual cells!

Most Blender crashes are actually due to running out of memory - when you perform some action (such as setting the Resolution for a fluid simulation, the number of Sub-division Surface divisions, the Remesh detail, or whatever) that results in Blender requesting a considerable chunk of memory that your computer cannot handle - so it either grinds to a halt or crashes blender (or your computer) completely.

Fluid simulations are a trade-off between cell size and number of cells. Obviously you want small cells so as to get a more accurate simulation but you also want to reduce the number of cells to improve efficiency.

In your particular example, it appears that you have a large cube domain - you can see the water running over the 'floor' of the domain. If you don't actually require the water simulation to include the droplets running over the 'floor' then a simple way to reduce the number of cells will be to shrink your domain to include only the waterfall and sufficient space infront and behind to contain any splashes off the model.

As an example, if you reduce the front-to-back dimension to only 20% of the current size then you'll save 80% of the memory requirement for the simulation. The free memory can then be used by upping the resolution further - which should give you better detail for the liquid. An 80% reduction in one dimension will mean you can get almost double resolution in the same memory (510 instead of only 300).

When baking the fluid simulation, the Bake button shows an indication of the memory required. Changing the resolution will affect this value - if it gets too close to your computer's available memory you may want to reconsider before pressing 'Bake'.

Also, make sure your fluid domain is set up correctly for the liquid you are trying to emulate and at the correct scale. For example, set the Fluid World Real World Size to match the domain size (the longest dimension) and set the vicsocity - this will affect how the fluid behaves and how the liquid breaks up into droplets.


Rotating Array Modifier applied to a rotated object issue

Select the smaller cylinder and apply the rotation and scale.

This can also be done by pressing CtrlA followed by O.

The result should be like this.

Then select the empty and rotate it around the Z axis.

N.B. You could also rotate the small cylinder itself around the Z axis, but I prefer doing all transforms on the empty when using one to guide an array.
And the reason why this happens, is that for every duplicate the Array modifier makes, it takes into account the transforms of both the duplicated object and of the empty. I have not read the source code, nor have I found specific information on how it calculates the transforms, but from what it looks like to me, it divides the scale of the empty by the scale of the object.
An example: The object has scale set to 0.333 and the empty has scale set to 2. The overall scale for each repetion would be 2/0.333 = 6, so each duplicate would be 6 times bigger than the previous one.
With rotation and position, it looks like it's just subtracting the position and rotation respectively of the empty from the position and the rotation respectively of the object.


Single track with bundle should be selected to define axis

Longwinded and rambling answer:
The scene has to be solved first.
Then the slected tracker has to be part of the ones used for solving the scene.
A bundled track is one that has a reprojected point.

Bundles makes sense after solving the movie clip, and it works in the following way: the solved position of each track gets projected back to the movie clip and displayed as a small point. The color of the point depends on the distance between the projected coordinate and the original coordinate: if they are close enough, the point is green, otherwise it'll be red. This helps to find tracks which weren't solved nicely and need to be tweaked.

(What does "three tracks with bundles are needed to orient the floor" mean?)
Reprojected points can be viewed as an overlay by enabling Marker Display > 3D markers

A green reprojection dot means that the tracker and reprojection have an acceptable error, a red dot means that the error is too high.

So to set an axis or origin or scale use a tracking point with a green dot.
Then the origin has to be set. To do that then you select a single tracker and that will be the 0, 0, 0 coordinate for the reconstructed scene.
Once you have the origin. Select a second tracker that is in the direction of the axis you want to determine. Then Click on the Set Axis option. The axis is thus determined using the selected tracker and the origin.

Note that you can bypass all of this steps ans manually orient and scale the scene any time you want later.
read: Correct tracked camera orientation


This looks like non-manifold geometry.

Check possible interior faces through Select > All by trait > Interior Faces
Get rid of them through Delete > Faces
Select all and remove double vertices through Mesh > Clean up > Merge by distance, Alt + M

Remove interior faces and double vertices left behind.


How to merge all vertices by distance and remove all inner faces?

First of all if you want to write your own basic scripts you should go to Edit -> Preferences -> Interface and enable "Python Tooltips".

After that you will see pop-up hints with python references for certain buttons, menus and values commands every time you place a mouse cursor over them. Also you can press Ctrl+C (or Cmd+C on mac) when your cursor is over the button and it will copy the python command for that button to the buffer, so you can paste it in your script.

Also you can open up the Info Window in Blender, many commands appear there right after executing and you can copy them from there. Also you can open Console Window in Blender and start typing in commands you know - and use an autocomplete option (shortcuts may be different but you can easily find it).

A little bit of theory before the script. Note that in most cases copying python commands from the buttons will give you a Blender operator starting with bpy.ops. It is not prohibited to use those operators in the scripts, but it is not very stable and may cause errors because all Blender operators rely on context (exact window, screen, area and region from which it is called). There are hints to override a context, here for example. But generally the more efficient way is to use direct access to blender data and change it directly without using the operators. Unfortunately direct editing of the mesh data with Blender API is pretty... let's call it strange and unpredictable (in my opinion). There is bmesh module which has been written specially for this purpose, but I'd say it is pretty complex especially if you are a beginner not recommended. Anyway, if you are not writing a very complex program, using bpy.ops is ok.

According to your algorithm a script may look like this:

import bpy

merge_threshold = 0.05 # here you can define Merge By Distance threshold

if bpy.context.mode != 'OBJECT':
    bpy.ops.object.mode_set(mode='OBJECT')
bpy.ops.object.select_all(action='SELECT')
# This is to make sure that there is an active object in the scene:
#----------------------------------------------
if not bpy.context.active_object.hide_viewport:
    for object in bpy.context.scene.objects:
        if not object.hide_viewport:
            bpy.context.view_layer.objects.active = object
            break
#----------------------------------------------
bpy.ops.object.join()
bpy.ops.object.convert(target='MESH') # Here I've added an option which will
                                      # apply all modifiers by converting object
                                      # to mesh
bpy.ops.object.mode_set(mode='EDIT')
bpy.ops.mesh.select_all(action='SELECT')
bpy.ops.mesh.remove_doubles(threshold = merge_threshold)
bpy.ops.mesh.select_all(action='DESELECT')
bpy.ops.mesh.select_mode(type = 'FACE')
bpy.ops.mesh.select_interior_faces()
bpy.ops.mesh.delete(type='FACE')
bpy.ops.object.mode_set(mode='OBJECT')

UPD. Info Window and Python Console Window can be opened as any other window in Blender:

Toggle System Console in Windows opens up a system console where you can find detailed information about errors, results of your print() functions, etc.


in object mode click shift S and choose 3d cursor to centre


Create an object that emits smoke only from specific faces

Select the top face in Edit Mode and assign it to a Vertex Group

Select the Vertex group in the Smoke Flow Advanced section
Limit the distance of emitting from surface by setting Surface to 0.


Is there a way to mimic the 'inherit rotation' of a bone?

I'm assuming this is an IK chain, because if not the foot will always follow the knee rotation. In IK chains generally this behaviour is obtained by making the knee pole target child of the foot, so that you rotate the foot and the knee rot follows (while you're trying to do the inverse).
If you really need this inversion you can create a bone in the loc of the knee with the same orientation of the foot bone; make it child of the knee bone; set a copy rot constraints on the foot bone following only the rot axis needed (in my example Z axis).


Is it advisable to update Blender to the newest version as soon as possible each time?

Blender is very compatible between versions, both backwards and forwards (with the exception of the upcoming 2.7, which is supposed to have minor compatibility breakage).
For lost configs, Blender should prompt you to use your old config after you start the new version, but if it doesn't it's very easy to transfer (and keep backups, etc.). See this post for details.
The a and b releases are relatively minor bug fix releases usually only released when major bugs are found shortly after the initial release. In spite of being relatively minor releases, you probably want to use them instead of using the previous release (which has some bug bad enough to justify another release).
Conclusion:
It is of course up to you, depending your habits and what works for you, but I highly recommend staying with the latest stable releases. However, expect to find bugs if you use any development versions.
Notes:
Some extra information you may find useful:
Multiple versions:
You can have multiple versions of Blender installed simultaneously, which may be of use if you want to try the new version without removing your current version.
To install another version along side your current version:

Download blender using the archive (*.zip, *.tar.bz2). The archive gives you a completely portable version of Blender which you put and run anywhere (even a USB drive) without any installation.

Extract the archive into some directory (the archive extracts into a new subdirectory).

Run the blender executable located in the extracted directory.

Note that portable Blender will use the config of the system version of Blender (if there is one) by default. If you want to have separate configs, create a directory called config in $directory_from_extracted_archive/2.69/ where 2.69 is the version of Blender you extracted.
Bugs:
If you do find a bug, report it! The developers are usually very responsive (I have had reports fixed within a couple of hours).
Don't assume someone else will report it if you don't (but do check to see if it's already been reported before you report it, just in case).


How to move bones and amature in edit mode altogether?

Parent the mesh to the bones, and then move the bones in pose mode


On the toolbar on the left, you can select a tool, such as the Move tool. right now you have the circle select tool enabled (the one highlighted in blue)


How to bake a generated texture from displace modifier to UVs

I may be wrong but it looks like there's no automatic way to bake the height map of a Displace modifier.
If your object is flat with 3D relief, you can apply the Displace, give it a black and white gradient texture on the Z axis, plug it into an Emission, create a plane above and bake the Emit.
If it's a more complicated object, Ilakya gives here a method to do it, with the Multires and Shrinkwrap modifiers:

Create your model with its Displace modifier.
Create a second object that will contain the model as a sort of cage.
Give this second object a Multires modifier. Give it also a Shrinkwrap modifier, Wrap Method > Project, with the model as Target. Hide the model.
Subdivide the Multires of the second object until it looks like the model. Lower down the Level Viewport down to 0.
Apply the Shrinkwrap modifier.
Give your object a material, create an Image Texture, keep it selected but don't plug it for the moment, create a new image for this Image Texture.
Go into the Render panel, choose Cycles. In the Bake panel enable Bake from Multires and Bake Type > Displacement, click on Bake, it should work.


I guess this is one way to do it:

Delete the top center vertex and extrude out the sides.  Remove Doubles:

Select the horizontal edges only on the faces you just created and Subdivide them twice:

Use Proportional Editing to bring the subdivided loops toward the corner a little more:

Now select the only the edges shown and subdivide those as well.  This will make the odd number of loops that we need to complete the Quad structure on the top and bottom.

Next, create the edges shown below and subdivide the edges once.  Press GG to slide the new vertices toward each other and merge them at the center.  Subdivide the remaining edges twice more (Note: I have a the number keys 1-3 mapped to Vertex, Edge, and Face selection).  You can use the F2 Add-on to make face creation faster:

Continue that process until you get to the end and simply extrude out the remaining vertices to create the final quads:

Repeat the same process above for the top as well.  Since we cheated at the beginning by deleting the center vertex, you can use Proportional Editing to add a little smoother termination.  Hide the geometry below so that it's unaffected:

Here's the final.  It may not be the best way, but it's one way to do it:

EDIT: A quick and dirty way to do it, building on @Marcus' answer, is to take the subdivided cube and make "projections" for X, Y, and Z.  You can then dissolve unnecessary edge loops.  It doesn't really teach much about modeling, but it is does make an eighth of a sphere out of quads:


I cant make an stencil using texture painting

I had the same problem, but then I realized, that my normals where flipped.
So to be able to draw with the stencil method, make shure that the normals of your mesh are oriented the right way (blue) or turn off backface culling in the brush settings (active tool and worspace settings > options > backface culling).


How to turn on the horizontal scroll bar in text editor

You can use the MMB (without the Shift key) to grab and slide the view in the text editor.


How do I "mask" out certain areas of a photo?

Blender's compositor can be used to mix together video and still images. The render output of a 3d scene doesn't have to be used in the compositor, any image or video can be input and placed on top of another using a mix node.

A transform node can move and resize the image. A mask can then be used to cut out part of the image you are adding, box and ellipse mask nodes are available in the compositor, you can also create odd shaped masks in the UV/Image editor which can be animated if you want the mask to move or distort over time.


X access mirror modifier behaving like Z access mirror?

You must apply the transforms, or avoid the rotation in object mode.
See here:
Problem creating mirror in X, Y axes


Is there a way to change the color of keyframes?

There is a way to change the colors of all keyframes. If you go into the user preferences and go to Themes > Dope Sheet then you can change the colors of selected and unselected keyframes.
I could be wrong, but after using Blender for two or three years I have not seen a way to change keyframe colors for individual bones. Would be a nice feature have for sure.


After entering a value for dimensions Blender shows zero

Dimensions are given in local view and your object is rotated around X. A way to see that is to activate the axis display option:

If you want to avoid that, the only way I know is what you stated in the comments: applying the rotation.


Driver "Transform space" option is mixing different rotations

While I'm not sure of the cause, if you clear the rotation of the empty and only rotate it on the x axis the issue stops.


How to select edge rings between two edges?

It may be easier to use another selection tool instead of Edge Ring selection, because it won't take into account specified end of selection.

You can workaround that by selecting faces:

Select the shortest path with Path Selection in Face Select mode.
Switch to Edge Select mode, and deselect top and bottom edge loops by holding Alt+Shift and clicking with LMB on them. "Shortened" edge ring will be the only left selected.


can I use blender render scenes for blender game engine

I guess a lot of the things you already did will work with the BGE.

You might need to tweak materials and settings here and there to get the desired result.

Be aware not all modelling options are available. E.g. particles and curves are not supported by the BGE.

The animation systems are different (Blender is timeline driven while the BGE is event driven). So you will need to add the BGE behavior on that (you can use the actions of the Blender animation).

The Physics systems are different and require a complete different setup.

The Renderers are different (realtime renderer vs. non-realtime renderer) and not compatible, but can result in similar results. Due to the different requirements the BGE renderer will support less features than the Blender renderers. You can bake the output of the Blender renderer into materials and textures which can be presented by the BGE realtime renderer. Be aware not all details can be baked (e.g. reflections).


After two days of searching/tinkering I've found the solution.

First of all, this solution does not save the properties with the .blend file. It will reset all the properties every time you reopen blender.

Step 1: Create the PropertyGroup

So the first step is to create a PropertyGroup holding all the properties you want to store on the console:

class ConsoleProps(bpy.types.PropertyGroup):
    str_prop = bpy.props.StringProperty()
    int_prop = bpy.props.IntegerProperty()

Step 2: Create a Collection Property on the screen.

Because consoles are indeed a part of the screen and not the scene, put a CollectionProperty on Screen.

bpy.types.Screen.consoles = bpy.props.CollectionProperty(type=ConsoleProps)

Step 3: Identify the individual consoles.

At this point you can add a console to the collection but you need some way to identify it. Because I was using it in conjunction with blenders builtin module console_python (sorry, I couldn't find any documentation),
I used the hash of the window region (bpy.context.area.regions[1] is a quick way to get it, not sure if this will ever brake). So at this point you could add a console to the collection like this:

console_id = hash(bpy.context.area.regions[1])
console = bpy.context.screen.consoles.add()
console.name = str(console_id) # Because the name has to be a string.

If you aren't using this along with the console_python module then you could simply use hash(bpy.context.area)

Note that because this is using the hash function it will always return a different value when you reopen blender. This means that any variables you change on the console will get reset to whatever their default values are.
If anyone knows of a way to make this return the same value every time, I'd love to hear about it.

Step 4: UI/Tracking Consoles

At this point all the infrastructure is in place, it's just a matter of actually adding the consoles to the collection. The best way I've found to do this is in the UI (somewhat of a hack). Just setup a basic UI on the console (probably on the header). In the draw function, check to see if the current console is in the collection, if not add it. It may look something like this:

class ConsoleHeader(bpy.types.Header):
    bl_space_type = 'CONSOLE'

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

        # This could be hash(context.area)
        console_id = str(hash(context.area.regions[1]))

        # Make sure this console is in the consoles collection.
        if console_id not in context.screen.consoles:
            console = context.screen.consoles.add()
            console.name = console_id

        # Display the console props, just because.
        layout.prop(context.screen.consoles[console_id], 'str_prop')
        layout.prop(context.screen.consoles[console_id], 'int_prop')

Something interesting about this approach is that you don't even need display anything in the UI. All you need is the draw function which get's called on every console in the layout. So if you don't want a UI, just don't display anything in draw.

Step 5: Cleanup

At this point everything will work (except that you need to register the classes of course) but if you reopen blender multiple times, screen.consoles will contain a lot of consoles that no longer exist. There is an easy way to fix this using bpy.app.handlers:

import bpy
from bpy.app.handlers import persistent

@persistent
def flush_consoles(dummy):
    for screen in bpy.data.screens:
        screen.consoles.clear()
bpy.app.handlers.load_post.append(ftlush_consoles)

This will clear the datablocks every time you open a new file. That way you won't end up with a huge collection of consoles that no longer exist.

Hope this helps anyone else trying to do the same thing. It took me quite a bit of experimenting to get it right. If anyone has any suggestions, please let me know in the comments.


Moving a Keyframe animation in time:
You can move the entire animation sequence from within the Dope Sheet Editor. There you select all keyframes (type "a" on the keyboard once or twice), then for example: G X 30  to shift the animation by 30 frames:

Moving a Constrained Path Animation in time:
This animation type starts at timeframe 0 by default. Within the Constraints panel you can define an Offset to shift the start of the animation:

Open The Object Constraints of the animated Object
Set the Offset to the start timeframe where the Path Animation shall begin (30 in this case)

Moving the Animation time of an Object parented to a Path

This animation type starts at timeframe 0 by default and runs for 100 Frames, then it stops. You can define the animation window by setting 2 keyframes in the Path Animation Panel of the Path:

Select the Path
In the Data Properties locate the Path Animation panel
In the Timeline select the startframe for the animation (30 in this case)
In the Path Animation panel set the Evaluation time to 0.00
Then keyframe the Evaluation time.
In the timeline select the Endframe for the Animation
In the Path Panel set the Evaluation time to 100 (or to whatever value you have set the Frames Attribute right above the Evaluation tmie attribute)
Keyframe the Evaluation time again.


Unknown Issues with Texture Painting? Not Working? 2.8

The 'Normal' Problem here is usually that your Face Normals are pointed inward. To check this in 2.8, switch to Edit Mode and press the overlay icon to find the option to show Face Normals, and correct the direction in Edit Mode before returning to Texture Paint mode.

Happy Painting!!


Select the faces of the mesh you want to seperate. Hit P key in the keyboard. That seperates the mesh from the main object and leave you with 2 object. Tab out of edit mode and you will have side as a different object.


here the answere:

import bpy
import bmesh

index = 0 # here the index you want select please change

obj = bpy.context.object
me = obj.data
bm = bmesh.from_edit_mesh(me)

vertices= [e for e in bm.verts]
oa = bpy.context.active_object

for vert in vertices:
    if vert.index == index:
        vert.select = True
    else:
        vert.select = False

bmesh.update_edit_mesh(me, True)


let's say this cube is the face you made

(step 3 is very important)

1

2

3

4


The problem is that this simulation is to perform in an automated process where human-designed but random assemblies are put through a physics simulation, so it's impossible to fit the correct collision shapes by hand. Fortunately, I have made some progress. The (at least partial) solution was to do a convex decomposition of the mesh, after chopping the entire thing up into manageable blocks.The whole process is this:

split the mesh into its components (mechanical separate parts)
subdivide those components into 3x3x3 blocks
split those blocks up into isolated parts
perform an approximate convex decomposition on those parts.
finally, assemble all the convex hulls into groups that approximate the original components

Although it requires a lot of processing, the results are quite stunning. You can now interactively manipulate one of the more complex assemblies in the set. I haven't tested this on other production models yet, but at least there is some real improvement in the quality of the simulation.


'Snap during transform' not doing anything

The reason why it does not seem to work is that the mouse cursor is not hovering exactly over the vertex which is to snap.

Enable Snap during transform by clicking on the red Magnet symbol or by pressing Shift + Tab.
Choose Vertex as Snap Element
Enable Snap onto itself

*If Snap during transform is disabled you can hold down Ctrl during Translation (G).*

Hover the Mouse cursor over the desired Vertex

Make sure you hover exactly over the Vertex otherwise it won't snap

A little circle will appear on the Vertex

&nbsp

Another possibility to achieve the desired result is to Merge the Vertices

Select the two Vertice by holding down Shift and click RMB
Press W and choose Merge
Choose 'Merge at Last' or 'Merge at First' depending on the selection order


Scale Keyframes Together From "Medium Point"

In the Dope Sheet, the position of the 2D cursor (the blue line) will be the pivot point:

As  atomicbezierslinger says, if you switch to the Graph Editor (CtrlShiftTab) you'll have the choice between Bounding Box Center, 2D Cursor and Individual Centers:

if you want the middle of your selected keyframes to be the pivot point, choose Bounding Box Center:


Unfortunately, you cannot access the history list directly from python (I'm pretty confident this is the case.).

The history list is called by bpy.ops.ed.undo_history() and doesn't have any accessible attributes that you can read into a list. In fact, bpy.ops.ed's methods come from bpy.types where the class  starts with ED_OT_ (eg. bpy.ops.ed.undo() is really an instance of bpy.types.ED_OT_undo()

It looks like the undo stuff is in the guts of blender-app.exe but you can try and mess around with this bpy.ops.ed stuff and see if you can manage something that I may be overlooking.


Adding a vertex onto an angled edge in precise X position

You could subdivide the edge to add a vertex. Select the vertex and press GG to slide the vert. Make sure snapping is set to vertex and then click on the vert shown at 2 units above. This should line up the lower vertex on the angled line with the vertex above

The vertex above could be place at 2 units with snapping set to increment absolute grid.

 Answer above incorrect. New solution:

Ok this one bugged me as it should be possible to do this. I turned on edge length in the overlay

I subdivided the angled edge to create a vert and then GG and dragged the vert to the starting vert on the edge. I am working in m so in the image you can see 0m.

With the vert still selected I dragged it back along the angled edge whilst holding shift to get a more precise value. I moved the vert until it was at 0.5m

Should be able to use this technique for other stuff


How do I solve "Color management: using fallback mode for management"

This is normal but you can make this message go away by building with OpenColorIO. Since it is the default now for color management in Blender, by not using it in your case here, Blender is falling back to an simpler set of color management rules, where float buffers are linearized sRGB buffers, and byte buffers are sRGB nonlinear buffers.

Note that imports after the first will use the cached module so they are not loading the entire Blender state every time. But this means you can't for eg, have 2+ blend files loaded from Python at once. each Python process can only operate on one blend file at a time.


Is it possible to unhide only part of a mesh?

I think you might be interested in the Mask modifier.

This modifier will hide everything except the specified vertex group, or the other way around if you have the invert icon selected. To hide multiple vertex groups, you can add multiple modifiers:

Make sure the modifier is enabled in edit mode (triangle icon).


Blender Python: Convert Enum Flags into String?

It is sometime later after posting this question, and I have learned a lot about how Blender properties work. Here are the nuts and bolts that should answer my older question. Below, instance represents a scene element or property group, and Prop represents any property defined for the instance.

All Blender properties are stored in memory as two different value types - complex and basic. Some properties (like int) are the same type, but are still stored in two locations. Some others (like enum flags) are stored as very different types in each location.
Using syntax instance.Prop (same as getattr(instance,"Prop") or setattr(instance,"Prop",*)) reads and/or writes the property using the complex value types.
Using syntax instance["Prop"] reads and/or writes the property using basic value types.
Assigning either version of the two property value types will instantly and automatically update the other version to the same value of its respective type. You can literally assign a set of strings to the complex version of an enum flags property and, on the very next line, read the basic version of it to convert complex -> basic. Or do the opposite to convert the other way.
Be careful when reading the basic version of any property (syntax instance["Prop"]). It will not be generated for a specific instance (eg, property group) until the property is assigned for the first time (either type version). You can check to see if the basic version of a property has been generated by using if "Prop" in instance: or if "Prop" in instance.keys():. You can also use instance.get("Prop",DEFAULT_BASIC_VALUE) to safely request the basic version without knowing if it has been assigned yet.
The basic version of an enum flags property (instance["MyFlags"]) is stored as an int, which represents all of the binary flag values ORed together. The complex version of an enum flags property (instance.MyFlags) is represented as a set of strings, where each string represents the bit or mask you assigned to it.
To convert an enum flags property into a string, you can literally just convert the complex value into a string: str( instance.MyFlags )


Ruler/Protractor tool - change snapping values for easier snapping to vertices?

If you only want to measure simlpe edges I would use the Mesh Display Tools in the Propertys Panel of 3D View.(Press N to diplay)

First switch to edit mode. Then activate Edge Info>Length:

Then it displays the the length of the selected edge or what else you want in the 3D View.


How to set attributes in a Blender registered class dynamically?

As this relates to Sverchok, but more broadly to bpy's PyNodes interface, i'll chime in with the limited knowledge / experience I have.

No you can not trust that variables/properties added to an instance of a class will "stick" to the class instance. You can also not remove a property at run-time. In this sense Node classes are not like regular Python classes. If you dynamically add a property inside a function it might exist for the duration of a function call, but once execution leaves that function then the variable/property ceases to be associated with the class instance. The evidence that this is the case is what probably triggered the question in the first place.

The only things you can trust are the Properties that are included in the Class definition. I suspect this makes node instances more of a "known quantity" and reduces complexity of the PyNode back-end.

We (sverchok) however do use a not widely documented/explained feature for storing arbitrary data (not bpy.props tho..at least I have not tried..) in a class instance. We call it the node_dict. When used correctly The node_dict (class member) gets a unique key per class instance, and we can pass anything into the value.

def some_random_function():
    ...

class SomeNode(...):
    node_dict = {}

    def sv_init(self):
        node_dict[hash(self)] = {}

    def store_data(self, data):
        storage = node_dict.get(hash(self))
        if storage:
            storage['some_function'] = some_random_function

    def process(self, ..):
        storage = node_dict.get(hash(self))
        if storage and storage.get('some_function'):
            storage['some_function']()  # call it.

This is about as minimal i can go to show some of the mechanism for dynamic data storage. There are examples of defining a node class dynamically (the monad Class relies on it) but it's something that I consider obfuscation and possibly a sign of placing importance on the wrong things.

Of course it would be awesome to have more fine grained control over the parameters of properties at runtime like (name, min, max....dynamic operator tooltip), without needing to dynamically define/register/unregister nodes if you want to change a single property-definition.


Setting object property with a python module's function

No, the module functions in BGE work without returning values, and you can't set property values that way.

The basic structure of a module function in BGE is:

import bge

# cont is a reference to the controller, similar to bge.logic.getCurrentController()
def functionName(cont):
    own = cont.owner

To set property values, you don't need property actuators, just use the syntax:

object["property"] =  value

You said you don't want to use that syntax, but along with actuators, it's the only way to set object properties. You don't need to add the property through Blender interface, just set it through the code and it will automatically be added. Also, it works not only for game objects but for scenes as well, and they can store not only the basic types (int, float, str, bool, etc), but any kind of type and reference (including references to other objects). For example:

object1["target"] = object2

That way, you can access the object2 without needing to search for it, just accessing it through the reference.

object1["target"].worldPosition


where can I get ADDONs for 32 bit blender

This depends on the add-on you are trying to install.
Most add-ons are ‘python code’ only. Python is a programming language that is ‘text only’ and this means that it does not care whether it is running on a 32 or 64 bit system or whether on Windows, Mac or whatever - the code will still run regardless.
Some add-ons, however (such as Animation Nodes or Molecular) include additional libraries to perform some functions. These libraries have to be built for the specific system and it is those that are specific to 32 or 64-bit or Windows, Mac, etc. You need to contact the developer of such an add-on to determine whether a version exists for your particular system.


Why do the particles in my fluid sim move to the left with no added velocity?

After I baked the fluid data it worked fine.


Bevel not working, still got a flat face!

This looks to me like you have double vertices, i.e. several vertices in the same location, making two corners of that face loose. How you got those double vertices I can't say for certain, but most likely a mistake during extrusion. To check, go into edit mode, select that face and move it away slightly to see if something like this happens.

If it does, restore it to how it was before you pulled the face away, by hitting CtrlZ as many times as needed, then select everything by pressing A as many times as needed.

Then for 2.80 hit CtrlV followed by M then B to merge vertices by distance, i.e. merge vertices that are close to each other.
For 2.79 hit CtrlV followed by D (if I remember correctly, some builds used R instead of D), to remove doubles.

You'll need to do this before beveling.

The following should appear in the lower left corner of your Blender window, to let you configure the distance by which to merge vertices. If the dialog is closed, open it be clicking the little arrow to the left of the title "Merge by Distance". Leaving it at the default will likely be fine. This is for 2.80. Unfortunately I don't have a 2.79 install, but a similar dialog should appear if that's the version you're running.


using particle system to cover hollow objects

Although you can give hair a negative length,

it is better to change normal directions

or solidify a tube and choose what faces to generate particles on.


Here is the solution for this baking senario:

Note The result are correct, you will need deep crevices to create really
dark shadows or details. If you need more shadows on your ambient map consider using a 2D image editor like photoshop or Gimp to up the levels.

Change your baking bias from 0.001 to 0.01


The closest thing is to switch to quad view Ctrl-Alt-Q, then Blender displays a grid in front, top and right view (orthographic).


How can i eliminate the edges from this mesh?

Try selecting the desired edges in edit mode using edge select and press the delete key. Select the dissolve edges option and it will delete the edges without affecting the vertices.


Blender Game Engine - Load Scene Similar To Linked

You can use LibLoad(). It merges the data of a blend file into the current scene. So you could switch/add an hard-coded nearly empty scene and dynamically LibLoad() the data from the other blend file. The flexible part is the name of the blend file.


In eevee, shadows are clipped by camera distance

If this is happening with a "Sun" type light, you want to select the "Light" object in the scene, and in its Object Data Properties Panel, adjust the Shadow -> Cascaded Shadow Map -> Max Distance setting.  Even though this appears in the Light's properties, as per the manual, it's related to camera distance:

  Cascaded Shadow Map -> Max Distance.
      Distance away from the view origin (or camera origin if in camera view) to cover by the cascade. If the view far clip distance is lower than Max Distance, the lowest of the two will be used. Only works in perspective view.


I think the easiest way to do this is to bevel a curve object.
Go to Blender Preferences > Add-ons. Type "extra" in the search bar, and activate the Add Curve: Extra Objects add-on by checking the box next to it.

Then in the 3D Viewport press Shift + a, choose Curve > Polygon and set the sides to 6.
In the Properties window, go to Object Data Properties > Bevel, and change the Depth value to give the curve thickness.

Then move and rotate the vertexes in Edit Mode to get the desired result.

If you want the corners to be less sharp and more rounded you can change the handle type of the selected vertices (from the original Vector) to Aligned. You can also use Vector and Aligned vertices together in one curve to get a more precise result.

EDIT:
Alternatively (which I quite stupidly didn't realize before) you can place Spheres to represent the atoms at the corners of the curve. If you would use a Hook modifier the curve would follow the position of the atom object.
Select the curve. Go into Edit Mode. Select a corner Vertex. Press Ctrl + S and choose Cursor to Selected. Go to object mode and Press Shift + A and choose a spherical object like Mesh > UV Sphere. (Press S to scale it down)
Now select the the sphere and Shift select the curve (in that order) so both are selected. Go into Edit model and select the curve vertex and press Ctrl + H and choose Hook to Selected object.

However if you choose to do this, you might want to parent the curve and all its atoms to an empty object, to be able to move the molecule (by moving the empty) without issues. (Add an empty, move it in the center of your molecule, select al the parts of the molecule, Shift select the empty, press Ctrl + P and choose Object(keep Transform). )


Object appearance changes after Scale transformation applied

Object had negative scale. Before applying scale, hit S to rescale it to get positive values or hit N to bring Transform Properties Panel and retype scale there. Object will mirror around it's axis, by the way.


Subdivision surface creates thorn-like artifact/curve (Blender 2.8)

So I solved the issue, but I still don't know what caused it. I selected the whole mesh, and deleted loose. That gave me a face with 6 vertices. Creating an edge by selecting the two middle vertices and pressing f recreated the issue; However, using the knife tool to cut the new face solved the issue. I somebody knows what this means, please let me know. Thanks.


This will give you a dictionary of colors attached to each vertex:

in the form {vertex_index :  [ color(s) ] ,... } .

import bpy

mesh = bpy.context.active_object.data
color_layer = mesh.vertex_colors['Col']

tk = {}
i = 0
for poly in mesh.polygons:
    for idx in poly.loop_indices:
        loop = mesh.loops[idx]
        v = loop.vertex_index
        linked = tk.get(v, [])
        linked.append(color_layer.data[i].color)
        tk[v] = linked
        i += 1

print(tk)

There are nicer ways to write this, using collections.defaultdict. In this example I also import pprint to nicely display the vertex<-->colors dict (tk).

import bpy
from collections import defaultdict

tk = defaultdict(list)

mesh = bpy.context.active_object.data
color_layer = mesh.vertex_colors['Col']

i = 0
for poly in mesh.polygons:
    for idx in poly.loop_indices:
        loop = mesh.loops[idx]
        color = color_layer.data[i].color
        tk[loop.vertex_index].append(color)
        i += 1

# you must cast this as a dict manually like  tk = dict(tk) ,
# if you need it as a dict, but defaultdict will behave mostly the same
import pprint
pprint.pprint(tk)

This will get you as far as being able to average the colors. The output for this Col (for sake of simplicity i use a 9 vertex planar surface)

is

{0: [Color((0.800000011920929, 0.4313725531101227, 0.04313725605607033))],
 1: [Color((0.11372549086809158, 0.800000011920929, 0.0))],
 2: [Color((0.27450981736183167, 0.27843138575553894, 0.27843138575553894))],
 3: [Color((0.7882353067398071, 0.7921568751335144, 0.800000011920929))],
 4: [Color((0.800000011920929, 0.4313725531101227, 0.04313725605607033)),
     Color((0.27450981736183167, 0.27843138575553894, 0.27843138575553894))],
 5: [Color((0.11372549086809158, 0.800000011920929, 0.0)),
     Color((0.7882353067398071, 0.7921568751335144, 0.800000011920929))],
 6: [Color((0.7882353067398071, 0.7921568751335144, 0.800000011920929)),
     Color((0.27450981736183167, 0.27843138575553894, 0.27843138575553894))],
 7: [Color((0.800000011920929, 0.4313725531101227, 0.04313725605607033)),
     Color((0.11372549086809158, 0.800000011920929, 0.0))],
 8: [Color((0.800000011920929, 0.4313725531101227, 0.04313725605607033)),
     Color((0.11372549086809158, 0.800000011920929, 0.0)),
     Color((0.7882353067398071, 0.7921568751335144, 0.800000011920929)),
     Color((0.27450981736183167, 0.27843138575553894, 0.27843138575553894))]}

To complete this, here's an example of how to average a list of colors (naturally, for greyscale colors you only have to concentrate on 1 component as R,G and B should all be the same.

import pprint
from mathutils import Color

cols = tk[8]   # unadulterated color list for that vertex
pprint.pprint(cols)

def avg_col(cols):
    avg_col = Color((0.0, 0.0, 0.0))
    for col in cols:
        avg_col += col/len(cols)
    return avg_col

print('average')
col = avg_col(cols)
print(col)

Now using the defaultdict that represents the vertices and their occurrence in vertex_colors you can average them, or do whatever calculations and create a new dict with a dict comprehension.

import pprint
import bpy

vcol_averages = {k: avg_col(v) for k, v in tk.items()}
pprint.pprint(vcol_averages)

''' outputs, nicely the averages.
{0: Color((0.800000011920929, 0.4313725531101227, 0.04313725605607033)),
 1: Color((0.11372549086809158, 0.800000011920929, 0.0)),
 2: Color((0.27450981736183167, 0.27843138575553894, 0.27843138575553894)),
 3: Color((0.7882353067398071, 0.7921568751335144, 0.800000011920929)),
 4: Color((0.5372549295425415, 0.3549019694328308, 0.16078431904315948)),
 5: Color((0.45098039507865906, 0.7960784435272217, 0.4000000059604645)),
 6: Color((0.5313725471496582, 0.5352941155433655, 0.5392156839370728)),
 7: Color((0.45686274766921997, 0.615686297416687, 0.021568628028035164)),
 8: Color((0.4941176474094391, 0.5754902362823486, 0.2803921699523926))}
'''

From this you might create a list of vertex indices following a threshold test.

vertices_of_interest = [k for k, v in vcol_averages.items() if v.r < 0.5]

pprint.pprint(vertices_of_interest)
# [1, 2, 5, 7, 8]

Selecting vertices, is easy once you get to this point.


Make the eyes bones parented with head bone. Then select the eyes object and set parent to with automatic weights (Ctrl+P). And now if it moves weird you must check that all the rest of the bones are not affecting the eyes in weight paint mode. (sorry for my bad English U_U)


You are very close in your setup. you only need one more mouse look actuator.

The reason why you need another actuator is because you currently have nothing to make the airship rotate along the Y. Adding another mouse look actuator can fix that.

I have also changed the settings slightly from what you had, because I think it behaves better with these values.

The first mouse look actuator does the roll.

The second mouse look actuator does the pitch and yaw.

With both of them together, it behaves just like a flying fortress of total monkey awesomeness

With the actual mesh from the flying fortress only with BGE materials


What is the best way to join two sculpted objects?

You should be able to do this with the Boolean modifier. Add a Boolean modifier to one of the objects you want to join, and set the operation to union. This will join the two meshes into non-overlapping meshes. You can then join the mesh without overlapping, disconnected vertices.


How to make small objects fall properly with rigid body?

Normally, when simulating for the first time after adjustment, the data needs to be cached. It will look more smoother as expected when playing back from then on.

If this is not the case here, then you can adjust the Speed value located in Rigid Body Worlds panel, which lets you control the speed factor for simulation.


How to make an object appear to be buried in sand?

A result like this can be obtained using the particle system (without physics) and vertex weighting in cycles.

Steps

Create a sand surface object and a watch object. You can partially cover the watch in sand. Adding modifiers to the sand to displace with a rough texture can simplify creating this surface. If you render them, you should get something like this:

Add an icosphere to act as a grain of sand. Move it out of the camera view. Add a shader to the grain of sand which changes colors and transparency depending on the particle number. The idea is to use the particle number to set the color and transparency of each sand grain, so the result is varied. The shader is shown below:

Add a particle system to the sand surface. Set physics to 'No'. Set all particles to emit at time 1. The example image was generated with about 250K particles. Since physics isn't used, this runs reasonably fast.

If this is rendered, the results should look something like this, looking like it was dropped on the sand.

To partially cover the watch with sand, use vertex weights. This requires going into 'weight paint' and using the brush to indicate where you want the sand grains to overlay the watch. For the image above, this weight painting was used. The red color indicates where sand grains will be dense and deep blue indicates where the sand will be absent.

Set up the sand particle system on the watch. However, to control where the grains go, use the vertext groups and specify the 'group' vertext group. This will refer to the vertext weights generated in step 4.

Render the image! Since no physics simulation is required, the rendering should occur relatively fast. On a 2 core, 1.5 GHz machine, 4Gb ram, with >250K sand particles, the image rendered in less than a minute.

Download the blend file here:


Boolean difference modifier not working on a custom mesh

(Assuming Blender 2.80)
The anvil has a defect geometry. To fix this, select the anvil, go edit mode.
Then "Merge Vertice->By Distance" and leave Edit mode. Then it looks like this:

PS: I switched the cylinder into "Wire" display...


How to bake floating geometry to normal map?

So here is what’s happening. Let say you have object A (the highpoly object you need to bake) and object B (the lowpoly, the object on which you want to use the bake)

The bake is a kind of scan that begins from the faces and goes in the opposite direction of their normals, it goes as long as necessary, until it hits the surface of the object that needs to be baked. That’s the basis of baking (as I understand it). So here is what happens for the top face: With a Ray Distance of 0 the scan begins from the top face, it goes downwards and hit nothing, so no baking.

If some faces of object A go a bit beyond the surface of object B, you need to make the scan begin a bit before with the help of the Ray Distance value. It’s the case here, object A is out of object B, so you need to have a Ray Distance value higher than 0, in your file your value was a bit low, so it didn’t scan the whole object A, you need to increase the value a bit, 0.2 seems good.

The bottom face of your object B scanned in the opposite direction of its normal as it is supposed to do, so it scanned upwards until it hit object A. But in this direction it hits faces that are flipped, so the scan gave incorrect colors.

I suppose you didn't expect the bottom face to have any baking. In that case the simplest solutions are either to paint your normal map with purple, or to close the bottom of your object A with a face so that the object won't be scanned by the object B bottom face (only slopes can be scanned, not surfaces that are parallel or perpendicular to the scan direction).


Smooth shading not smoothing everything as expected


On Windows you can toggle the console windows using the Menu: Window / Toggle System Console

Documentation


PyNodes do not make it possible to extend Blender Internal, Cycles or the compositor with new nodes.

They are designed to make user interfaces for new node systems. For example developers of external render engines can use them to make their own shader node systems, or an addon could make a new geometry node system.

It would of course be very useful if they did, but that would be a much bigger project, as it requires each node system to expose an API with access to its inner workings. For Cycles the closest you can get is Open Shading Language nodes.


Plot graphs and play animation with bpy or bge

What you use will depend on what result you want to have.

You would most likely use the game engine if you want to watch your animation in real-time as the data is collected.

You would use a render engine (whether that is BI, Cycles, Luxrender...) if you want to capture the data then render the animation and watch the video you made hours or days after you captured the data. You can also do this in two stages, capture the data to file and then use that data to create the animation in blender. This options also gives you the flexibility to clean up or enhance the animation before you render the final video.

It is also possible to combine real-time viewing with an after the fact video. To do this you would have your script moving items in the 3dview as it is recording the animation for later rendering. Note that recording the animation for later adds some overhead that may slow down your "live" playback depending on the scene complexity.

This answer provides an example of collecting data from an external process without blocking blender. I expect it can be adapted for use in either scenario.


I am afraid this is a limitation and you cannot interactively draw with bgl outside of modal operator. There is no way to initialize the drawing handler because it needs the modal operator for access to events and the modal loop where tag redraw would happen.

Tag redraw could be done but the events are the bummer. Linking similar: Get events without running modal

From blender api user events outside of modal can't be caught. There is probably a possibility to catch them with python in monitor space and from blender areas and window positions get them local (like mouse coords).

From user perspective how blender is made it seems the philosophy is that user should have control over modal operators and start/end them manually ideally with button in ui. So something doesn't run in the background without your knowledge. There is somewhere an answer from Brecht on something similar but couln't find it.

There is possibility to call an operator from handlers, but mostly you will get another limitation:

 "RuntimeError: maximum recursion depth exceeded"

Calling the operator from load_pre handler should be fine though. See similar: My custom timer is cancelled when loading a *.blend file


How to co-simulate between Blender and a system modeling tool?

Blender 2.8 can co-simulate with simulation tools that generate FMUs (see https://fmi-standard.org/ ) using the FMPY library. Most versions of Modelica will create FMUs. A complete list of simulation tools that create FMUs is found at https://fmi-standard.org/tools/ .
Installation
To co-simulate with an FMU, the library FMPY (https://github.com/CATIA-Systems/FMPy ) should be installed. This procedure will work on Blender 2.8 and later.

Using the python version with Blender, at the command prompt enter 'python -m pip -install FMPY'
Is FMPY installs successfully, the final message should say something like 'Successfully installed ...'
Verify installation by opening Blender and typing 'import fmpy' into the console. If it successfully imports, then the library was installed.
Verify an FMU can be imported by downloading an FMU and loading.
Download 'rectifier.fmu' from https://github.com/modelica/fmi-cross-check/blob/master/fmus/2.0/cs/win32/Dymola/2019FD01/Rectifier/Rectifier.fmu
Enter the following python commands:

from fmpy import *
fmu = 'path-to-fmu\\rectifier.fmu'
dump(fmu)

If a summary of the fmu prints out, then the module is working an able to import fmu's.

Usage
To co-simulate, a python script can be used with animation nodes to initialize and co-simulate. The fmu_simulate command can be used to set the state,set inputs, step in time, and get the outputs and new state. See https://github.com/CATIA-Systems/FMPy/blob/master/fmpy/examples/coupled_clutches.py for an example of this command.


Shortcut for centering the 3D-cursor in a view

There is a menu for that: "Center view to cursor"

But no predefined shortcut. You can assign the one you want with a right click on the menu (or add it to the quick favorites):

But that won't move it the view center is locked to 3d cursor's location:


Indirect Control

I suggest to first exchange the keyboard sensors by message sensors. You do not even need to change your car controlling code.

to

To make it working, you now need a "user input provider" (other object) to send the new messages.

Note: the True Level Triggering. This is necessary to continuous send the messages as long as the key is held.

Now your game should act as it did before

File input

Now you can add a request provider that does not listen to the keyboard, but reads a file and sends according messages with the right timing. Be aware this is a continuous process. You should send a message (of on subject) just once per frame.

You need to process file operations via Python. How to do that is a different topic.


It could be a CtrlShiftB, 1-segment Vertex Bevel:

You can adjust to precision in the operator's F9 Adjust Last Operation panel.
Thanks to @John Eason for the reminder.. While modelling, always have your object's Scale CtrlA applied to (1,1,1) for predictable results from operations and modifiers.
Edit: The shipped add-on 'TinyCAD' can find the projected intersections between lines, and insert vertices at the closest approach. If you have a lot of that to do, you could set up shortcuts for that.
Without add-ons, this could be a way? There's probably a better one..

With Snap set.. 'To: Vertex' and 'With: Active'

K cut an arbitrary edge, to insert vertices
ShiftD duplicate the vertices of the template edge.
GX with and GY, switching active vertices, snap to the target corner, one dimension at a time
Snap the pre-cut vertices to the duplicate, and M > 'By Distance' merge everything down.


Update:

The original method did not work due to a limitation of blender's interaction with the Carve library (used for boolean operations). Here is an updated technique.

Example file

You can do this using Boolean modifiers:

Add a cylinder and a cube, then move the cube 1 BU on the X and -1 on the Y. With the cube selected, enter edit node and delete one edge:

Then select one of the remaining two face and press P> Selection:

With the 3D cursor in the middle, select each cubeface/plane object and press CtrlShiftAltC to snap the object origin to the 3D cursor:

Add a Union boolean modifier to plane 1 (it doesn't matter which plane is plane 1 and which is plane 2, but once you decide you shouldn't switch) and select plane 2 as the target object:

Add a Difference boolean modifier to the cylinder and select plane 1 as the target object:

Optionally add an Edge Split modifier to get rid of the dark shadows (only visible when the mesh is smooth shaded) caused by the poor topology produced by the boolean operation.
Insert Rotation keyframes (I> Rotation) to animate the rotation of either plane:

For example:

On frame 1 with one plane selected insert a rotation keyframe (I> Rotation)
Go to a later frame and rotate 360° on the Z (RZ360)
Insert another rotation keyframe (I> Rotation)


Is there a Snap option in the Graph Editor?

Ok so Mr Zak suggested me the best method to do it:

Select the vertice #1 which is the Y position reference.
ctrl G to make the cursor move to the vertice position.
Select the 2D Cursor as the Pivot Point.
Select all the vertices you want to snap to the Y position.
Scale down to zero with S Y 0

and a quite similar way:

Select the vertice #1, which is your Y reference, ctrl G to move your green cursor up to this vertice.
Select the vertices you want to align on the same Y position
shift S > Cursor Value, and again shift S > Flatten Handles, if necessary.


How to change the rotation of an already existing animation?

Graph Editor is what You need to use in this situation. You can edit frames values one by one, all together or even add a modifier, that will create a move, that you want.


Why does this happen every time I unwrap my textures?

Make sure in your textures tab , The uv co - ordinates are set to UV

Make sure to UV unwarp your model before texturing!


Cutting a circular hole in a hollow cylinder without distorting the cylinder

you could use the Knife projection (in front mode of the circle )

select your cylinder and your circle  go into edit mode of your cylinder
and click while you are in Edit mode  in the T-panel on Knife Project


How to set the origin of sub-meshes without it affecting the armature?

Place the model and armature in the center of the scene with both origins at 0,0,0. Then you won't have to re-set origins every time but scaling the model and applying the scale will always affect rigging. There is no way around it except scaling rig to which the model is parented, you probably want to avoid it though, if you want to export model with animations to some other environment, like Unity or Unreal. The best solution to this problem would be to rig the model after all mesh changes are finished.


Is a render farm suitable for using high-res stills?

That will depend on the render farm you plan to use. Normally a render will generate a complete image which means animations can easily take advantage of multiple computers as each computer can render a single frame from the animation.

It is possible to cut up a single render into multiple pieces that can later be stitched together into a larger image, this will allow multiple computers to work on the same larger final image. Blender's render border option can be used with a python script like in this answer, it is possible to use imagemagick to automatically stitch the pieces into one image.

Some commercial render farms include an option to do this, Render.st is one example. If you are creating a personal render farm then chances are you will need to add this ability yourself.


How do I programmatically set hair position and shape in Blender 2.8?

Halfway there now…

Following this answer for manipulating particles, and shoehorning this problem with the same approach led to the following:

Viewport: OK! :D
Render preview: OK! :D
Final render: Not OK... :(

Code:

import bpy

# 1. Use initial cube as object and set CYCLES
bpy.context.scene.render.engine = 'CYCLES'
obj = bpy.data.objects["Cube"]

# 2. Add a particle system
psys = obj.modifiers.new("hair", 'PARTICLE_SYSTEM').particle_system
psys.settings.type = 'HAIR'
obj.show_instancer_for_render = False
obj.show_instancer_for_viewport = False
psys.settings.use_strand_primitive = True
psys.settings.radius_scale = 0.2
psys.settings.hair_step = 3
psys.settings.count = 5

# 2½. Animation options
psys.settings.frame_start = 1
psys.settings.frame_end = 1
psys.settings.lifetime = 1000

# 3. Setup frame_change_post-callback
depsgraph = bpy.context.evaluated_depsgraph_get()           # Get depsgraph

# Define particle setter. Set at every frame update(?)
def particleSetter(self):
    particle_systems = obj.evaluated_get(depsgraph).particle_systems

    for m, particle in enumerate(particle_systems[0].particles):
        setattr(particle, "location", (m, 0, 0))
        for n in range(len(particle.hair_keys)):
            setattr(particle.hair_keys[n], "co", (m, 0, n))

    # Toggle back and forth to update viewport
    bpy.ops.particle.particle_edit_toggle()
    bpy.ops.particle.particle_edit_toggle()

# Clear the post frame handler
bpy.app.handlers.frame_change_post.clear()

# Register our particleSetter with the post frame handler
bpy.app.handlers.frame_change_post.append(particleSetter)

# Trigger frame update
bpy.context.scene.frame_current = 0


Is there a way to control Blender's GUI remotely?

The latest version of MobaXterm works great with Blender! I just had to check the "Hardware OpenGL acceleration" in order to make it work (under "Settings" --> "Configuration" --> "X11" tab.

I started a SSH connection with compression enabled in order to lower bandwidth usage and started Blender which now works correctly.

I am running the latest free version of MobaXterm from http://mobaxterm.mobatek.net and my Windows computer has a nVidia Geforce GT640 with the latest nVidia drivers.

I hope this helps!


How to keep texture mapping after applying modifiers

One way to handle this is to use UV Mapping right from the start.  For this, you can press Numpad_7 for top view.   Now if you press Numpad_4 several times, the view will rotate along the z-axis.  Once the positioning matches the texture orientation press Numpad_5 to set the view to Orthographic.  Now press u and select "Project From View (Bounds)"
You could just use Unwrap or Reset but there is no guarantee that you will have the mapping aligned to the texture's direction.  If it's not then you'd have to rotate the UV's and/or scale by -1.0 along one of the axis(that can be confusing, it's best to avoid).

Now you should be able to apply the modifiers and have the following result.


Placing spheres in a perfect circle on a ring

Add a single sphere, and a curve to the scene (a Bezier Circle should do). Reduce the size of the sphere down to about 0.1 depending on the scale of the scene you're in.

Next, add an array modifier to the sphere and bump up the counts to about 10 or so you can see something. Finally add a curve modifier to the array of spheres. The spheres should follow the curve and you can now increase the array count depending on the scale of the sphere until both ends meet.

End result:

NB: If after doing this, the spheres don't connect at both ends evenly, just select the sphere in object mode and scale it slightly until they meet. You can also hold Shift while scaling for more precision.

An alternative (but more cumbersome) way is to use dupliframes, see How can I duplicate a mesh along a curve?


Problem with imported SVG - cannot convert curves to mesh properly

There is a hidden extra vertex in your curve object that confuses curve behavior.
The vertex is located on the left from the top right vertex in the S, marked with the green square in the picture. It is actually selected (and should look white) but because it is behind another vertex you can't see it.
Click on the location twice, so you won't see a white selection (but in the bottom right corner it still says: "Vert 1/414") Then press X or Del and choose Dissolve Vertices. This should resolve your issue.


Your problem is not neccesarily related to Blender. Just because it's the only thing you used doesn't mean it's the only thing that happened on your PC. Yestarday I had 30GB of free space on C and after only using Blender it went down to 7GB. Well actually turns out Windows downloaded update files in the background.

The first thing I would do in your place (and did today to my PC) is run disk clean up:

It will scan your PC for any temporary old files that could be taking up space and let you choose to remove them.
If that doesn't solve your issue than your best bet is to just go over your C Drive manually and cleanit up your self, remove any unwanted files etc.

Remember that your Desktop and any files in the recycling bin are also a part of your C drive, so if you're saving a lot of things on your desktop it could be taking up a good amount of space.

I reccomend WinDirStat for browsing your drives and doing manual clean up, it will make it a lot easier to identify areas with large files or folders that take up a lot of space.


Nate suggested that you change the Auto Smooth value but in your file, this value panel is greyed out. This is because you have Custom Split Normals on your mesh.

Hit the Clear Custom Split Normals Data button and then try reducing the Auto Smooth Angle to something like 12 to 15 and that hopefully will clear your AO artifacts problem.

Edited to propose a different "solution"

I have no idea why but when moving the mesh and its origin to the World Origin a lot of the problem disappears! Perhaps someone can explain why?

After separating (P) a small part of the original model (less taxing on my PC) and moving it along with its origin to the World Origin most of the shading (shadowing) issues just disappeared:

Next some Vertex Smoothing to smooth out some of the sharper edges:

And finally with the auto smooth option unchecked:


You can use Object ID Keys to store intial location.


How to turn off computer after rendering?

The Alarm and Shutdown add-on can be used.

Alternatively, you can render your scene from the command line, and then add a command to shutdown after it completes (or fails).

On Windows this would be something like:

"C:\path\to\blender.exe" -b "C:\path\to\your file.blend" -a && shutdown -t 0 -s -f


What you can see are the relation lines, not the bones. For some reason your bones are so tiny, you can't see them. Select the armature, go to edit mode, select Individual Origins for Pivot point, then hit "a" to select everything. (If you selected everything the Gizmo must be appear in the middle of the skeleton). Then hit "s" to scale and type in a big number (500,000). Then hit enter or left click and go back to pose mode.


How to calculate specific liquid volume?

You could use a cube, to scale it that it has a volume of 500ml, calculate the 3rd root of 500 ~ 7.93 (this should be the edge-length) scale the cube to this size.
For a bottle you might want to model a funnel.

For the fluid simulation setup:

Set the cube as fluid
The vessel as obstacle
The funnel as obstacle

For all set the Rigid Body Collisions shape as Mesh.

Add a domain object as domain
Set the rigid body types to passive otherwise they will fall down.
Increase the resolution to ~90 (more would be better but extremely time consuming)
Bake the fluid sim.

After filling your vessel you can use the methods on exact measure as described here:
How to model effectively using exact measurements?.

Instead of pasting all settings I uploaded the .blend here


FBX model from makehuman has broken rig on import

The current semi-official MakeHuman advice is to not use FBX in the first place, when the end goal is Blender.

MakeHuman has two alternative pipelines that directly target Blender, each of which is more likely to work than when going via FBX.

The traditional one is MHX2. This is a tried and stable approach, which has been in use for many years, and which should work with most blender versions, including 2.80. See https://bitbucket.org/Diffeomorphic/mhx2-makehuman-exchange/overview
The new approach is available starting with MakeHuman 1.2.0 alpha 1, and allows fetching a rigged mesh directly from a running makehuman instance without having to go via a file export. This works in blender 2.79 and 2.80. See https://www.youtube.com/watch?v=tAwfR-G813g

If you want to stick with FBX anyway, you could try the latest alpha of makehuman, see http://www.makehumancommunity.org/content/downloads.html. There are known issues with rigging in this version too though, but it's possible it might work better as parts of the routine has been rewritten.


Bone Constraint/ Location rotation issue

Switch your Pivot Point setting from 3D Cursor to Median Point.


Why when I render my 200 frame animation everything is the world color and not the animation?

be sure that all  layers that contains your objects are selected in the render_layer tab"


Why is this object reflective only in Blender?

Try converting your Normal Map using the method below, as opposed to using RGB Curves. As far as I know, this is the preferred method to do DX to OpenGL conversion. If it doesn't work, let me know and I'll delete this answer:


Simple glossy balls in Blender internal renderer

I think you should simply find a better balance between the "mirror" and the "specular" function of the material, as picture 1.

If you really want to fake the reflections, you could render the previous scene, then render only balls, lights and white reflective plane over a transparent background, unchecking the "traceable" option of the material (this will delete the cross reflection between balls, but shadows also will disappear); then composite the two images: floor and shadows from the first render, balls with no cross-reflections from the second (you will miss the shadows of balls over others balls).
This method works also for animation movies.


Assuming you're using Eevee:

Per my comment, I think the problem is that your PNG's alpha channel (the second output in your Texture Input node) is not being used to do anything, and Toon BSDF interprets the fully Transparent pixels as black by default. Because of this, I get the same problem with this image of mine, where everything Black is actually Transparent (pixels with alpha=0):

We can fix this by setting Material->Blend Mode to Alpha clip (this assumes you have already set Context->Render Engine->Eevee), Context->Film->Transparent, and using a slightly more complicated shader, which uses our PNG's alpha channel to explicitly control the mix factor between a Transparent BSDF and the color information in our Toon BSDF:

Note that the math node could also be deleted if you switched the order of the inputs to the Mix Shader node.


Will add-ons from Blender 2.79 work or be compatible with Blender 2.8?

No, most 2.7# addons will not be compatible with 2.8# versions of Blender, and will require explicit porting and updating.

The Python API has changed in ways that break compatibility. It has been improved and expanded to allow further integration, more features, and better workflows and these would make old addons not work in newer versions.

There is a Blender Wiki article documenting the new Python API changes and explaining how to port old addons.


How can i create the shader of the virus?

Actually, maybe you should try Subsurface Scattering at the end of your node organization, it will give translucency and it will take your volume into account:


How to properly export into .obj and .mtl file

Are you having trouble exporting in general, or exporting that specific material?

In general with Blender, the .mtl export settings are in the .obj exporter. Check the Write Materials box to have Blender generate an .mtl with your .obj.


Why is my high-poly mesh bake result poor?

Your object is very small in your scene, so with an Extrusion of 0.5 it will miss the bake, bring back this value to 0, give a Ray Distance of 0.0001 and it will work.


How to make hollow object with only surface into solid?

It seems to me that you didn't finish the outline before you spun the model, so now you have three options. See the blender documentation for the Spin function.

You can modify your outline to have a top and bottom and re-spin it.
Select Edge Ring and press F to make a face.

2.1 Press Alt+P to Poke the face, thus making a triangle fan.
You can use Grid Fill or from the Ctrl+F menu.


It's definitely related to the modifiers, or clumping.
One option is to apply the modifiers, which seems to ground the rocks.  You might not want to do that.
The other thing seems to be Clumping.  If you set it to a positive value it seems to not float, but I think the clumping just pulls together the particles in space without regards to the modifier stack of the surface they're sitting on, unfortunately.  The only thing I could figure out that doesn't break the clumping was applying the subsurf and displace.


How to get rid of hair root location artifact

Enter the Particle Edit Mode.

Change the Particle select and display mode to Point select mode.

Uncheck the Lenghts and Root boxes in Options panel, then select all the hair particles with border select tool (B) and move them closer to the sphere (G).

Here is the result.


How can I apply some kind of pattern on a mesh?

It's not clear if the shape itself is made of this repetitive pattern or if it's a round shape with an added line on its surface.
In the second case you can use the method I describe, except keep only the lines and create another object, a subdivided cylinder that will be deformed with the same Mesh Deform modifier, so that both the 2 objects, lines and cylinder, have the exact same shape.
In the first case, you could begin with a 16 vertex circle, keep only 7 of its vertices, duplicate, flip:

Extrude, flip, bevel:

Array along the X and the Z:

Use the Simple Deform modifier (Bend mode) to bend along the Z axis:

Use the Mesh Deform modifier to shape it:


Pros and Cons of different-geometry variants of a character model

Regarding point 2.

It helps to know what is the center of focus and pick your battles.  More close view inspection may require more finesse.
Intersecting geometry is not necessarily an issue.  If you do not create excessive geometry.
If the area is not subject to intense scrutiny then no one will observe the minimized discontinuity of the clip-on curls .. I mean ummm ...embellishment.
Clearly game development would use textures and normal maps to simulate geometry and the audience does not protest very much


No reference images of my daughters face for modeling

Blender 2.8 changed a few things up, like with this instance. On the add object menu (Shift+A) there is an option called 'Image' where you can insert reference pictures and move them around the planes like you would with Blender 2.79's referencing feature. Just make sure you're in orthographic mode when you do this so that your model appears the same size as the photo.


How to pause/continue a FluidSim without Stopping the Simulation?

This is hilariously late, but you can hover the mouse over the render button in the outliner (looks like a camera) and keyframe this to be off whenever the the unwanted domain box appears. Hope this could help someone with the same problem at least.


How to write all characters in a font to a 3D text object?

Well, it depends on what "all characters" are, but generally you should be able to just loop over a range of code points or character values, casting with chr.

For example, if you want all printable ASCII characters:

text_string = ''.join([chr(i) for i in range(32, 127)])
bpy.ops.font.text_insert(text=text_string)
# [SPACE]!"#$%&\'()*+,-./0123456789:;<=>?@ABC...XYZ[\]^_`abc...xyz{|}~

Here, I just used a list comprehension to go from ASCII 32 to ASCII 126, inclusive. You could use a different range to suit your needs.

You can't really "separate characters by languages" because it's not bijective. Which language does A belong to? Practically every language that uses a Latin-variant alphabet. How about ü? Spanish, German, to name two.

You could separate characters by their Unicode blocks, like Basic Latin (U+0000 to U+007F), Latin-1 Supplement (U+0080 to U+00FF, contains stuff like ¢, ©, §, õ, þ, etc.), etc.

For example, if you wanted two separate text objects:

blocks = { 'basic_latin' : (0x20, 0x7E), 'latin-1-supp': (0xA0, 0xFF) }
for k, v in blocks.items():
    t = ''.join([chr(i) for i in range(v[0], v[1] + 1)])
    bpy.ops.font.text_insert(text=t)


Duplication along curve with Mirror modifier

Instead of using the duplicate method post din your questions you can use an array modifier and a curve modifier.

1. Add Curve

Add -> Curve -> Bezier
move it (in my case I moved it along the positive x-axis)
Place the origin at the start of the curve path

select curve -> edit mode -> Select start point -> Shift S Cursor to selected -> Object Mode -> Ctrl Alt Shift C -> Origin to 3d cursor

2.

Add a plane at the same location
Scale it down

edit mode -> S

Apply Location: Ctrl A Location

3.

Select plane, add array modifier
Fit Type: Fit Curve
Relative Offset modify to move in the direction of the curve

4.

Add Curve modifier to plane

5.

Add mirror modifier

image description http://www.pasteall.org/pic/show.php?id=67294


This is because you are using Cycles.
Texture baking is currently only supported in Blender internal.
This feature is currently under development, you can see some tests in the bf-cycles mailing list.
Update:
As of Blender 2.71, Cycles now supports texture baking.  To bake a texture:

UV Unwrap the model

Add a blank image texture in the UV/image editor

Add a texture node to your material and select the newly created image

Ensure that the texture node is selected

Press Bake under Properties panel > Render tab > Bake.

Also see:

How do I bake a texture using Cycles bake

Andrew Price's tutorial on cycles baking.


Creating an eye/eyelid rig for dragon without shape keys

Concerning the eye movement, you can use a UVWarp modifier to your eye.

The principle is to set two objects (empties) to shift the position of the UV map of the eye.
Moving (or inserting key frames) one empty will shift the UV map to obtain the result.

Here is a closer view of the modifier :

Edit :
Concerning the eyelid animation, if you set the bone origine at the same position your 3D cursor is (as you said you can rotate it manually), that may work.

Another edit : a rigged version of the eye animation.

The principle is simply to add a "Bone" and define a group named "Bone" for the Iris circle. That allow to play on the position and X-scale of the iris.

The Bone group is the iris / center UVs in the image below :


I'm having trouble trying to understand the topology & model this shape

To me it looks like something like that:


Is there a better way to make paths? Working on a string for longbow

Longbow - a rudimentary example:

The bow and string are both initially shaped using a straight Nurbs Path bevelled with their respective curve circle.

That Bow only is then converted to mesh with ALT-C.  This leaves the bow as a hard meshed cylinder with plenty of cross section subdivisions with which to flex it when the string is drawn back.

The string is left as a straight Nurbs path with an even number of control points each side of it's center one.  These are used to keep the string straight as the center is drawn back.
The outside two are used to stretch and relocate the ends to match them with the bow's ends.

Animation -

When the string is formed initially,

Give it as many control-point pairs as felt necessary. These are placed equidistant and outwards from the center.   This example was given 6. (3 pairs plus the single one at the center)

Hook-empties are added to control each pair of control points (location only) back along it's length
Another Hook is added to control the center one.

NOTE - Hooks are only moved along the axis perpendicular to the string.

At frame 1, keyframe the LOCATION ONLY for all hooks.  The outer Hook needs a keyframe for it's scale also.

Move the timeline cursor to frame 15 (?).

Pull the center Hook back so the center of the string is where it's required at the full drawn-back location.

Pull the other Hooks back to shape the string as a straight Vee.

The outer pair Hook is drawn back also and to where the Bow's ends are to be flexed. Scale it along the string's axis to stretch them as necessary. (all can be fine tuned later)

Keyframe all 4 Hooks.

Run the animation, see that it looks ok.

-================-

With the string animated, (more or less) it's time to take the timeline back to frame 1 and rig the Bow mesh.

Bones are placed along the Bow's length as shown, rigged so we can flex it's ends by rotating the end bones. (the inner bones too if felt necessary)

Go to frame 15 and position the bow's ends and the string's outer Hook to bring them together.

Keyframe the string's Outer Hook again, (location and scaling) then keyframe the bone rig - rotation only.  Don't keyframe it's location.  If you do, delete those in the Dopesheet.

Play the animation, readjust as necessary.

When all is ok, the launch sequence keyframes can be added...

Move the timeline forward enough frames from the draw-back to hold that pose for about a second or less,
keyframe everything again.  (duplicate the draw-back frames in the dope-sheet (SH-D) and slide them forward to the timeline cursor)

At  2 or 3 frames on from there, duplicate the bow's and string's frame 1 keyframes, drag those to the timeline cursor.

Try it out, see if it looks right, albeit a little mechanical.

To make the string appear normal, it should oscillate forward and back a couple of times after it reaches the at-rest frame.  Add these keyframes after the launch.

An arrow can be added at frame 1, and keyframed to follow the string's center as it's drawn back and again to follow the string during the launch. Another is added (with linear interpolation) to continue it on it's way at the same speed.

-===================-

To enable the entire thing to be used elsewhere -

Parent the Arrow, Hooks, Bow, and String, to the Main Bone.

Move/Rotate/Scale the assembly by the Main Bone only.

When appending to a new scene, all individual components will need to be included. (reinstate their selection arrows in the Outliner if necessary)

-================-

The bow and animation can be appended into any scene, relocated etc. It's animation keyframes will go with it and these can be slid forward in the dopesheet to be launched at any frame and as often as required by duplication, again in the Dopesheet.

HINT - At the bottom of the Dopesheet window, click on the ghost icon and the arrow icon next to it.  This will limit the keyframe display to only those objects selected in the 3D window.


If you are "lost in space" you can press the Home button to view all objects in your scene, or select an object in the outliner and press Numpad "." to view active object. Also check the clip values in the "N" properties panel: in my example all objects closer than 1 cm or far more than 1 km will be greyed out, and you can change thoose values.


Materials show up in material preview but not in render preview

Pink usually means that image texture path is lost (it requires re-linking). It might also be caused by wrong or missing Texture Coordinates mapping (material nodes)...


You can access the compositing node tree via:

bpy.context.scene.node_tree

And your RGB node this way:

bpy.context.scene.node_tree.nodes['RGB']

As for why the tooltip shows a data path that you can't really access?

Don't really know, might be a bug.


Setting vertex color with ob.data.vertex_colors["Col"].data[0].color stores values wrong

Vertex colours are stored as 8-bit sRGB values. This means that they have a maximum precision of 1/256, but the raw values are also further distorted by the sRGB colourspace translation.


In the viewport I see the back part of the model instead of the front

[FIX as of jan 2021] after having this problem again I was able to pinpoint the Problem to be only in orthogrraphic view, the fix for this was then changing the clip end, I've also read that changing the clip start can also fix this
[FIX as of 2020] I have no clue why but here's how I fixed this.

Go into Material preview (press z in the viewport)
Press the Arrow in the top right corner and activated these two settings

Deactivate them again and it worked for me. The problem was probably just that the viewport had an error and just needed to update the lighting, which is what this did. Hope this helps anyone in the future


I did something similar in the past, although I was looking for rounded bezier paths and I came up with this, which works - somehow - also when lines are straight, and not rounded. I'm not sure if it helps you but at least it's done differently, as it does not use bevel but an animated array modifier plus a curve modifier...

this is the setup: the bezier segments iirc have been straightened using: V => vector first, and then V => free.

I also exaggerated the line width (editing the small rectangle in edit mode) to better show it in pictures here.

and this is the animation that is produced:

I'm not sure if it solves your corners issues...

Here's the file, anyway.


Option 1:

Select your object (not edit mode)
Press Ctrl+Shift+Alt+C (Yes, 4 keys at once)
Select "Origin to Geometry"

Option 2:

Select your object and go into edit mode
Press A (maybe twice) to select your whole mesh.
Press G to grab your selection and move it to your Origin.
(If you only want to move it straight down press Z to stick the movement to the Z-axis

Note that if you want to move your object around in your scene you should not do that in edit mode as the origin (the thing in the yellow circle) doesn't move with it. Otherwise you end up with the problem you hae right now.


Is there a way to isolate an area of a mesh when Weight Painting?

Using the button I have highlighted in the screenshot will basically translate what you see and have selected in edit mode, to weight paint mode.

So if I hid the top rim of the cup in edit mode, with that button enabled it's hidden in weight point mode.

You will need to have whatever faces you DO want to paint on selected however.


Select the edge loop.
Snap the cursor to it (Shift+S-->Cursor to Selected).
Select other loops up to the top of the mesh.
Set the pivot point to "3D Cursor"

Hit S,0 and hit Enter.

If you want to make the flattened surface look like a square plane you may add one, and join it with your mesh using Bridge Edge Loops option. Delete some edge loops X, add a plane and subdivide it (W-->Subdivide). Select the edge loops as pictured below (remember you have to have the equal number of verices in each separate meshes to make a bridge). Then press Space, type bridge and select Bridge Edge Loops option.


How does fire and smoke simulation work?

Quick and watered down explanation. For Blender's simulator NOT MANATFLOW. Much of this can be applied to Mantflow among other parts. Volumetric are quite complicated in how they work so it won't be included.

Assuming your using Quick smoke settings(This is to avoid the thousands of different settings)

D = Divisions = 64

Divisions is the amount of divisions each side is divided into.Each side is equivalent one side may be 2 units long and will have D divisions a side that is  1 unit long on the (Should only be one domain) object will have the equivalent amount or (D / 2 because it's half the size).

Time scale is the speed how fast it will go the lower the slower.

Border collisions are self explanatory.

Empty space is a voxel is under this value it's considered empty.

Density how dense the smoke is the higher the value the faster it will spread out.

Temperature difference the difference between the smoke's temperature and the "air" around it Higher the value the faster it will go up (I don't think I need to explain why).

Voracity(Not the correct spelling) the amount of turbulence in the smoke and "air" (I don't recommend using) .

Dissolve this feature will determine how long the smoke takes to dissolve.

Adaptive domain will change how large the domain is therefore increasing and/or decreasing the amount needed to calculate use this (Adaptive domain in Mantaflow is bugged don't use it in that branch )

Cache will store the data that has been simulated (Search up a tutorial on rigid bodies it will explain the exact same think just different simulations)

Field weights are basically what is affecting affecting it.

Flames (I don't know how to explain but I'll try)

When simulating flame and smoke they are done  mostly separate from each other but they interact through the proprieties like temp difference,density among others
The main ones are Divisions,Temperature difference,Density,and Field weights.
Divisions are how much will be considered flames
Temperature will determine how long the flames stay before they emit smoke.
Field weights I don't think I need to explain.
Yes flames are taken from the result of the simulation through distance Temp and the other Major factors listed above.
No the initial temperature isn't set high for Fire + Smoke it will basically do what is stated above.

Collections what you put in flow, anything that has smoke on it in that collection will emit but only from that one. What you put in to collision same thing but it will collide.

High Resolution Nothing I need to explain but noise method which is the differences in how noise is generated ( I have no Idea how it works).


Does the mirror modifier have to be applied in order to a complete a UV map of the model?

It depends.  The Mirror modifier extends UV's as well.  So if you have textures mapped to your model, it will map to both sides identically.  If you are fine with that, then no.

If you need to edit both sides independently, you will need to apply the modifier and further unwrap your model.


Newbie question, rig character with skeleton from a different model

Yes, you can use a skeleton for another model. You'll need to skin your mesh to that armature. But this is the same for any rigging you do in blender. Google about skinning in blender.
If your rig doesn't fit your new model, you have to adjust it. If it's a simple rig with no complex constraints, hidden bones' layers, it would be an easy task, but if it's something like rigify rig, makeHuman rig, or any other complex rig, it would not be so easy. Those complex rigs are made with metarigs, then generated with scripts. So you will need to fit the source metarig to your new model, then re-generate the actual rig.


Issue with creating high precision Ngon faces

It's a kind of warning that you are creating a concave quad face.

Ther's an article that explains they should be avoided.

Remember that render engine base their calculations on triangled meshes. Concave quad faces, as non planar quad faces, are not automatically splitted in Blender.

You can see how it works by adding a plane and move the vertex with fixed z till is placed inside the triangle made by the other 3 vertices


Blender 2.8 Wireframe Mode: show only visible Vertices

In wireframe mode they used to be all visible but the "Show whole scene transparent" button changes between selecting visible only and selecting all. It's similar to the button I outlined in solid mode.


Did you try the convert button?  That is the answer I keep seeing, Convert Cycles Hair Particle System to Mesh Object. Hope this helps I am new to blender so just reading through.... :)