How can I execute a function from a separate script?

You can just import the second file from the first and then call it's functions.

Imagine you have two scripts, foo and bar, stored in foo.py and bar.py, respectively; the script bar has a function which you want to call from the script foo. All you need to dois import bar at the start of foo and then call it's function, as in this example:

#File bar.py
def test():
    print("Hello, World!")

#File foo.py
import bar

bar.test() #Outputs "Hello, World!" to the console


From your image it appears that your light source is excluded from the render. In the outliner in the top right of your screen, enable your lamp rendering by clicking on the grayed out camera icon.


How can I render pixel art images with no AA and transparent background?


How to create a sphere with an outer layer of removable pieces?

You could create your icosphere, duplicate it with ShiftD, select one of the two, go in Edit mode, select all and split the faces (Mesh > Split > Faces by Edges):

Then extrude with E, press Enter right away, and scale up with Transform Pivot Point > Median Point selected:

Now you have your two objects, the core and the outer sphere. You can separate each piece of the outer sphere with P > By Loose Parts:

Each of these separate pieces will have the same origin, which I guess will help to position them correctly in the 3D space of your game.


I'm new to this board so I don't know why my previous attempt to answer was deleted. Maybe it was just to short last time so I'm trying to be wordier. Its a perfect solution to your issue because I use this same technique. Its a very simple but it works. and I'm being as clear as possible.
Instead of rotating the view to your object, rotate your object to the view, so that the plane you want to sculpt is aligned with the correct axis. That way you can still lock the x and y, and just sculpt along Z axis.
With the axes locked, you can see that the sculpted verts only move in Z axis.

You can rotate the object instead of rotating the view to keep sculpting only locked to Z axis. Rotated 90 degrees

Even if you dont rotate 90 degrees, you can rotate the object however you want and the sculpting is locked to one axis. The vertices are only moving up. Rotated 45 degrees.


You won't be able to solve a shot like that with the default solver. The camera is stationary and is rotating only, in those cases you need to solve as tripod. Be aware that this will only reconstruct the rotation of the camera, but will not yield any 3D information.
Read: How can I get better results when doing camera motion tracking?


Need light from HDRI to shine inside of mesh (cycles)

Select the Text Mesh and under Object properties scroll down to Cycles Settings and untick Shadows

This has the affect of allowing the light to pass through and into the object.


Script wise functionality of F8 to reload Addon

The following worked for me in the Python console in Blender (Shift+F4 to open):

import imp
import manuelbastionilab  # addon name
imp.reload(manuelbastionilab)
bpy.ops.wm.addon_enable(module='manuelbastionilab')


Final render doesn't look the same as it does in the preview (2.8)

I don't know how to solve that issue... but you can use this.

Goto-> View-> Viewport render.

but to get the render correct. you need to hide all those cursor, grid, arrows etc.,
Hope this helps you.


Box rigging with empty groups does not work

Try using automatic weights instead. That will create the groups for you.


Mtree addon blender 2.83.10: Leaves and Tree branches separated in Particle System

This is not a real solution but it works. Select the tree and the leaves Export selected as .FBX then import again then join. Just like that you can just move it around and scatter it together.


How to make object transparented when player approaches them based on their distance?

1. In your material active (enable, check) Transparency checkbox:

2. Select the desire object

3. In logic editor, add an always sensor connected to a pyton controller:

4. script.py

from bge import logic
own = logic.getCurrentController().owner
player = logic.getCurrentScene().objects['Cube']
distance = own.getDistanceTo(player)
#if distance
print('distance : ', distance*0.02)
if distance * 0.04 < 1:
    own.meshes[0].materials[0].alpha = distance * 0.04
    print('alpha : ', own.meshes[0].materials[0].alpha)

Related

Python API (bge object material)

bge.types.KX_BlenderMaterial.alpha


Imported genesis 8 female's vertex groups are not following bone they should be parented to (I'm a noob)

The weight painting is probably off. To fix the teeth find the vertex group with the weight painting for the head first. The bones of the armature have vertex groups with the same name. I don't know if the teeth in your model is a separate object. In my model, it is.
Select the head object, go to Weight Paint mode and search the list of Object Data Properties > Vertex Groups for the head bone. If the head turns red, you probably found the right one. Remember the name of the vertex group. In my example, it's "spine.006".
Disclaimer: I used Rigify's metarig for a quick pose and the weight painting is very rough and done lazy. But it does the trick for the non-animated pose.

Go to Object Mode and select the teeth object (ignore this step if the teeth are in the head object.) Switch to Edit Mode, select all vertices of the upper teeth and the palate (key L may help). Assign the selected faces to the "spine.006" vertex group. Create a new one if needed. The upper teeth should be in place now.
Repeat the steps for the lower teeth if needed and assign them to the jaw vertex group ("spine.005" in the screenshot). So you can open the mouth properly.

For the glitch at the forehead, you need to check the weight painting in the vertex groups to see what's wrong there. There is probably one vertex assigned to another bone/vertex group or not completely assigned to the head vertex group.


Is it possible to load animated gif images?

Short answer:
You can't.
Blender does not support the gif format.
Long answer:
You would need some other software to convert your gifs to a format that blender understands to be able to import them.
For a list of supported formats see here


There is at least a video showing someone compiled PyQt into Blender:

http://vimeo.com/86398593

And a facebook post:

https://www.facebook.com/cgtutorials/posts/521688517904188?stream_ref=10

So it seems possible, at least with a modified Blender binary.


When you are saving the image, in the save dialogue options, do you have by accident "Individual" checked instead of "Stereo 3D"?


Seamless grunge texture overlay across two materials

A way to add a grunge texture to both the board and the letters with no discontinuity between the 2 would be to join your 2 objects (make sure that you've applied the Scale and that the normals are recalculate), unwrap  with Smart UV Project mode, paint your grunge texture on both with the Stencil brush option and use the result as a mask:

But the quickest way to is probably to use the grunge image in an Image Texture that you switch from Flat to Box, which allows the texture to be projected on the 3 dimensions, and use the Texture Coordinate "Object" output socket, with an empty as Object in order to control the location and scale of the texture so that you can precisely put the grunge:

Then use this node chain as a mask in both the letter and the board materials. Here for the board I use it to simply separate 2 nuances of red:

Former answer, in case your letters were printed and part of the same object:
You don't say enough about your current material, but let's suppose that is very basic, like this one (a simple mix between 2 colors with a b&w mask for the text):

then you can plug a dirt mask into 2 ColorRamp in order to get the dirty texture:

If your material is more complicated, for example because it plays with glossiness etc, it will make the node setup more complicated as well:


How do I select a square area on a cube and extrude it into the plane to add depth?

select the face click i and move to resize the face

then press e and move inside the cube


How to bake dynamic paint surfaces headlessly?

import bpy

obj=bpy.data.objects['Cube']
modifier=obj.modifiers['Dynamic Paint']
canvas_surface=modifier.canvas_settings.canvas_surfaces['Surface']
point_cache=canvas_surface.point_cache

context={}
context['blend_data']=bpy.data
context['scene']=bpy.data.scenes['Scene']
context['active_object']=obj
context['point_cache']=point_cache

bpy.ops.ptcache.bake(context,bake=True)

Objects can be both a brush and a canvas. The baking is done by the surfaces of the canvas. So an additional iteration is necessary.

#...
for modifier in obj.modifiers:
    if modifier.type=='DYNAMIC_PAINT':
        #additional iteration
        for canvas_surface in modifier.canvas_settings.canvas_surfaces:
             context['active_object']=obj
             context['point_cache']=canvas_surface.point_cache
             bpy.ops.ptcache.bake(context,bake=True)


Is there a way to bake ambient occlusion map as strong as in viewport shading ambient occlusion?

The viewport AO uses different engine than the bake AO function (Blender Internal or Cycles in 2.79 Blender), so the settings for the viewport AO are not used in the Bake.

The viewport AO is multiplied by 5, so if you take your baked AO into Photoshop or another editor and you play with the levels of the image (or you multiply 5 these images on top of each other) you get similar result.

Selected to Active does not have impact on the strength of AO, only from which object it will get calculated.


Move object to 3D-Cursor but only on one axis

I don't think this is possible while creating the objects but you can move them all to the same z-coordinate at the end instead. To achieve this, select all the objects you want to move and then set the Y-coordinate (or whichever property to want to have in common). Then right-click the coordinate property and select 'Copy Single to Selected'.


In the first example why not use a rectangle instead of a square for the boolean so the backside is longer and doesn't disappear as it goes over the bottom cube. You could animate lots of strange shapes for options.
You may also want to do something like in the unrelated answer to this question here:
Animating appearing/extending strip with gaps


Workflow for a short animated film: what to do first, music or video?

By short animated film I assume it is story driven and that there might be dialog.

The process is this:

write the script (with dialogue)
create storyboard, mood, concept art
record dialogue with video reference of that performance
select Temp music based on script and mood
animate based on script, storyboard, dialogue audio, temp music
compose real music and replace temp music, add sfx

In more detail you can read Pixar's Animation Process.

Why is it like this:

I will skip how script and storyboard is important, the question is not about these.

It is way way easier to animate facial and body expressions if you have dialogue and actor reference as source.

The final camera motion, animation and film cuts are also good sources for the music. However it is easier to cut footage to music than to cut sound to video. The reason is music has rhythm, which the footage might initially not correspond. Speeding/slowing footage and cutting it is easier than doing it with sound.

You solve this paradox by using Temp music, which is just some music already created, that you "steal" and use as reference to time your animations and to use as temporal guide for mood.

This temp music makes it a bit easier to get inspired for flow, mood and timing while animating (similar as with the dialogue audio). But it is no deal breaker if no temp tracks are used.

Making the actual music/score is the last step in creating animated short film.

On a side note:

It is by all means also possible to skip the Temp music part, and source all the flow and mood for animating directly from script and storyboard. The music is then inspired by the visuals (mood-board/story-board) and story emotions (animation/script) and is less restricted.

Temp music can be controversial, because your final score might sound like a knock-off. Because of this, it might be good to change the tempo or roughly re-mix the source for using as temp track.

More matter to watch:

Temp music from composer's point of view: video here

Temp music in film: video here


You have turned off rendering of the text objects. In the outliner, click on the greyed out camera icons next to the names of the text objects, to activate.

Now it should render just fine.


In the edit mode select the face selection mode, select the part of the mesh you want to remove, if it selects both the upper and lower parts, subdivide the selected face after its been subdivided select the part below ground level and click on P key to seperate you'll see an option that comes out click on 'selection' then you can delete the seperated Part if you want


Why texture heavily 'stretched' even though UV is well positioned?

The vertices, extra smoothness and all data generated by Subsurf can't really be modified further from their source mesh they are interpolated from. It's how the modifier is intended to work. But there is a checkbox for Subdivide UVs that you can disable. This should make the model linearly interpolate the UVs instead of smoothing them according to Catmull-Clark.

The image isn't really the best when it comes to illustrating the difference in UVs, the differences are only there where the unwrap isn't perfect and I'm bad at making distorted UV unwraps. But regardless, disabling subdivide UVs should fix whatever difference in UVs is caused by Subsurf modifier.

However in the future, thinking about your workflow it's important to model first, then texture especially with hand-painted ones because they are entirely dependent on geometry. If you look at your texture you can actually see the level of detail you had during painting. You should adapt your workflow to this fact and paint the textures only after you've reached high enough definition with your model.


You will have to play with the settings to get the exact look you want, but the base of this material is a noise texture that controls the roughness and the displacement of the material (technically the roughness should be consistent, but it gives it more contrast IMO)


How can I access view3d.select_circle radius value?

Operator Properties Last

The window manager has some useful methods re looking up operators and their properties.  Of particular use is WindowManager.operator_properties_last(...)

If we feed in the operator, in this case "view3d.select_circle"

>>> sc = C.window_manager.operator_properties_last("view3d.select_circle")
>>> sc.radius
273

it will return the last used properties of the operator.

If the operator has not been used (or does not exist)  sc will be None

This is not read only. Changing the value will set it for the next run of the operator

>>> sc.radius = 40

Defaults

Possibly worth mentioning too, to get the default value use

>>> rna = bpy.ops.view3d.select_circle.get_rna_type()
>>> rna.properties['radius'].default
25

as it does seem that although the class name is as expected

>>> bpy.ops.view3d.select_circle.idname()
'VIEW3D_OT_select_circle'

after a change in API (around 2.79 IIRC) not all classes are accessible via bpy.types

>>> getattr(bpy.types, 'VIEW3D_OT_select_circle', None) is None
True


Grease pencil problem, Can't see the keyframes

You won't see the keyframes in the timeline. Instead you have to use Dope Sheet > Grease Pencil.


Missing Material Issue; Pink Color in Render Mode

Make sure the image is not corrupt before adding it into Blender. If this happens, re-download or re-export the image.


Python show rig ui if armature is selected

If you add a poll method to your panel class you can use whatever criteria you wish to decide if a panel should be shown.

@classmethod
def poll(cls, context):
    return context.active_object.type == 'ARMATURE' and
        context.active_object.name.startswith('myrig')

When you alter the bone layer visibility it should only effect the one active armature. You can perform tests in the panels draw function to decide if a layer button is shown.

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

    if context.active_object.name.startswith('myrig'):
        row = col.row()
        row.prop(context.active_object.data, 'layers', index=0, toggle=True, text='head')

Unfortunately I don't think there is an easy way to check if there are bones on a layer, you need to loop through all bones and their layers array.

def used_layers(obj):
    ulayers = [False,]*32
    if obj.type == 'ARMATURE':
        for bone in obj.data.bones:
            for i in range(32):
                if bone.layers[i]:
                    ulayers[i] = True
    return ulayers

Then in the draw method -

def draw(self, context):
    layout = self.layout
    col = layout.column()
    show_layers = used_layers(context.active_object)

    if show_layers[0]:
        row = col.row()
        row.prop(context.active_object.data, 'layers', index=0, toggle=True, text='head')


Dynamic Reaction Control System Animation

I believe that I've solved the issue. The solution isn't 100% physically correct, but it appears reasonably close with a few caveats:

Use Animation Nodes 2.1, no My-AN-Nodes required (this could probably be redone on 2.0)
You must also instantiate empties on each location you want a plume, then use the animation nodes Set Keyframes node set to record rotational keyframes for every frame, running entirely through your animation at least once to get that data. (This can be temperamental on Ctrl+Zs, sometimes requiring one to re-keyframe them again)
The object/cage you want to have RCS plumes must be reasonably symmetrical for the effect to look good, and be able to have some portion of it (usually all the sections below its center of rotation) covered by an invisible mesh, which determines which half of the object should have the RCS plumes fire in the opposite direction.
You must be willing to run a small bit of python code to calculate the acceleration.
You may need to tweak the values in Map Range node, depending on the speed and scale of your animation.
At this point, this node tree only handles rotational acceleration, not translational acceleration, though it is possible it could be adapted.
I am not a mathematician, and may be using any number of these nodes incorrect or only accidentally correct ways.

To start with, you'll want to create 4 objects, an object to be the RCS "plume" (I'd recommend a cone), an empty to calculate individual acceleration on, a "cage" to place the RCS on, and finally, another "cage" to mark which parts of the mesh are the "bottom" half.

Once you've positioned the second cage appropriately, parent it to the RCS cage (or whatever you've parented the RCS cage to). Next, animate the RCS cage in whatever pattern you want. Keep in mind that if you change the animation at all at a later time you'll need to re-keyframe the empties!

At this point, you're ready to create the NodeTree.

Start with the generic support nodes, including the script node to calculate acceleration. The python script is as follows:

# Mostly borrowed from https://github.com/Clockmender/My-AN-Nodes/blob/master/speed_acc.py

fps = bpy.context.scene.render.fps

dec_n = DecimalPlaces

if Minus0 == 0 and Minus1 == 0 and Minus2 == 0:
    spd_u = 0
    acc_u = 0
    acc_g = 0
else:
    spd_c = abs(Minus0 - Minus1) * fps
    spd_o = abs(Minus1 - Minus2) * fps
    acc_u = round((spd_c - spd_o) * fps,dec_n)
    spd_u = round(spd_c,dec_n)
    acc_g = round(acc_u / 9.81,dec_n)

Next, create the loop that'll calculate X, Y, and Z rotational acceleration based on the empties' keyframes.

Make sure that the the frame offsets are set on the Evaluate FCurve nodes!

Initialize all the objects and empties.

Note that the "Copy Full Object" option for the object instancer for the RCS Cone is likely only necessary if you've fiddled with the object's settings, such as their Cycles Settings.

Next, we grab the BVH tree of the Bottom Cage and check what RCS Cone objects are inside of it.

We feed this into the List Boolean subprogram we created earlier, as the Boolean Switch node is not vectorized that I can tell. This list of either -1 or 1 gets fed into a Combine Vector node, though I suspect a Vector from Value node would work as well, which is then sent into a scale Compose Matrix, which then feeds into the overall scale calculation.

I don't fully understand why the Vector Math Cross operation (of the polygon normals of the RCS Cage, and the acceleration vectors) works in keeping the scaling on "one side" of the mesh, but it does. Next that list of vectors is fed into another support subprogram that uses the Transform Vector node on each pair of vectors and matrices. Next, we separate the vector, add its components, and multiply them by 100 (to get less fractional numbers). The Map Range node determines how far each plume can scale, based on the input (set the input min to 0, and input max to whatever seems a reasonable value based on a viewer node), and the output (set the output min to 0, and the output max to however long you want the maximum length of the plumes to be). Finally, combine that value into a vector and feed it into a Object Transforms Output node with only the Z axis selected, also being fed the list of RCS Cone/Plume objects.

This next part is more cosmetic and QoL than necessity, but it will keep plume objects with a Z scale of 0 from being visible (which can cause z-fighting).

Additionally, the Keep Layer subprogram will make sure that your plumes stay on whatever layer you've selected in the subprogram's body.

For people who'd prefer to have an existent blend file to work with, here's a link:

As mentioned above, you'll need Animation Nodes 2.1

If you've made it this far, congratulations! Here's a 4 second video of the nodetree in action. (The spaceship is not included in the above blend file)


Blender 2.8 Sculpting splitting at edges

Also a noob here. A solution I found is to go to edit mode, select all the vertices around the edge of the hole, click on the button that says 'Face' in the top left, then select the fill option. Only just found it and haven't tested it too much.


The Rigid Body World default values are OK for crude approximations of physics without much computational overhead but can be tweaked to produce more accuracy. In particular, try adjusting the following settings :

Increasing Steps Per Second should give a better simulation as each simulated step will be smaller and so more accurate. Similarly, increasing the number of Iterations gives it more chance to settle on a stable solution. Enabling Split Impulse should stop objects bouncing apart at unexpected velocities if/when the simulation results in them overlapping.
Try significantly increasing the number of Steps and Iterations and see if that improves your simulation and also try with Split Impulse enabled and disabled. Once you've got acceptable results you can try gradually reducing them to get a good balance between realism and efficiency.


why the background image I add not show in render?

There's a great addon exactly for this.

Go to Preferences > Addons  and search for Images as Planes addon.
Check it to enable it.

Then you can easily add a new image that will appear in your render.
Add > Image > Images as Planes

Note:
The way you described is for reference images only - thy're not supposed to be visible in a render.


On linux, the mouse cursor is almost the exact same color as the gray background of the preview window

On xfce:

Open "Mouse and Touchpad"
Go under "Theme"
Then select a bright cursor theme


You need to apply your Array modifier, once done you'll be able to separate the objects.


Can I reuse a character to multiple characters in one scene with the link feature in Blender 2.8?

This seems to be a limitation of Blender at the moment. You can't link in multiple copies of the same rig for independent animations.

The workaround is to create copies of the original blender file and link in the copies.


particles.location not returning proper frame values

You are using the reference to the location of the particle, hence they are all the value of the last frame, fix by using a copy of the location in your list.

p_position.append([frame, particles[0].location.copy()])


I think it might be the node setup for the light. When I set up a similar scene with a pure emission shader on the plane, everything worked as I think you wanted.

In the scene I have a plane with a 50/50 blue diffuse/white gloss mixed shader, a 100% green diffuse shader and a 100% red glossy shader all at about .2-.3 roughness. There is also the default amount of light being emitted by the world

Finally just to prove that the red glossy plane isn't reflecting the light, I turned off the world light and you can see that the red plane is no longer being lit by any light source and is completely black.

Hope this helps you.


The color management is set to filmic. This does not only effect your renderings, but also the VSE output. So you need to set the color management to for example sRGB

 Where it says filmic choose something else.


Exporting cycles rendered models to be used in opengl

The main problem is that baking with Cycles is still fairly new, less than one year at the time of writing.  Blender's various exporters were designed before this and they are built upon the older Blender Render(Internal) Material system.  Here is a print-screen of the main Blender Render Material System.  Although BI has nodes as well, I'm not so sure they will work well with exporting either.

So let's go back to Cycles for a moment.  Here is a setup that has a texture which was baked using Cycles bake.  The baked texture is chosen by a node as seen in the node editor but the current problem is that this node will not be recognized by the various exporters as being a texture that should be exported along with the model.

Here is an example of one difficulty that can make upgrading the various exporters to work with Cycles a bit complicated.  There are three textures in the following node setup.  One bake-to texture, one texture for the diffuse color input and one normal map.

Now it could be decided that the texture which is not attached to anything should be the texture to be exported as the main color texture, however, Cycles nodes allow for more than one node group as shown in the following image.  The setup shown would make consistent and reliable exporting very difficult but it makes the Cycles material system very flexible.  These two ideas conflict.  It's not at all clear for this situation which baked texture(s) should be exported.

So for now what you can do is switch to Blender Render and deactivate the Nodes as shown in the following image.

Now click the tabbed icon for textures that is to the right of the Material tab icon and add a texture slot.  Next, assign the baked texture to this slot.  (Now you should be able to export without too many problems.)*

*as I mentioned in the comment earlier, leaving the Cycles nodes intact but deactivated can still cause the exporter problems.  For simple scenes it doesn't always happen but with a complex scene that has 100 models and hundreds of textures all linked into the Cycles nodes system, things can get hairy for the exporter.

The textures may be detected but the exporter may not know what they mean and it could fail because of this.
The SketchFab exporter was doing this to me this past spring.  It's probably better to save the .blend and create a duplicate of it and then just delete all the Cycles materials and build them up again using Blender Render(Internal) from the start.

It's a nuisance but until someone with coding skill finds the time to deal with it, this is what we are stuck with. (unless someone knows something I don't and they would like to share.) :)


In the World Options, select Environment Texture for Color and then select Hdri Image.

In the shader node, we attach the hdri image to the color in the background node.


In Edit mode, select all vertices using A, then hit R, (and possibly X or Y or Z to lock the rotation axis - if you hit it twice, it will lock to to local instead of the global axis) and the number of degrees you want to rotate.


Why isn't my mesh properly textured in Blender.

Well, it's hard to tell exactly without seeing the actual .blend file or a screenshot of the various steps you used, but i'll guess that:
... You either didn't separate the various mesh sections physically  or by using "seams", before unwrapping, then selecting specific faces before assigning the materials....
.. or by designating and assigning "vertex groups" to define various sections before "applying" or "assigning" the materials on the "edit level",
... or used an inappropriate or "singular" method of "UV Uwrapping" for the various parts,
... or didn't just "paint your textures" on using the live "texture painting" option after doing a "basic" UV UnWrap....

To fix, you might want to go back into Edit mode and establish "marking seams" to separate the various parts not just by texture or color, but be sure to include an additional splitting seam to allow the Unwrapped sections to flatten out properly for proper "fitting" of the texture to those specific areas... ...If you do this correctly your Unwrap should look like a pattern used for cutting out sewing panels...
....If you did that part correctly, you can use the texture paint tools to "live paint" the textures in 3D or hand paint the various parts of your unwrapped UV mesh islands...
....If you select various faces at a time, you can assign "Vertex Groups" (under the Mesh or "vertex" Data panel) to just those faces, lock them, then unwrap by "View Projection" or whatever method is appropriate, give "that" resulting UVMap it's  own unique name in the "vertex panel as well", assign a material containing the desired texture, and making sure that the desired "unique UVMap" name is chosen under the texture "mapping" options...   ...Then be sure to "deselect" the new vertex group before creating and assigning the next and repeating the process....
...Review a tutorial on UV-unwrapping and texturing a Character as the proper material for your Renderer.... mixing BI material nodes with Cycles doesn't work well....
...If you have the Matcap materials option turned-on on your view Display options, that could also be interfering with what your models surface appearance...
...Hope that helps a bit...


Vary the size of a particle instanced object

To give the instanced strands a random lenght increase the Random value in the Particle Instance modifier settings.


How to perfectly position these faces into this slot / area? (no gaps)

Your best bet is to use the snapping tools, specifically the vertex snapping mode, as others have said in the comments. The snapping tools take a little getting used to, but are really quite powerful. As I have noticed when using vertex snapping, Blender seems to take one vertex from your selection and try to snap it to the positions of others not in your selection while all other selected verts move in relation to the snapping vertex. Unfortunately I don't think you can specify which vertex will do the snapping, not exactly. You can however almost always change how the surfaces will attempt to snap together by moving the objects in relation to each other before hand.

The key is first placing your object so it can find a good snap, then moving it with snap mode. Using the ctrl key is really helpful for this.

For example:
If you are trying to snap cube A to above cube B, but cube A is somewhere off to the right side of cube B, Blender will only want to snap cube A on to the left side of cube B. However if you first move cube A somewhere above cube B, you should be able to snap cube A down onto the top of cube B.


How do I make this a 3d shape in blender?

Here's one approach:

I used your provided image to determine X-Z slices of 3-D space that should be transparent, and then spherically displaced a highly subdivided plane to get a 3-D shape that seemed reasonable given the image (although it is not rotationally symmetric about the Z axis, which you might be wanting).

I used two objects in my scene: a Plane at (0, -0.5, 0) and an Empty at (0,0,0) (the Empty was just used to make the Mirror modifier mirror in the intended manner without my having to reset the main object's Origin).

Here's the small modifier stack I used:

Where the displacement used this quadratic sphere texture, with Color Ramp enabled and tuned to taste (this controls how wide/tall the resulting object is):

I enforced the transparent stripes with this shader, where the input image is the jpeg you provided:

(not shown: my collapsed Principled BSDF node's Base Color was set to Black; this is why the non-transparent stripes in the image of the object are black)

I used Eevee as my Renderer, and had Blend Mode: Alpha Clip (in the Materials settings for this material) and Film: Transparent (in Render settings) enabled.

Note that this approach:

Doesn't convert the transparent strips to geometry (although you could do something similar to this with a Mask node to achieve a similar effect, and if you were to do so, that would make selecting and deleting those vertices straightforward, which would let you embed this information in the geometry)
Yields a very large number of extraneous vertices if you apply the modifier stack to convert it to raw geometry. Here is what the result looks like, after applying the modifier stack in order and viewing the object in Edit Mode, Rendered View:

You can easily select most of the undesirable vertices outside of the main, central area of the object (in case you'd like to delete them) by using Select Similar: Normal, although this isn't perfect and you'll still need to clean up some of them manually. Depending on your use case, you might also want to re-topologize the final object to simplify its geometry (it is nice in that it contains only/primarily quads, but it also has lots of vertices that occupy exactly or almost exactly the same point in space, and some of its internal vertices could be unnecessary as well, depending on your final use case).


How do I get particles to follow an animated path or armature?

Thank you for posting your question so clearly.

Time to get serious with particles: Select your tunnel, enter EDIT mode, switch to FACE selection filter, select all faces. Go to the MESH menu>NORMALS>Flip normals. Now all your normals should be pointing INSIDE your tunnel.

2) Switch back to OBJECT mode, now apply a SOLIDIFY MODIFIER, and make it thick enough so that when you deform your object it will deform correctly (like a real tunnel thickness)

3) Go to the dynamics tab and click COLLISION. Set friction to something like 0.2, 0.5

4) Now when you playback your animation, your (already working curve guide force) should be working and particles will not be able to scape the tunnel. Furthermore the expected behavior of the particles will react to the deformation of the tunnel.

Thank you for your consideration to vote this as the answer.

BFCT_Schiller


3D print toolbox

In the 3D print toolbox add-on (it's already bundled with the official verion of Blender, you just have to enable it) there are two buttons (you can fin the right on the top of the tab), one for the volume and one for the surface (area)

Results are shown in the latest line of the panel once one of the two buttons is pressed.

The commands take into account the whole object, so if you need to get the surface of one part of your object only, you'll have to separate the faces into another object.


How to use Mesh to paint weight to another

You could use dynamic paint to do that. Make the plane a canvas, and the pink object a brush, and set the plane's surface type to Weight.

Note: you should be aware that the resolution of the weight painting depends on the subdivision of the plane.


Moving all files to a new computer, my concern is links

I think the key thing here is to always use relative paths in your blend files when linking remote data. That means for linked libraries, textures and any other data external to the file.

Relative paths are guarantied to work if you maintain the folder structure relative to the blender file intact, even if the absolute paths are changed.
That means if you move your files to a different machine or even on your own current machine but maintain their positions relative to each other things should not break.

Whereas absolute paths are never guarantied to work in a different machine, unless you can recreate the exact same base path for everything down to the same drive letter.

The good news is I think Blender already does this by default, so in theory you should not have to do anything, unless your store stuff across different drives letters, crosslink from network data, or specifically set blender to use absolute paths.

You can double check this by opening one of the files in question, going to the Outliner and changing the menu in the header to Blender File this should list all local data stored inside the current Blender file, and bellow it towards the end of the list all loaded external data from other .blends. From there you can check which files are loaded and from where.

If a path looks something like //..\Path\to\my\Library.blend then is relative and all is good. If it looks something like D:\Path\to\my\Library.blend (has a drive letter in it) than it is likely to break in the new computer.

You can easily fix this by going File > External Data > Make all paths relative

Blender has relatively good asset management capabilities, in the new computer you can then check if anything is missing by going to File > External Data > Report missing files

Now make sure that when you move stuff you maintain the same internal folder structure. One good way to organize your projects would be:

Master Folder

Blender Projects Folder

Project 01
Project 02
Project 03
Project ...

Library folder - For reusable assets and library files

Models
Animations
Textures
Materials
...

Independently of where in the file system you place it, if you maintain this internal folder structure intact, and all files reference each other using relative paths within this "garden" all should be fine.


Is there a way to solve terminator artifacts?

From blender 2.90, you can tweak this using the Object's Shadow Terminator Offset Shading property.


Bone Heat Weighting: Failed to find solution for one or more bones?

One of the problems that the automatic algorithm is not good at is dealing with characters maden of spare parts and not an unique closed manifold mesh.

You can separate all spare parts and rig them one by one: it works but you'll have to tweak  the automatic weights manually, because the algorithm doesn't know which part should be moved by which bone.

As your beautiful character is so complex, I would absolutely go with manual weighting, which is less complex than it seems, see this answer for some weighting tips: Rigify : skin overlapping clothes


Why casting a sphere to a cube give cylinder+cube?

The image above shows a blue mesh with a sphere shape, hereafter the blue sphere.  It is symmetric about the 3 axis similar to a cube.  Note the red faces have a 3 face corner not a 4 face corner. Not a UV Sphere.  The mesh will work symmetrically along x, y, z axis with a cast cuboid modifier.

In the image in your original question concentric rings of the UV Sphere are placed along the z-axis.  Speaking about the default situation.  So the there is an asymmetry regarding the z-axis.  So the [cast] modifier mathematics amplifies this asymmetry.  You will get slightly better results if you subdivide your mesh again.

You can edit the blue sphere in [edit] mode and rotate 90 on the y axis.  The asymmetry deformation will be rotated as well.

Here is the same blue sphere shaped mesh with a cast modifier.  Note again the red faces which form a 3 face corner of a cube.

To create a NON-UV sphere shaped mesh.  Create a cube. In [edit] mode loop cut on with 7 or so divisions. Loop Cut on all three axis XYZ.  Menu Transform ..... Transform to Sphere.

Yes, start with cube, transform to sphere shape, cast back to cuboid.

Additional Notes
Please welcome Carlo

Cast modifier basically projects the object vertices along their normals to the target shape's surface. It is the same thing you would get by using a Shrinkwrap modifier pointing to a scene object.

By enabling Vertex normals in Edit mode, you can see on what surface each vertex will be translated to.

There is no vertex pointing toward the box's corner.

Conclusions:
To better approximate a cube, the starting sphere should have enough vertex density whose vertex normals point to the cube edges and corners. So for better results you can:

Increase the number of vertices
Use a different starting topology


How to continue bake fluid simulation in blender 2.80

If you have baked it, just go to physics properties tab and tap on 'Resume'.


The action editor that you are using only shows a subset of keyframed values, to see all available keyed data you need to use the full dopesheet or the graph editor.

If the values you are looking for are still not visible then check the options in the header that filter the displayed items.

EDIT:

An action is basically a container for animation data that can be turned into an NLA strip. One active action is associated with an object for editing and is cleared when added to the NLA, it can manually be activated again in the action editor if further editing is needed. The dopesheet and graph editor only show animation data that is in the current action for an object.

A materials animation data is stored in it's own action, but this action is not shown in the action editor and only material animation data that is associated with a material in a selected object is shown in the dopesheet and graph editor. Once a materials action is turned into an NLA strip blender does't provided a simple way to re-activate it for further editing. You need to use python to re-activeate a materials action so that it can be edited.

In blender's python console enter the following (adjusting the names) -

bpy.data.materials['Material'].animation_data.action = bpy.data.actions['Material.action']

Then the material animation data can be edited in the dopesheet or graph editor.


Solidify modifier creates edges with a different thicknesses

Here is an example:

The figure on the top here has "even thickness" unchecked.

That means the modifier makes so all segments length are the same. But as you can see the flat parts are uneven because the corner has the same length as the extremities.

The figure on the bottom has "even thickness" checked.

Here the flat parts are regular. But the segment at the corner does not have the same size compared to the extremities.

Now look at this figure:

When "even thickness" is checked, Blender calculates the intersection of 2 flat parts. Like intersecting 2 rectangles. That means (as shown with the green segment here above) that the length at the corner must be larger than the others.


Why is render coming out SQueezed together?


Unable to edit the meshes for shape keys


What is the correct context for applying a new particle setting or override it?

The bpy.ops.particle.new() is not the operator name you are after.

bpy.context.scene.objects.active = bpy.data.objects[edge_name]
bpy.ops.object.particle_system_add()
bpy.context.object.particle_systems.active.seed = seed_value

It is usually preferred to not use operators in scripts. For creating particle systems the method may appear a bit odd as adding a modifier seems to be the only non-operator way to do it. You might notice that this way doesn't need to alter the active or selected objects.

object = bpy.data.objects[edge_name]

if len(object.particle_systems) == 0:
    object.modifiers.new(name='particles',type='PARTICLE_SYSTEM')
    object.particle_systems.active.seed = seed_value

Once you have the particle system on the object you can either change each setting to suit or you can set it to use an existing particle setup.

object.particle_systems[0].settings = bpy.data.particles['MyGreatParticles']

While a new particle setting will be created each time you add a particle modifier and you will get more of them as you repeat this, by using an existing particle setup they will have zero user count and will not be saved to disk.


There are two ways to go about doing this.

Method one is to merge the front edges first, then the back ones. If the vertices you are merging have no depth on a certain axis (the Y axis in your case) then merging them will not move them on that axis. Simply select the from ones, merge them, then the back, and merge them.

The second Method is to select all the vertices that you want to merge and scale them to 0 on whatever axis you want to merge the vertices along. In this case, you would press S then X and finally 0 to completely flatten the vertices along the X axis. If the vertices you have selected had some variations along the Z axis, you could instead use Shift+Y instead of X to scale on all axes but the Y, so that they would be perfectly flat. Confirm the scale operation, and then, with all of the vertices still selected, press W and select remove doubles. This will merge together any vertices that are in the exact same position.

One other thing I should mention is that blender has a feature called Auto merge editing that will automatically merge vertices that are in the exact same place. This could be used to save a step in method two. The feature can be found at the bottom of the 3D view on the right side of the toolbar there. It is the little button with the two arrows pointing to the center.

Method two sounds longer when I describe it here, but in practce, once you become familiar with the shortcuts it is quicker that way.


Blender - apply image texture to specific parts of the object

A solution is that first you make two material slots. Give one slot any other texture you want and the other slot the image texture you want to apply to a specific part of mesh. Then go to edit mode, select the parts of your mesh you wan't your material to appear on and then press apply after selcting the right material.
Here are some tutuorials from youtube for beginners: https://www.youtube.com/watch?v=ms89wP8m4ZU
https://www.youtube.com/watch?v=CXpbK2T1HJA


Creating a resizable selection cursor in Python

Thanks to this answer I've figured it out. I am drawing the circle using OpenGL calls. Here's updated code I can use to select faces in edit mode:

import bpy
import bgl
import blf

import math

def draw_circle_2d(color, cx, cy, r, num_segments):
    theta = 2 * 3.1415926 / num_segments
    c = math.cos(theta) #precalculate the sine and cosine
    s = math.sin(theta)
    x = r # we start at angle = 0
    y = 0
    bgl.glColor4f(*color)
    bgl.glBegin(bgl.GL_LINE_LOOP)
    for i in range (num_segments):
        bgl.glVertex2f(x + cx, y + cy) # output vertex
        # apply the rotation matrix
        t = x
        x = c * x - s * y
        y = s * t + c * y
    bgl.glEnd()

def draw_callback_px(self, context):

    bgl.glEnable(bgl.GL_BLEND)

    # ...api_current/bpy.types.Area.html?highlight=bpy.types.area
    header_height = context.area.regions[0].height # 26px
    npanel_width = context.area.regions[1].width
    transorm_panel_width = context.area.regions[3].width

    width = context.area.width - npanel_width - transorm_panel_width
    height = context.area.height + header_height

    # draw text
    bgl.glLineWidth(4)
    draw_circle_2d((1.0, 1.0, 1.0, 0.8), self._mouse_pos_x, self._mouse_pos_y, self._radius, 360)

    # restore opengl defaults
    bgl.glLineWidth(1)
    bgl.glDisable(bgl.GL_BLEND)
    bgl.glColor4f(0.0, 0.0, 0.0, 1.0)

class ModalWheelTest(bpy.types.Operator):
    """Operator which runs its self from a timer"""
    bl_idname = "wm.modal_wheel_test"
    bl_label = "Test mouse wheel"

    _timer = None
    _radius = 50

    def set_wheel_zoom_state(self, state):
        """
        Disable or enable zooming by mouse wheel
        """
        for key_map_item in bpy.context.window_manager.keyconfigs.default.keymaps["3D View"].keymap_items:
            if key_map_item.name == 'Zoom View' and key_map_item.type in {'WHEELINMOUSE', 'WHEELOUTMOUSE'}:
                key_map_item.active = state

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

        if event.type in {'RIGHTMOUSE', 'ESC'}:
            self.cancel(context)
            return {'CANCELLED'}

        if event.type == 'MOUSEMOVE':
            for area in bpy.context.screen.areas:
                if area.type == 'VIEW_3D':
                    self._mouse_pos_x = event.mouse_region_x
                    self._mouse_pos_y = event.mouse_region_y

                    override = bpy.context.copy()
                    override['area'] = area
                    override['region'] = area.regions[4]

                    bpy.ops.view3d.select_circle(
                        override,
                        x=event.mouse_region_x,
                        y=event.mouse_region_y,
                        radius=self._radius,
                        gesture_mode = 3
                    )
                    break

        if event.type in {'WHEELUPMOUSE'}:
            self._radius = min(200, self._radius+5)
            print("radius: {}".format(self._radius))

        if event.type in {'WHEELDOWNMOUSE'}:
            self._radius = max(5, self._radius-5)
            print("radius: {}".format(self._radius))

        return {'RUNNING_MODAL'}

    def execute(self, context):
        if context.area.type != 'VIEW_3D':
            print("Must use in a 3d region")
            return {'CANCELLED'}

        self.set_wheel_zoom_state(False)

        wm = context.window_manager
        wm.modal_handler_add(self)
        return {'RUNNING_MODAL'}

    def cancel(self, context):
        self.set_wheel_zoom_state(True)
        bpy.types.SpaceView3D.draw_handler_remove(self._handle, 'WINDOW')
        wm = context.window_manager

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

            self._mouse_pos = []

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

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

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

if __name__ == "__main__":
    register()


This is in fact a very old known issue with Blender Internal renderer (caused by numerical imprecision), see e.g. this nine years old report.

Workaround of triangulating the buggy mesh (using e.g. the relevant modifier) seems to be working quite nicely, when that issue shows up.


What you see is actually a warning not an error, it will allow you to continue on but you may get odd results when you leave sculpt mode.

If you have modifiers that generate part of your model, like a mirror or skin modifier, you want to apply these modifiers, this will turn the generated data into real geometry that you can sculpt with.

For other modifiers like a subsurf, you will still get this warning, but it is better to remove the modifier, sculpt and then replace it if desired.

To apply modifiers, you should start at the top and click apply to remove each one you want to keep the results from.


Increase the effect of Ambient Occlusion with Cycles?

You are using fairly light colors in the ramp. I suggest to start with a simple B/W ramp to change the contrast on the AO node. Once you get the desired intensity, then only start changing the color ramp.


Removing alpha from PNG image with set alpha node gives pixelated result

Sometimes in PNGs that have alpha channel the image get interpreted in a weird way as RGB only (without the alpha).
Here's an example of how blender interprets such image:

Maybe someone else can explain why... I find that the program in which PNGs are generated can make a difference.

But as a quick solution in this particular case, try connecting the alpha of your Image node to the alpha of the Set Alpha node.


How to make a point out of 2 intersecting lines?

Two line maybe not even intersect, not even in 2d if they are parallel, well there is cheat for it:
https://en.wikipedia.org/wiki/Line_at_infinity

In blender we work with vectors in a 3d place and not with real numbers but with floats. So a pure mathematical solution is maybe unusable, I wrote this because the question is pure mathematical. If we rephrase it for 3d modeling:

Can I make a vertex at the intersection or mutually closest point of two edges. We will get a duplicated question:
How can I add vertices to intersection of two edges?


The problem you're having are three N-Gons. N-Gons are faces with more than 4 verts. So you need to change the N-Gons to tris or quads. To triangulate a face, just press SPACE and type triangulate, you will then see the option "triangulate faces".

The first picture shows my unwrap with N-Gons, the second one is with triangles.

However, the right way of doing it (if you want to maybe use sub-d or something) would be like this. You the only would have to deal with the edges going over the cube.:


What this issue displayed in my UV a symptom of?

This looks like new geometry added after your intial unwrapping was already done.


The "Random rough" parameter of the children seems the only one that affects individual children without too much correlation between them¹. Unfortunately though, it inevitably affects sizes too. Also, it can't be constrained to the normal axis (in case you needed it):

3 hair particles, 4 children each

A real "random rotation" doesn't exist for children specifically.

¹ (if "Size" is small enough)


I think you are talking about the Denoise node in the Compositor.

https://cgcookie.com/tutorial/denoising-renders-in-blender-2-81

https://developer.blender.org/D4304


Position of eyes and hair goes wrong after exporting

before exporting you need to set their world orgin to the same as the body orgin.

1)select the body
2)shift + s "cursor to selection"
3)select one of the other meshes(hair or eyes  or whatever order is not important)
4)shift + ctrl + alt + c(yes a crazy hot key) then select "origin to 3d cursor"
4a) you can alternatively just press space and do a search for "origin" and find it on the list
after that re-export your model...if that does not work, try to apply location, rotation, and scale...by selecting each object and using ctrl+a

I hope that helps, if not...just update here what the outcome was. It will help better diagnose the problem.


Apply texture to mesh that has been extruded

If you make a change to your mesh you will need to UV Unwrap it again.

In Object Mode Apply the Scale Ctrl + A > Scale.

Also, you could use the Project From View method of UV Unwrapping since it's flat. Just make sure your looking at it straight on.

A quick tip on Modeling the wall: Unless you plan on extruding "out" geometry your mesh would be much "cleaner" if, in Edit Mode,  you just selected the bottom two vertices (or top two) and pressed G + Z to grab them and move the only on the Z Axis. Then your left with a simple rectangle. If you Extrude the mesh down you are creating extra vertices and in complicated models that will increase render times unnecessarily.


You can do this with a Grease Pencil sketch, it has a Convert to Geometry Routine.

However, the paths created with this take ALL the curve points of the Grease Pencil sketch into the new mesh, so this may not be a perfect solution.

Update:
Actually, using the Polygon Drawing Mode this is pretty much exactly what you want. Closing off the endpoints is a bit fiddly, but otherwise it works just fine.


VSE: How do you precisely position two video strips

grab one strip, and move it towards the other while pressing CTRL: it will "snap" to the other strip's end even if it is on another slot:


How to define and access a list property for a game object in BGE

You will have to define the list in the script like this:

if 'list' not in object:
    object['list'] = []

You can then add objects using functions such as

object['list'].append('x') # adds the string 'x' to the end
object['list'].instert(3, 'x') # adds the string 'x' at position 3


Found the problem!

Some faces overlap and causes some rendering problems. Go into Edit Mode and move some of the faces away from its overlapping part.

Note: Since you didn't give me a texture to work with, I simply used my own...

Another solution: Remove Doubles (Press "w"), but this will make you have to unwrap some faces again.

Nice house by the way!

Another problem: The overlapping faces that are causing render problems isn't properly unwrapped:

I'm assuming you know how to unwrap, so go ahead and do that!

P.S: Select everything in Edit Mode and press ctrl + n. This will recalculate the normals and make you feel more organised ;)

Happy Blending!


How can I move an object along it's local axis?

I can thing of two ways:

1) In the 3D view Editor header you can choose the transform orientation

2) lets say you want to move in in the local x axis: hit G  X X


How can I change Blender 2.8 Preference via Python

This works...

bpy.context.preferences.view.gizmo_size=101


Memory on the left is your VRAM and on the right it's your RAM.

441Mb of VRAM is not much though, what's your GPU? You probably want to upgrade if you are going to use it to render.

You can also try to optimize your scene, easiest way to do this is to bake as much things as you can, lower texture resolution and your number of polygons, create instances instead of duplicating object data. Also you can probably reduce lights bounces but I'm not certain this would help.

That or just render with your CPU (it will take longer but will store data in RAM instead of VRAM). How much RAM do you have?

Google 'Cycles Optimization VRAM' for more info on the subject.

Here you'll find a way to launch Blender in debug mode to troubleshoot memory usage: How do I see what is using Memory?


Matching physics properties for multiple objects

Select all the objects you want to apply the physics to, then click on the object that already has the correct settings whilst holding down Shift.

Then navigate to the physics tab and click Copy from Active.


Not all bone automation using drivers and add-ons will work when rendering or might interfere with bone rendering animation.

In pose mode select all bones then go to

Pose> Animation> Bake Action> OK

This will disable all built in automation but will assure that your animation looks identical in your renders as in the viewport.


heightmap from textures and hight poly mesh to apply to low polly mesh?

The basics:

Apply your texture as a normal map to your highpoly mesh.
Unwrap the lowpoly mesh and add an image to it (to bake to).
Select the highpoly, add the lowpoly to the selection (important to do this last). Bake normals.

With images:

Highpoly + lowpoly meshes

Test render of highpoly + texture

a voronoi texture applied as normal map

Bake setup and result.


To do this, you first must make sure that the object you want to put the texture on is unwrapped.

Then, make sure you are in cycles render and add a new image texture shown below

If you ever want to change how big the texture looks on your object, just scale your UV mesh up or down.


Timeline modal operator: how to get frame cursor to follow mouse

Solved -
in the invoke() function, I set these:

self._initial_mouse = event.mouse_x
self._initial_frame = scene.frame_current

in modal():

self.offset = (self._initial_mouse - event.mouse_x) * -0.1
scene.frame_current = self._initial_frame + self.offset


Animated character exported to THREE.js not animating properly

On GitHub there are a number of open issues about incorrect transforms and animation with the three.js JSON exporter. This is very likely one of those problems... I would try checking there, or exporting to FBX or glTF in the meantime.


Why are all weights set to zero when linking my armature to my character with automatic weights?

Make sure your bones have the checkbox marked: DEFORMER in the properties of the bone. Also, when you ctrl+P make sure you choose with "automatic weights". If you see no vertex assigned colors, chances are your armature bones are not setup to deform.


How to make an object not be affected by light?

It's easy in Blender Internal. Just enable Shadeless in material settings and voila.
For the same effect in Cycles, use this material node setup:


Diffusion confusion - what is the right diffuse shader yor which application?

Use diffuse for diffuse reflection, use glossy for glossy/specular reflection, and mix them because real materials also have multiple types of reflection at the same time.

It is a common misconception to think that diffuse reflection is caused by the surface irregularities/bumps, but this is wrong, perfectly smooth surfaces still can have diffuse reflection. Actually diffuse reflection is caused by subsurface scattering, but the scattering distance for most materials and rendering scenarios is smaller than the pixel size, therefore luckily we can use the diffuse node instead of the slow subsurface scattering node.

For more details, see my answer to a similar question: What is the technical difference between a diffuse shader and a rough glossy shader?


If you are using Blender Internal Render Engine:
In the Properties Window > Texture Tab > Image Sampling Panel > Filter
change it to Box.

Have in mind that this will not have any effect in the viewport preview, but it won't appear blurry in your final render.

If you are in Cycles/EEVEE Render Engine:
In the Node Editor, under your material node tree navigate to your image texture node and set the second pull-down menu Interpolation to Closest


Using Python to create a popup that changes an object based on the input

Use an update method on a property.

Give that whole "athing" thing away. You CANNOT use draw methods to run code to update objects. (The you cannot modify blenddata in this state error)

You can define a button to click that calls an operator, or a property that when changed runs an update. .. which I believe is what you want update method on properties Example below, on changing my_bool if True will call the athing(self, context) method. self will be a reference tot the operator.

import bpy
class DialogOperator(bpy.types.Operator):
    bl_idname = "object.dialog_operator"
    bl_label = "Simple Dialog Operator"

    def athing(self, context):
        if self.my_bool:
            bpy.ops.object.mode_set(mode = 'EDIT')
            bpy.ops.mesh.select_all(action='SELECT')
            bpy.ops.mesh.subdivide(smoothness=0)
        return None

    my_float = bpy.props.FloatProperty(name="Some Floating Point")
    my_bool = bpy.props.BoolProperty(name="Toggle Option", update=athing)
    my_string = bpy.props.StringProperty(name="String Value")

    def execute(self, context):
        message = "Popup Values: %f, %d, '%s'" % \
            (self.my_float, self.my_bool, self.my_string)
        self.report({'INFO'}, message)
        return {'FINISHED'}

    def check(self, context):
        return True

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

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

bpy.utils.register_class(DialogOperator)
# test call
bpy.ops.object.dialog_operator('INVOKE_DEFAULT')


You must be in edit mode, with a mesh selected.


IF what you want is a rigid, mechanical way for the camera to follow the guy, you should put an empty where you want the camera to look, parent that empty to the guy (so that it follows him when he moves), and then add a "Track to..." constraint, with that empty as a target.

This will produce what you're asking for, but as Abedd pointed out, I don't think that's what you want.

This problem has been solved before, in two different ways. One way is to just make the camera do what you want it to do. It might mean you have a keyframe on every frame (probably not), but it'll look at what you want, when you want it to look there.

The REAL solution is a genuine camera rig. You build an armature for your camera that makes it move more like a real camera does. you build different rigs for handhelds, locked shots, crane shots, and Steadicam shots. There are also existing rigs that you could get from elsewhere. I'll bet there's one on BlendSwap, but I haven't looked.

The best solution for you, right now, is probably a really simple rig. Don't spend too much time trying to learn a new skill and new rig, just make an empty that's easy to move around and make your camera look at it. Then you can animate it and the camera at the same time. Don't parent the empty to anything, just use it to control where the camera is looking.


2 different textures are overlaying (Blender Render)

You were correct in adding geometry. However, when vertices/faces share the exact same space in Blender, you will get artifacts that are drawn all of the mesh.

To fix this, simply adjust the geometry so it doesn't share the same space. You can scale it in (with S or AltS) or delete the inside geometry, add a solidify modifier and set the material index offset to the material index of the inside material:

(The material index is zero-based. Thus, the selected materials index is 1)

(Set the material index to 1)

Result:

(Object cut in half for demonstration purposes)


Tutorials are outside the scope of this site. There are lots of good tutorials on YouTube. Just search for "Blender UV Mapping" or "UV unwrap" or "Blender mark seams" and you'll find lots of good information.

To avoid being pedantic, I'll try to give you some kind of answer.

Think of it like a papercraft TV or like you're unfolding a cardboard box. The things you should mark as seams are those places where you'd have two different edges coming together, instead of a fold. You could theoretically mark everything as a seam, and have lots of individual components to texture, but it's typically better to have as few separate pieces as you can manage. Or at least to separate it into pieces that make sense (glass, plastic, etc.).

I hope that at least gets you started.


Faces are now accessible in Mesh.polygons. But seeing that your reference is so outdated, there may be other deprecated API usage in your script. So far, this link is always redirected to the latest Blender Python API manual, you may want to refer to it instead.


Can someone share a link on "how to map just 1 side of a box" and not UV map the entire box?

UV map will contains all the faces anyway (this is structurally how the data is). You can select one face and unwrap it. It will take all the surface normally. But the other faces will exist and all be at 0, 0.

As shown here:

Note:

If you've a previously created UV map, when creating a new one selecting only one face, the other faces will keep the UV of the previously created UV map.


This is caused by multiple armature modifiers on the mesh. Delete one to get better results. Notice that for each number of armature modifiers on the mesh, it (the mesh) is bent again by the same angle.


I closed the file and reopened, deleting all previous caches and now it seems to work. :-b


How to create a loop in Animation Nodes (now that it has been updated)

Shift + A > Object > Instancer

You can also use the Search Tool:

Ctrl + A, then type "instancer"


Look in the outliner window to make sure the camera icon switch for the particle object is enabled and bright.  This means render the object.

It is quite possible to see the particles in view mode and no particles in render for exactly this reason.  You may place your object particle in a different layer to keep it handy and out of camera view except in its role as a particle.

Look in modifiers panel to see if modifier is enabled in render mode.
The area has the eye , then arrow, then camera for each object.

In Render Layers panel, section Layer, verify the scene and layers include your desired results.

Verify your [global] coordinate selection for the particle system object particle suit your intended purpose and the location is not modified by render only modifiers.  Are your particles moved off viewport?

(I used casual explanation and names as per the user interface)

As always I may say something you may already know or have tested.


You can make a script like this:
import bpy

max_saves = 4  # if you have that many saved regions, trying to create a new one will throw an error
               # remove old saves to create a new one

save_name = "restore_render_regions_{}.py"

out = "import bpy\n\n"

for name, scene in bpy.data.scenes.items():
    out += f"scene = bpy.data.scenes.get('{name}')\n" \
    f"if scene:\n" \
    f"    scene.render.border_min_x = {scene.render.border_min_x}\n" \
    f"    scene.render.border_max_x = {scene.render.border_max_x}\n" \
    f"    scene.render.border_min_y = {scene.render.border_min_y}\n" \
    f"    scene.render.border_max_y = {scene.render.border_max_y}\n" \
    f"# --\n\n"

for i in range(max_saves):
    filename = save_name.format(i)
    if filename not in bpy.data.texts:
        break
else:
    raise MemoryError("Number of saved render region states exceeded the limit - increase the limit or " \
        "remove old saves")

file = bpy.data.texts.new(filename)
file.write(out)

Running it will create another script named restore_render_regions_{0}.py with saved region coordinates, so you can run the automatically generated script to restore the coordinates at any time (the Texts are saved with the file).


Why are the colors from color ramps dimmer than what you pick?

By default blender tweaks the final renders colors.
Go to the Render Properties tab (camera), and under Color Management, change View Transform from Filmic to Standard. Now the colors will come out nearly identical.


Trying to get even spaced dimples on a sphere (Golf ball)

You can make a golf ball this way (inspired by this video by Savoir Pour Tous):

Create an ico-sphere with a Subdivision value of 3:

Bevel with Width Type > Percent and Width Percent > about 28%:

You have mainly hexagons and also some pentagons, try to equalize the areas. Select an hexagon and press ShiftG > Area. Select a pentagon and same thing, ShiftG > Area:

Extrude, scale down:

You have a golf ball (yes, a bit ugly because it needs a bit more accuracy):


You could try adjusting mouse settings in User preferences > Input (You can open the user preferences with CtrlAltU, or File > User preferences:

Invert Wheel Zoom Direction inverts the zoom direction when using the mouse wheel in the 3D view.
Invert Zoom Direction inverts the zoom direction when zooming by pressing CtrlMMB.

You could also try the solution posted in this thread on Blender Artists:

  RESOLVED: I received an answer to this question from Tehrasha in the
  Blender.org forum.

  Tehrasha pointed out that one of the buttons on the 3D mouse displays
  a settings menu with options to invert the axes.

  This works for me. The only thing on my wish list now is to remove the
  need to hold down SHIFT for panning actions, as this breaks the smooth
  flying effect of the 3D mouse (it interrupts any rotation). It's odd
  that zoom (forward / back) works regardless of SHIFT state.


How to know what's the radius of a stroke I've already drawn in Blender 2D?

I don't see anywhere this information is displayed in the user interface, but you can get the info from the Python console.
First, in your list of workspace tabs at the top (e.g., probably starting with "Layout", or "2D Animation"), see if you have a "Scripting" tab.  If you don't already have a "Scripting" tab, select the "+" at the right to add a workspace, and select "General -> Scripting".  Click on the "Scripting" tab if it isn't already selected.  It should switch to a view with your drawing in a 3D layout at the top left and a console below it -- a text Window containing blue text like "PYTHON INTERACTIVE CONSOLE" with a ">>>" prompt at the bottom.
In the 3D layout window:

use NumPad 0 to switch to a more usual camera view and better see your drawing
select the stroke in Object mode (it will probably select a bunch of individual strokes all belonging to the same object)
use Tab to switch to Edit mode
type 2 (not numpad, just the usual 2) to switch to stroke select mode
select the stroke you're interested in so it shows up as active (orange).

Now, enter the following command in the Python console:
>>> [s.line_width for l in bpy.context.active_object.data.layers for s in l.active_frame.strokes if s.select]

That should print the radius of the selected stroke in square brackets, like so:
[65]

If you want to see a list of widths of all the strokes used, you can drop the "if s.select" part:
>>> [s.line_width for l in bpy.context.active_object.data.layers for s in l.active_frame.strokes]
[65, 65, 20, 20, 65]

Obviously, this will be a long list if your drawing has hundreds of strokes.


Jagged edges before subsurf, or rounded corners after

First, your mirror modifier needs to be moved to the bottom of the modifier stack. If you subdivide it before mirroring, it will look like its separated, and it's very noticeable in the pictures you shared.
Making edges sharper is very easy. All you need to do is crease them. Just select any edges that need to be sharper/less smooth, and press ShiftE. You can then edit the crease value, a number between 0 and 1. It is 0 by default. 0 means that the subdivision surface will operate normally, and 1 means that it will not touch it at all and leave it completely sharp. The creased edges will also become purple, and this color will be lighter/darker depending on the crease value. Hope this helps!


you need to weightpaint your model. in pose mode you need to hold shift and right click your model. after that go to weight paint mode. then click a specific bone and paint on the mesh its influence. red means this face is affected 100% by the bone. blue means zero. if this is too complex, you should watch one of the many tutorials on youtube :)


Go to the graph editor,

place the 2D cursor at the origin (the arrow on the screenshot below),
choose the 2D cursor as pivot . (the rectangle below)
select all A (or only the keys you want B)
scale S on the vertical axis Y


It's not so much about the lighting, but about the surface of the plane that receives the shadow. If you add a tan/yellow material to the plane, it will show a tan/yellow shadow in the final result. As a general rule, do make your shadow-receiving plane the same color as the ground.


Unbend object bent with simple deform modifier

You can try this way:

Let's say you have object A (your half cylinder). Create a plane (object B), give it a Simple Deform/Bend modifier, bend it 180°:

Overlap the 2 objects (scale object B if necessary), give to object A a Surface Deform modifier with object B as Target, click on Bind:

Bring back object B to  an angle of 0°, object A will follow:


cuda binary kernel for this graphics card compute capability (6.1) not found

I'll just quote  Developer Thomas Dinges' (dingto) post

In order to support Pascal cards, we need to build kernels with the CUDA Toolkit 8. There is only a RC of the CUDA Toolkit 8 available yet, and so far only for registered developers. https://developer.nvidia.com/cuda-toolkit
As soon as the final release is here we will build Blender with sm_61 kernels.


Disable collection on all layers except one?

The following Add-on code can do this for you. Save the code as oco.py and install that file as an Add-on in Blender. You can then activate it when searching for Collection Ops in the Add-ons section of Blender.

Once done, right-click in the Outliner on the collection you would like to exclude for all other View Layers and select the command on the bottom:

Here's the Add-on code:

'''
Created on 09.07.2019

@author: r.trummer
'''
bl_info = {
    "name": "Collection Ops",
    "author": "Rainer Trummer",
    "version": (0, 1, 0),
    "blender": (2, 80, 0),
    "description": "provides functions in the Outliner context menu to work with collections",
    "category": "Object"
}

import bpy
from bpy.props import BoolProperty

#===============================================================================
#    Operators
#===============================================================================
def get_flattened_layer_collections(layer_collection):
    for c in layer_collection.children:
        yield c
        yield from get_flattened_layer_collections(c)

def find_layer_collection(view_layer, layer_collection, **kwargs):
    pool = kwargs.setdefault('pool', view_layer.layer_collection)

    colls = get_flattened_layer_collections(pool)

    for c in colls:
        if c.collection == layer_collection.collection:
            return c

class COLLECTION_OT_Unset_For_Other_View_Layers(bpy.types.Operator):
    bl_idname = "collection.unset_for_other_view_layers"
    bl_label = "Exclude In Other View Layers"
    bl_description = 'excludes collection in all other view layers'
    bl_options = {'REGISTER', 'UNDO'}

    deactivate: BoolProperty(default = True)

    def execute(self, context):
        for vl in context.scene.view_layers:
            if vl != context.view_layer:
                vl_collection = find_layer_collection(vl, context.view_layer.active_layer_collection)
                vl_collection.exclude = True

        context.view_layer.depsgraph.update()

        return {'FINISHED'}

#===============================================================================
#    put the commands into menus
#===============================================================================
def draw_outliner_collection_commands(self, context:bpy.context):
    layout = self.layout
    layout.separator()
    layout.operator(COLLECTION_OT_Unset_For_Other_View_Layers.bl_idname)

#===============================================================================
#    registration code
#===============================================================================
__classes__ = (
    COLLECTION_OT_Unset_For_Other_View_Layers,
)

def register():
    for cl in __classes__:
        bpy.utils.register_class(cl)

    bpy.types.OUTLINER_MT_collection.append(draw_outliner_collection_commands)

def unregister():
    for cl in reversed(__classes__):
        bpy.utils.unregister_class(cl)

    bpy.types.OUTLINER_MT_collection.remove(draw_outliner_collection_commands)

if __name__ == "__main__":
    register()


The Texture tab can be found in the Properties panel, but in the default state of the interface, it may not be accessible; What you need to do is to simply hover your mouse over the list of tabs in this panel, in the top, and use the Mouse Wheel to either scroll, on press it's button and drag.


Objects not in Viewport appearing in Render (Armatures/Rigging)

These 3 objects were hidden in Viewport but not in Render as you can see in the Outliner:


Are animation markers part of the timeline or part of an action?

It depends, there are Timeline Markers and Pose Markers.

Timeline markers are stored at scene level, whereas Pose markers are stored in an action:

# Timeline markers of current scene
bpy.context.scene.timeline_markers

# Pose markers for 'CubeAction'
bpy.data.actions['CubeAction'].pose_markers

In the Dope Sheet editor, switch to Action Editor.

Click the menu Marker > Show Pose Markers to see pose markers.

With this enabled, creating markers will add pose markers!
(Pose markers show a diamond-shaped icon)

With Show Pose Markers disabled, you may select Timeline markers (they show a triangular icon) and click Marker > Make Markers Local to convert them to Pose markers. Note that the original Timeline marker will be gone. If you want to keep it, make a duplicate before you convert (ShiftD, Esc).


Cant change color space of image texture

Its not my awnsers it belongs to @scurest , i saved the image as a png and it worked


How to get radius of a spline in animation nodes?

In the new beta v2.1, which you can download from the release page, the Evaluate Spline Node returns the radii of the samples:


For each segment of the path between two control points, it approximates a cubic Bezier curve:

where P0 and P3 are the control points and P1 and P2 are the handles.


Is there another way besides particles to make fire in the game engine?

You can add a transparent animated plane.
First off, you must change the Shading from Multitexture to GSL.

it must be tiled and evenly spaced like the image below

Because there are four tiles you would check the animated button, and choose one tile along the Y and 4 along the X

you also need to input a frames per second, and how many frames the animation should run for.

Blend file with working animated transparent plane


Option flags for custom properties (bpy.props)

The PROPORTIONAL flag is not related to Blender's Proportional Editing feature, but Multi-Number Button Editing. It's broken in 2.72 for custom properties however.

There doesn't seem to be any documentation in the API docs about this particular option beside what you already found. The corresponding is_... properties seem to be the only documentation.

HIDDEN: True when the property is hidden.See also Hide custom properties in the UI panel with python
SKIP_SAVE: True when the property is not saved in presets. See also this comment
ANIMATABLE: Property is animatable through RNA (should actually be true even if not specified)
LIBRARY_EDITABLE: Property is editable from linked instances (changes not saved)
ENUM_FLAG: Property is an EnumProperty and multiple entries can be selected (ShiftLMB)


Overlapping faces : how to create new faces (interception and complements) with Python API?

Bmesh script

For the case of overlapping circles.

Define two circles on z = 0 plane with centres and radii c1.xy, r1 and c2.xy, r2.

Add them as bmesh circles, edges only no fill. Select the edges of circle 1. Circle 1 needs to be at (0, 0), edit to translate to and back if need be.

The distance between the centres is R the length of the  vector N = c2 - c1. Using the triangle with sides R, r1, r2. apply the  cosine rule (given we have SSS (side, side, side)  to get angle "alpha" opposite r2. rotate the r1' length unit vectorN` by +/- alpha around Z axis to get the two points of intersection **

Using N as the normal and one of these points as a plane coordinate can bisect the circles, and move the cut points to their respective "perfect" circle intersection points. Notice the operators to add emties at the intersection points, will show that they rarely fall on an edge of what is really a regular ngon

Remove doubles.

Fill all edges on either side of and on plane to give non intersection parts.

The non selected edges on circle 1 side plus the selected edges of circle two side give the edges intersection in the middle.

Pass the bmesh contextual create operator the edges. Akin to pressing the F key in UI.

Assign materials 0 1 to circles and 2 to intersection.

Realign the normals.

Test script. run in object mode, first add some simple mesh at (0, 0, 0), assign it three materials, select and run script

import bpy
import bmesh
from mathutils import Vector, Matrix
from mathutils.geometry import distance_point_to_plane as dp2p
from math import sin, cos, acos, degrees, radians, pi
bm = bmesh.new()

me = bpy.context.object.data

segments = 25
# circle 1
c1 = Vector((0, 0))
r1 = 8

bmesh.ops.create_circle(bm,
        radius=r1,
        segments=segments,
        matrix=Matrix.Translation(c1.to_3d())
        )
for e in bm.edges:
    print(e)
    e.tag = True
    e.select = True
# circle 2
c2 = Vector((4, 5))
r2 = 9

bmesh.ops.create_circle(bm,
        radius=r2,
        segments=segments,
        matrix=Matrix.Translation(c2.to_3d())
        )

N = (c2 - c1).to_3d()
R = N.length
R2 = N.length_squared

# half angles

a1 = (R2 + r2 * r2 - r1 * r1) / (2 * R * r2)
a2 = (R2 + r1 * r1 - r2 * r2) / (2 * R * r1)
a = acos(a2)
# circle 1
rot = Matrix.Rotation(a, 3, 'Z')
loc1 = r1 * (rot * N.normalized())
#bpy.ops.object.empty_add(location=loc1)

rot = Matrix.Rotation(-a, 3, 'Z')
loc2 = r1 * (rot * N.normalized())
#bpy.ops.object.empty_add(location=loc2)
# three cases

ret = bmesh.ops.bisect_plane(bm,
        plane_co=loc1,
        plane_no=N,
        geom=bm.edges[:])

for v in ret['geom_cut']:
    if (v.co - loc1).length < (v.co - loc2).length:
        v.co = loc1
    else:
        v.co = loc2
bmesh.ops.remove_doubles(bm, verts=ret["geom_cut"], dist=0.001)

c1_geom = [e for e in bm.edges
        if all(dp2p(v.co, loc1, N) <= 0.001 for v in e.verts)]
bmesh.ops.contextual_create(bm, geom=c1_geom)

c2_geom = [e for e in bm.edges
        if all(dp2p(v.co, loc1, N) >= -0.001 for v in e.verts)]
bmesh.ops.contextual_create(bm, geom=c2_geom)
# intersection
all = set(bm.edges)
tagged = set(e for e in bm.edges if e.select)
untagged = all - tagged
inter = list((set(c1_geom) - tagged).union(set(c2_geom) - untagged))
for e in bm.edges:
    e.select = e in inter
ret = bmesh.ops.contextual_create(bm, geom=inter)

#recalc normals
bmesh.ops.recalc_face_normals(bm, faces=bm.faces)
for f in bm.faces:
    f.material_index = f.index

bm.to_mesh(me)
me.update()

Notes:

Tagged edges seemed to be lost after remove doubles bmesh op, had to use select instead.

Perform some tests to see if circles intersect.

if r1 + r2 == R: # touching
    # fill both circles
    pass
elif r1 + r2 > R: # intersecting
    # do above
    pass
else:
    print("circles don't intersect")

As in a previous question, and this one I've used bmesh rather than operators.  See Python performance with Blender operators Your script in this question (using 9 operators) could be achieved with 3 operators add circle x 2 and join.  However I would recommend not using them at all if possible.

For non circular shapes getting tricky with solidify and boolean modifiers might get the job done.


Where are the rigid body tool buttons in Blender 2.80?

You can either press space to pull up the list of commands you can input and type in rigid body, which will give you the option to copy rigid body settings, or you can follow the instructions on the screenshot.


Animated mesh has incorrect transforms when exported to Unity

As a general rule of thumb, it is a bad idea to animate meshes for use in other applications, there is alot to take into consideration such as world coordinates etc. After animating these, you have very limited control over the mesh in terms of applying transforms or even modifying the mesh later.

Solution, use bones to rig and animate the windmill after applying transforms to the separate parts. Example file with rigged windmill and applied scale and location. By making use of bones to handle the animation, your hard suface model can now be manipulated without the risk of breaking anything else.


Why the mapping/coordinates/size have no effect on displacement modifier texture?

it looks to me that you are trying to modify the material texture not the modifier texture as they are not the same for blender. I am no blender internal expert though


send instructions to blender from external application

You could poll a file with instructions or use sockets (for remote networks) or something else from pythons interprocess communication.

Using a file could be quite simple, the basic idea is to execute the statements in a loop:

Process A                           Process B(lender)
------------------------------------------------------
                                    File exists No -> sleep
Create file with instructions
                                    File exists Yes -> read and execute statements
Does file still exist Yes ->sleep
                                    After execution delete file

While Process-A just needs to print some lines in a text file like:

import,file1.obj
import,file2.obj
import,file3.obj
cancel,none

The Blender side could be timer operator (based on the build in template) it actually reads the commands from the file (the last command 'cancel' deletes the file and stops the timer):

import bpy
import os.path

class ModalTimerOperator(bpy.types.Operator):
    """Operator which runs its self from a timer"""
    bl_idname = "wm.modal_timer_operator"
    bl_label = "Modal Timer Operator"

    _timer = None
    filename='C:\\dev\\command.txt'

    def modal(self, context, event):
        if event.type == 'TIMER':
            if os.path.isfile(self.filename):
                for line in open(self.filename):
                    line=line.rstrip("\n")
                    cmd,arg = line.split(",")
                    if cmd == 'import':
                        print('import requested file=%s' % arg )
                    elif cmd == 'cancel':
                        self.cancel( context )
                    else:
                        print('unknown request=%s arg=%s' % (cmd,arg))
                os.remove( self.filename )
                print('command file removed')
            else:
                print('waiting for command file=%s' % self.filename )

        return {'PASS_THROUGH'}

    def execute(self, context):
        wm = context.window_manager
        self._timer = wm.event_timer_add(5, context.window)
        wm.modal_handler_add(self)
        return {'RUNNING_MODAL'}

    def cancel(self, context):
        wm = context.window_manager
        wm.event_timer_remove(self._timer)
        print('timer removed')

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

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

if __name__ == "__main__":
    register()

    # test call
    bpy.ops.wm.modal_timer_operator()


How to pick a true color from a texture in vertex paint mode?

If you're using 2.80, you can go to the shading menu in the 3d view (in solid shading mode) and choose flat instead of studio lighting.

If you're using 2.79 or earlier, wireframe view will actually give you a shadeless view.


Final Render is different from Viewport Render

The light source I think is the same. The reason the preview render looks so dark is because the samples are much lower so in the final render more samples pick up the light better.

Perhaps you can check light bounces in your render Tab and reduce them to 1 or 2 because the default is always 12 which is often excessive.

Also the lighting is poor in your scene so it's very noisy. Perhaps if reducing the light bounces helps to preserve the darkness of your scene when more samples are used, you could try using the denoiser to get rid of some of the fireflies amd speckling.

If it is indeed another light source causing the problem, go to your overlay tab and check your lights. The eyeball next your objects means it's visible in the viewport and camera tells you it'll be visible in the final render. Just make sure the eyeball and the camera icons correlate if you have multiple lights.

Hope that helps :)


3D software needs to interpret faces with 3 or 4 vertices. Everything else is called n-gon. In this case you have an n-gon with around 26 vertices. Select this face, hit x, delete just this face. than select two vertices in corners (drawing), press F to create edges between them, than fill everything out. With 3 faces this should be solved. You can also try to press K (knife tool) to draw the missing edges.


Blender is seeing my GPU but it doesn't seem to kick on when I render

My Radeon R5 M330 had the same problem, except it listed "Hanian" as the GPU available. I asked a question about how to make it work, and I got answered: Rendering with AMD Radeon R5 M330 gives an error that I can't understand!
The GPU name doesn't seem to do any effect.


Why deselecting an already selected vertex does NOT work?

Actually, yes, you are missing something ;)

The fact is, when you select all vertices of an edge or face, you also select said edge or face (same when you select all edges of a face). In other words, selection of verts, edges and faces are linked together, so if you want to deselect vertices you must first deselect all faces and edges they belong to.

Note that selection operator(s) in editmode take care of that, using current select mode as reference (such that in vertices select mode, deselecting a vertex automatically propagates to relevant edges and faces).


In the image above are three stages of the mesh. Left to Right. Hemisphere.  Hemisphere with a loop cut and delete vertices.  Last mesh image has subdivision surface modifier.

Create enough vertex density appropriate to the model.  Because there is a deep recess with edges near each other you should consider the object as possessing protrusions .. or arms.
Remove Vertices for flowing face density if possible
Hemisphere from sphere
Loop Cut for more density.  This prepares for the deep cut.  You can barely see how the Z height of the cut face area is now half of the surrounding face z height.  Thus allowing more detail.  Loop Cut can be searched.
Delete vertices on Both Sides.  This will allow the deep cut while keeping regular vertex density.
Consider Proportional edit or Lattice to shape the mesh.
Subdivision Surface Modifier
Modify and Improve to your tastes
You are the Artist and can improve the crude mesh depicted above

Most forward mesh to viewer has used proportional edit.  Proportional edit may be searched here at BSE.


Yes if the windows are at the exact same level they will stick to each other, I don't know if there's any other way to solve it than to create a new window and collapse it, like that:

You could join the areas but I doubt it makes it faster as you'll need to create a new window:


Why is shape with shrinkwrap modifier flat?

The Shrinkwrap Modifier allows an object to "shrink" to the surface of another object. It moves each vertex of the object being modified to the closest position on the surface of the given mesh (using one of the three methods available).

from https://docs.blender.org/manual/ko/dev/modeling/modifiers/deform/shrinkwrap.html

So it's totally normal that it's looking like this.

You can use  Vertex Groups:

  The vertex group to control whether and how much each vertex is displaced to its target position. If a vertex is not a member of this group, it is not displaced (same as weight 0).

But in this case it will not help in any easy way. Maybe some detailed Weight Painting could do the trick though.

This is what you can do instead:

Make Curve and convert it to a Mesh or just make this shape by Extruding single vertex. In this case second option would be faster.
Add to it Shrinkwrap modifier.
Add Skin modifier. Turn off Symmetry X Axis and check Smooth Shading.
Add Subdivision Surface modifier.
Go to Edit Mode and select first and last vertex.
With Proportional Editing turned on and fallof set to Sphere hit Ctrl+A and scale both vertices as you want.

This is whole setup:


How do I get rid of curved edges that bridge the two edge loops together in attached model below?

Reasons:

The edge is missing a crease, so the Subdivision Modifier deforms it.
You've enabled the On Cage option in the modifier panel, which prevents you from noticing it.
Your model is too low poly, the Subdivision modifier doesn't know which way to curve the edges.

Solution

Add a crease to the edge, or add some loopcuts.
Disable the On Cage option - it has no benefit here, only hides real geometry.
Add more geometry, so you can better control the curvature.

Add more geometry.
If you only add loopcuts, you'll need to correct the shape.
It's easier to rebuild the model with more sides.


Fade distant geometry into the background (EEVEE)

Rather than 'fade to transparency' you can, instead, 'fade to environment' with the fade acting between your mesh's actual shader and an Emission shader set to mimic the environment - this will avoid the problem of ‘backfaces’ or part-transparent faces showing through. This can be achieved with the following nodes :

Everything within the 'frame' is dealing with mapping the environment onto the surface of the mesh while the Diffuse shader at the top is there to represent your mesh's actual shader.
The Environment texture (an Environment node set to your HDR image) is normally driven by the Generated coordinates but in this case we generate the coordinate based on the Incoming vector. This will shade the point on the mesh with the point in the environment that would have been shown if the mesh was transparent - so effectively making it appear transparent by projecting the environment onto the surface. This is achieved by Vector Subtracting the Incoming vector from 0 (to effectively reverse the ray’s direction). The output of the Environment node drives an Emission shader with its strength set to 1.0 to mimic the environment.
The other nodes calculate the 'fade' based on distance - but only for 'Camera' rays (since we don't want the 'fade' to affect how the mesh interacts with the rest of the lighting of the scene, only how it appears to the camera. The Divide controls how far away from the camera the scene should fade, while the Color Ramp affects the profile of the fade (change those to affect the 'hardness' and distance of the fade).
This can produce the following result :

You would need to do the above for all of the materials in your scene that want to be affected by the fade (in the case of the above example, just the plain floor - so that it blends into the HDRI background of the scene (which provide the trees)).


Yes, there is a Record Animation function:

https://docs.blender.org/manual/en/dev/game_engine/physics/introduction.html


Change Origin and rotate the frame of a mobile robot

select the body, then shift+s, cursor to selected, shift+a, empty-axis, select axis-empty, ctrl+i, then select axis-empty again, right mouse button, parent, object.  This parents to the body position where the axis is and all items are parented to the axis, but are moveable individually.  Move the axis for scale, rotation of all, or just the individual parts.
save a new file doing this to not lose work changed from.  Then add bones BEFORE all this, to selected areas using car rigging methods (search for appropriate online).  You rotate the bones added to the wheels and so forth, that you also parent to the RIG-axis-empty created.
to position all at the world origin, after you have made an axis parent, select the axis, then shift+s, cursor to world origin, then shift+s, selection to cursor.