Bend extruded svg around sphere or extrude svg along sphere normals

I tried the suggested Solidify on a single-skin sphere, but I didn't manage to get the result I wanted. But I worked out a similar approach - with a little more work and without modifiers, that did the trick:

Create Sphere of approriate size
Use Boolean to cut off lower half to get to the desired half sphere and cut out the desired SVG symbol as I did before
Use "Edit Mode" to remove all inner vertices created by the booleans to produce a single skin sphere with cutout as suggested by Robin.

Duplicate the object, scale it so there is a second, slightly larger version of it - as desired for the thickness
Join the two objects and "stitch" the edges with CTRL-E - "Bridge Edge loops"

I had to select the inner cutouts manually, "select loop" didn't work there. But in the end, the result was worth the effort:

Thanks for your help, I hope somebody finds this useful!
UPDATE: I also found out why the solidify didn't work before, I didn't actually use a singleskin sphere (Step 3 from above), but instead I used a boolean operation to cut out the inner side with an only slightly smaller sphere. Which LOOKED single, but actually was a normal doubleskinned sphere. With the singleskinned sphere, it worked like a charm. So, thanks again Robin for the suggestion, you were spot on, if only I had done it right in the first place, this would have worked perfectly!
So, alternative to my more time-intensive method:

Create Sphere of approriate size
Use Boolean to cut off lower half to get to the desired half sphere and cut out the desired SVG symbol as I did before
Use "Edit Mode" to remove all inner vertices created by the booleans to produce a single skin sphere with cutout as suggested by Robin.
Switch back to "Object Mode" and use the Solidify modifier to get the desired effect with a lot less effort :).

Update 2: Yep, it works :)


Blender can import SVG files:
File > Import > Scalable Vector Graphics (.svg)

Depending on the dimensions of the original file, the curves could be very small or big.

If you can't see the imported curves in 3D VIEW, use the Outliner to select them and scale.

Because the origin is set at the point (0,0) of the original file, you could have to set its position.

Apply the scale (Ctrl + A > Scale)

Set material and other stuffs.

Open the Properties Panel and set the Extrusion Value.

If the extrusion is excessive regarding the input value (see the example below), you have to select all the Control Points and reduce the Mean Radius in the Properties (N).

That's it!
Now you can adjust every value as well as for any curve: bevel, resolution, fill type...

I suggest you to read the online manual:

http://www.blender.org/manual/modeling/curves/editing/introduction.html?highlight=curves

http://wiki.blender.org/index.php/Doc:2.4/Manual/Modeling/Curves

http://www.blender.org/manual/modeling/curves/editing/advanced.html?highlight=curve%20extrusion#curve-extrusion


How to export an Image(png / jpg) as glTF?

The imported image is using the "Diffuse BSDF" shader, but glTF has a PBR material system that is based on the "Principled BSDF" shader.

Luckily, you can just swap one for the other to get this working.  Use the "Shading" tab at the top of Blender 2.80 to get to this area, and replace "Diffuse BSDF" with "Principled BSDF":

Additionally, if your image has any translucent parts, set "Blend Mode" to "Alpha Blend" in the material settings (Eevee only) like so:


Is there a way to get continuous radial/polar coordinates?

You could avoid doing the trigonometric stuff the Gradient > Radial node has already done for you, by, instead of avoiding the discontinuity at 0, using it as the start of your segment:

At its most primitive, the start-angle is measured out of 1, clockwise from 9 o'clock, and the segment is anticlockwise from there.This set-up works round the clock, through negative and >1 start-angles.
But I guess the disadvantage is the amount of plumbing you have to do to wrangle the interface into offering you center of arc, angle of arc, in degrees, clockwise from 12 o'clock:

(Maybe there are ways of cutting this down?) ... anyway, that's quite a few nodes to avoid one trig. calculation per shading point. Given modern kit, this is probably old-fashioned :)
Edit:
It may be better to forget the Radial altogether and roll-your-own:

.. which is added to the .blend:


Combining cubes together so they are touching is not the best flow to make a mesh.
If my suggested fixes didn't help I suggest using Extrude tool when creating a single more complicated mesh.
Select a face

Then use combination E Z 2 to extrude it up by 2 units

Select the side face

And type E Y -5

You will end up with a single object with a single mesh (and no islands) that renders correctly.

When animating simply use this mesh for static shots, and when things need to move just hide it, and use your separated meshes.
EDIT:
Issue seems to be visible only in Eevee rendering engine.
Eevee

Cycles


Estimation of focal length when using BLAM

Blams accuracy depends on your line drawing accuracy. Maybe if you would repeat the cube line pixel to pixel it would calculate focal length correctly, but I bet there would still be some minor inaccuracy. As for the mesh reconstruction, even in introduction video is stated, that resulting object will probably not be perfect, so you should expect that. BLAM is not perfect, but certainly changes tens of minutes of tweaking into few minutes of tweaking, so it's not bad at all.


I can't remove dark blue lines is't mark sharp?

With the default theme, "mark sharp" is a lighter blue.  That dark blue is probably a Bevel Weight on the edges.

The easiest way to set them all to zero is to select the edges (or just all edges) in edit mode, and look under the "Item" tab in the right-hand sidebar (the one toggled with "N").  Look under Edge Data -> Mean Bevel Weight and set it to 0.

You can also use Ctrl-E -> Edge Bevel Weight, but that does a relative adjustment, so if you want to set it back to zero with the keyboard, you need to enter "-1 Enter" rather than "0 Enter".


IS there a short cut to add a material and assign it?

A new material can be created with bpy.data.materials.new(). You assign a material to a face by setting it's material_index, which is the material's index from it's location in object.material_slots, we need to use the length of material_slots to know the index of the material we just added to the list.

import bpy

obj = bpy.context.object
obj.data.materials.clear()

for f in obj.data.polygons:
    m = bpy.data.materials.new('FaceMat' + str(f.index))
    # for 2.79 remove the ,1.0 at the end
    m.diffuse_color = (0.01*f.index,0.02*f.index,0.03*f.index, 1.0)
    obj.data.materials.append(m)
    f.material_index = len(obj.data.materials)-1

This is a simple example that sets the diffuse colour used by BI which is also used by cycles for the viewport colour. To create a cycles material you will want to create nodes as well.

You could also do it in two parts, one loop to create materials and another to assign a material based on the material name. This way you could create 10 materials and distribute them across the object.

obj.data.materials.append(bpy.data.materials[mat_name])


Align vertices with curvature of another object

Just use the Shrinkwrap Modifier.

You can read about it in the Blender manual or watch this Youtube tutorial


Minecraft model transparency glitch in cycles

All you need for a transparent material in cycles is a Transparent node, a Mix node, and some base shader (Diffuse node).

These are the only needed nodes.

The Image Texture node sends the color of the image only to the Diffuse shader, that is very important (more on that in a bit).
The alpha of the image is used as a mask in the Fac socket of the Mix Shader node. That Fac "mixes" the two Shader input sockets, biased on the value in the alpha channel of the image (alpha channel shown below). The Fac socket is expecting a range between 0 and 1, and that is exactly what the alpha channel is. Anywhere that is black (a value of zero) the top socket is used, so transparent; like wise anywhere that is white in the alpha channel (a value of one) the bottom socket is shown, the diffuse node and thus the color in the image.

The Transparent node adds the transparent component to the material. The color of the Transparent node controls how transparent the transparency will be. White (a value of one) is completely transparent, conversely black (a value of zero)  will not be transparent at all, it will render solid black.
This is why you can not plug the image texture in to the transparent node.
Anywhere the image is not pure white will not render transparent if the image is plugged into the transparent node.

This is the alpha (on the left) of image in image texture node in the picture above; and (on the right) the output of the nodes pictured above.

Advanced nodes

Here is a slightly more complicated cycles material. All I'm doing is adding in a glossy component to my material.
Do note though, that even with the extra nodes, it does not change the simple transparency setup.


You need to give some weight corrections, see the weight of this bone, it should not influence the last phalanx:

You need to reassign the vertex groups correctly, either in Weight Paint mode, or with the vertex groups in the Properties panel > Object Data. You'll find these bones on this layer:


Final result:

Node setup:

Final thoughts:

It's not the same as Voronoi Texture but it's fast and pretty simple.
You can play with Wave Texture's (both of them) values to get more jagged/smoother cracks.

I've used Bump but you can connect it to Displacement if you need.

Blend file:


I think you should track for one eye and then parent another camera to the first and adjust the distances between the two and also the rotation until it looks right.


What is the best way to model this indent

I don't pretend this is the best way, but that can be something like this:

The idea is to loop over the indent and "protect" the external part with an additional edge loop which allow also to reduce the vertex count progressively to the external parts.

But what you concretely need to do may be very dependent on your model as it is for now.


Is it possible to snap 1 or more vertices on a face?

You can do this with the snap tool.

First, modify snapping behavior to Snap to Face like so :

 (toolbar on the top of the viewport screen)

In edit mode, select all the vertices you want to snap to the faces.

Then go into orthographic mode (numpad 5), align view to the "x" axis (numpad 3)

Type G (to move the vertices) and X to constrain to the x axis, and move your mouse to the right a fair bit, Hold CTRL (to force snapping), then click. You will not see any change in the viewport but if you orbit around your objects you will have this result :


In this setup, you will need to add keyframes for the kinematic property. The kinematic property should be enabled during the beginning so that the object movement is controlled by the animation. Right before the two objects collide, the kinematic property should be disabled so that the rigid body simulator takes control over the object movement.

Here is an example for how to modify your script so that the kinematic property is disabled at frame 12:

bpy.data.objects['Cube'].rigid_body.kinematic = True
bpy.data.objects['Cube'].keyframe_insert(data_path='rigid_body.kinematic', frame=1)
bpy.data.objects['Cube'].location = [-5,-5,1]
bpy.data.objects['Cube'].keyframe_insert(data_path='location', frame=1)
bpy.data.objects['Cube'].location = [0,0,1]
bpy.data.objects['Cube'].keyframe_insert(data_path='location', frame=20)
bpy.data.objects['Cube'].rigid_body.kinematic = False
bpy.data.objects['Cube'].keyframe_insert(data_path='rigid_body.kinematic', frame=12)

bpy.data.objects['Sphere'].rigid_body.kinematic = True
bpy.data.objects['Sphere'].keyframe_insert(data_path='rigid_body.kinematic', frame=1)
bpy.data.objects['Sphere'].location = [5,-5,1]
bpy.data.objects['Sphere'].keyframe_insert(data_path='location', frame=1)
bpy.data.objects['Sphere'].location = [0,0,1]
bpy.data.objects['Sphere'].keyframe_insert(data_path='location', frame=20)
bpy.data.objects['Sphere'].rigid_body.kinematic = False
bpy.data.objects['Sphere'].keyframe_insert(data_path='rigid_body.kinematic', frame=12)
```


True surface displacement can be achieved with tessellation and a Displace modifier.

There is also a new Experimental Cycles Displacement node, but since it isn't continuous across face boundaries, it creates gaps between faces.

Cycles - What is the expected range of values for Displacement?


Create GUI for selecting, creating or opening image

UILayout.template_ID

For ID types like image use the template_ID method.  As seen by viewing source of the image editor space, where  sima = context.space_data

layout.template_ID(sima, "image", new="image.new", open="image.open")

  What do you mean with the image editor space?

I mean look in blender for UI that matches, in this case I've arbitrarily used the header of the image editor.

With developer extras turned on if right click on open button,  select view source the text editor will open code and point to the code above.  This is the image set to the image editor.

In your case, going by answer simply change sima with env.  Will work for any blender object that has an image attribute that points to an image bpy.types.Image

Give some class an image

Can add an image to your custom class

class Foo:
    image : bpy.props.PointerProperty(type=bpy.data.Image)

    def draw(self, context):
        layout = self.layout
        layout.template_ID(self, "image", new="image.new", open="image.open")


You need to change the Fill Mode from the Properties Window > Object Data > Shape > Fill Mode.

This will vary depending on whether your curve is set to 2D or 3D. Either set it to Full for 3D, or None for 2D.


Cannot insert keyframes; incomplete "Insert Keyframes" menu

I'm not sure about the file size but that is the correct menu for the dope sheet editor. For the full menu press "i" over the 3d view instead.


There are various ways to accomplish this. I will share two methods that I've found work well.

1. The Transmission Mask Method (for stills)

This method involves modeling a simple foot object that will pass in front of surfaces that are to appear wet or imprinted upon. The wood material in this case uses the Light Paths node to mask between wet and dry shader mixes. The "Is Transmission Ray" output from the Light Paths node factors the mix in a way that any light hitting the wood material that also passed through either a Glass or Refraction shader will be shaded with the wet mix - else it will be shaded with the dry mix.

This is quick and easy to set up, however if you think you may have any objects made of Glass (for example) passing in front of your wood they too will trigger the wet material. As long as you plan your scene in advance, and know what else will be between the camera and your wood material, you can probably get by with this quick trick.

Use a Refraction shader on the footprint object with the IOR set to 1 so that no refraction actually occurs, but the rays passing through will now be considered "transmission" rays.

Here is a demonstration of the principle in its most basic form.

Basic transmission mask setup:

As you can see, while this has the advantage of being quick to set up, it has disadvantages as well. It doesn't render as transparent where the background is transparent. Also, when viewed from the side the sphere occludes more of the plane than you'd want. Instead of a circular area being yellow, you get a whole silhouette of a dome that is yellow. You might think that if you flatten the sphere enough you will get a circle, and this is true - however if you want to animate something like a footprint you will want the intersection to happen over the course of several frames, meaning the footprint-shaped object must have some depth to it. Adding depth means the silhouette will become at least somewhat visible when viewed from the side and look strange. This is why I present this solution as being alright for stills but not so good for animated scenes.

Example result:

(Thanks for the wood texture, Pixabay!)

Example node setup:

In the above example I subtracted the wood cracks from the mask because they don't need to appear wet, they just need to appear dark - and the glossiness of the wet mix was actually lightening them which didn't look natural, so I did a low-cut to exclude the really dark areas from the mask. This probably isn't necessary to do with most textures.

Note that passing through transparency is not "transmission", so you can even take it further and map fades between Transparent Shader areas and Refraction Shader areas if you a want a smooth falloff. Here is an example of a setup that creates a soft-edged footprint using the Z-height of the mesh:

2. The Wet Map Method (for stills and animation)

This method takes a bit longer to set up, but it's the right way to do it. And it works really well for animation.

Part I. Modeling and animating the brush and canvas objects

As with the transmission mask method, a footprint-shaped mesh object is required. I modeled mine starting with a trace of your reference image. Since the shape will move through the plane over the course of several frames, it needs to have some thickness for the imprint to be animated. I used the same mesh object for both. Here is what it looks like. Notice how it is intersecting with a plane.

The footprint-shaped mesh is your "brush object". The wooden surface is your "canvas object".

The foot and toes are rigged to a very simple armature so that they curve with the step. The water droplets are not rigged to the armature - instead they are animated with a Shape Key because I thought it would be simpler not to have a bone for each, but I wanted them to hit on separate frames.

I animated the step to come up through the plane instead of down into it, but it doesn't matter which direction you come from as long as the "brush" object intersects with the "canvas" object. The brush object must be a closed volume.

In most cases the brush object should move away from the canvas object after stamping into it. If it remains intersecting with the canvas object, it will continue to soak and spread out the wetness. Such soaking counteracts Dry and Shrink effects, if you use them (more on these later).

Unlike in the transmission mask example, we don't want the footprint objects to be visible to the camera. So uncheck these boxes in the Object Context under Ray Visibility:

Part II. Using Dynamic Paint to Create Wet Maps

Go to the Physics Context.
Select your canvas object and click “Add Canvas”.
Select your brush object and click “Add Brush”.

The default brush color is blue, which would be relevant for a paint map, but not for a wet map. A paint map transfers color information. A wet map transfers greyscale data mapping how wet a surface is, with black being dry and white being wet.

In the Dynamic Paint section, set the format to “Image Sequence”.

Specify the resolution of the output images.
The default 256 is good for initial testing, but you will want your final one to be higher.
Use your judgement depending on the size of your painted object in your scene.
This value is for both the X and Y dimensions, because your UV area is always a square.

Set the start and end frames for your animation. An image will be output for each frame.
Specify how many Sub-Steps you want to be calculated for smoothing the animation. If the brush collides with a face perpendicularly, Sub-Steps are not necessary because it will pierce through rather than trail across. See the step-count comparison below on a sphere that moved across a plane over the course of 6-frames:

Unwrap a UV map for your canvas object.

Specify the UV Map to be used (you probably only have one to choose from).

Specify the file path for your output images.

Press the button to “Bake Image Sequence”. The cursor will show the percentage done.

Once you've done a test bake to confirm that it's working, there are a couple more adjustments you can make to enhance the realism of your wet map.

Enabling the Dry option makes wetness gradually fade with time.

Enabling the Shrink effect makes wet imprints get smaller as they dry up.

Experiment with these settings if you want to simulate your footprints drying over time.

Part III. Using Your Wet Map in Cycles

After creating a new material in Cycles, open the Node Editor.

Add an Image Texture node and load the image of the first frame of your wet map sequence.

Change the source from “Single Image” to “Image Sequence”.

Set the number of Frames to be the number of images (frames) in your sequence.

Set your Start Frame to the frame in your scene when you want your wet map to kick in. In other words “wetmap0001.png” (or whatever yours is called) will begin at this frame.

Leave the Offset value at 0.

Enable the “Auto-Refresh” option.

Add a UV Map node and plug its UV output into the Vector input of the Image Texture node. Specify the UV map to be the same one you used for your canvas settings.
You might not need to do this if you only have one UV map on your object, since Blender will probably auto-detect it and know what to do - but it’s a good practice. It is necessary if you have multiple UV maps on your canvas object.

Example node setup:

Note that I didn't go so far as to factor in the wood cracks in this example since I wasn't rendering close-ups, but of course you can easily integrate that into your node setup if you want to. (See the example node setup for the Transmission Mask Method)

Example result:

In the examples above the drying effects have been unrealistically sped up for the sake of demonstration...and because it looks kinda creepy.


All your pole targets are setup incorrectly (the pole angle). Causing the chains to move in Pose Position.

Also there is pole target on the thumb which you probably don't want.

I suggest this reading for pole targets: How to Set/Calculate pole angle of IK constraint so the chain does not move?

You don't want the fingers to have any IK. You should control them only by FK. IK fingers are very advanced and rarely needed. You can still have 1 control bone to drive the finger bone chain (scale to curl/close the finger (try it, you can't rotate the finger parts individually), rotation to point it)

Further I suggest look into some already made armatures(cgcookie flexrig, sintel, search blendswap, rigify, etc.) how it should be setup. You will have problems animating this and the animations won't look nice. There are problems with shoulders, legs and spine.


Making Property sliders act similar to Operators

You can use the 'update' function value that can be assigned to the property's definition:

Update function is triggered each time the slider's value is changing.

import bpy

class SomePanel( bpy.types.Panel ):
    bl_label = "Property panel"
    bl_space_type = "VIEW_3D"
    bl_region_type = "UI"

    def draw(self, context):
        layout = self.layout
        scn = context.scene
        layout.prop( scn, 'someValue' )

#Update function example:
#self is the object to which you have assigned the property
#context is similar to the context given in the execute function of an operator
def whenUpdate( self, context ):
    if context.active_object:
        context.active_object.location.x = self.someValue
    print( 'update', self.someValue )

def register():
    bpy.types.Scene.someValue = bpy.props.FloatProperty(
        name = "Float",
        description = "Enter a float", min = -100, max = 100,
        update = whenUpdate ) #Assign the update function here
    bpy.utils.register_module(__name__)

def unregister():
    bpy.utils.unregister_module(__name__)
    del bpy.types.Scene.someValue

if __name__ == "__main__":
    register()


Where is nodes for altering the strength of the sun?

Just go into the node editor with the lamp selected and turn on USE NODES in the settings. If it is already toggled check for a emission node where you can up the strength. Hope it helped mate!


You need to slightly offset the road along the Z axis. This is what is called "Z-fighting" where the renderer does not know which material to render because the faces are overlapping, so they are randomly rendered on top of another.


How do you add a fog effect or make certain things seem farther away?

There are at list 2 easy ways to accomplish that, one is while rendering, other is post-process the render. If you want to do it while rendering (will get slower render) you have to create a volumetric object, with volume absortion nodes (under material). To do on post process (will be faster) you have to activate while rendering the option "mist pass". After rendering, in the compositer, you can link the mist pass to your rendered images and set density, color, etc. https://www.youtube.com/watch?v=CxNeMMZs_sM


How make my shape manifold? Substract one face from another?

You're looking for Ctrl+E > Bridge Edge Loops.


2.8 is not released yet. I don't think it is very reasonable to expect technical support for installing software that is unfinished yet. You could try reinstalling graphics drivers, any other drivers that are not up to date on the PC, also you could try to re-download the latest build once in every few days and try if that works. Else than that - it is experimental software at this stage. Don't be surprised if it does not work yet.


Texture Baking in Cycles, I'm getting no Colour

Plugging my procedural textures and image textures on to a diffuse shader node before mixing fixed the problem I was having.


Dividing terrain mesh up into multiple tiles with script - border gap issue

Finally got this working, turns out you require an overlap on both DEM and Sat image

and I had to tile both in QGIS before bringing them into Blender

Full description of the resolution here:
https://github.com/domlysz/BlenderGIS/issues/172

And summary of fix for issue:

  The overlapping of 1 pixel for DEM tiles help to compensate the loose
  of last column and line when connecting only pixel's center, this
  trick allows to obtain perfectly joint tiles.

  The overlapping for satellite tiles help to compensate the difference
  of tiles size between the 2 rasters datasource because even if the 2
  rasters have the same extent, as long as they don't have the same
  pixel size in meters then dividing the number of pixel by 4 will not
  produce a cut at the same coordinate.

Figures for my assets:

DEM 1253x1253 >> retile 315x315 with 1px overlap
SAT 10020x10020 >> retile 2600x2600 with 95px overlap

I used GDAL process 'Retile' in QGIS to divide tiles + overlap.


Texture on the wrong side of eyes after import from MakeHuman

If you look closely, you will see two layers in the eye. The exported MakeHuman model contains the cornea of the eye as well (the clear layer that covers the eye). In the viewport this appears white, but when rendering it should appear mostly transparent.


How do I create a single object with two different texture and UV maps?

I found two problems with your model:

Your fringe faces also exist on the coyote model, but there they do not have a transparent texture. This causes the white parts on the fringe. Remove the fringe faces from the coyote. The result should already look better:

There are still some faces with flipped UV coordinates, like the ones on the hind leg of the coyote, and the UV coordinates of the fringes unter its chest lie on a part of the texture without transparency, but these should be pretty easy to fix.
This problem is actually not your fault, but just how graphics cards work. The sections of the coyote that became transparent are caused by the order in which the faces of your model are drawn. When a face is shaded (meaning when the color and lighting calculations are performed) the first thing the graphics card checks is the distance of the triangle to the camera at the current pixel. If there was already another triangle drawn at this pixel which was closer to the camera, the lighting calculations are skipped (see Z-culling), because usually the old triangle would occlude the new one anyways.
But if the old triangle actually was transparent at that pixel you will get the visual artifacts you can see in you model: The old triangle did not produce a color at the pixel since it was transparent and the new one is skipped. This is how you get the holes in your coyote.

The only real solution to the second problem is rendering the triangle that is furthest away from the camera first, then the ones closer to the camera. If you want to use this model in the blender game engine you can make Blender do this sorting for you. Create a material for the coyote and give it your image as texture. Make sure the texture coordinates are set to UV and the texture affects the alpha channel of the material. Go to the material settings, enable transparency and set the alpha value to 0. Then activate alpha sorting. Do that for both the coyote body and the fringe.

 You can also join both meshes (select both and press [Ctrl+J]) and just use different materials and UV coordinate sets for body and fringe.
Since all these settings are a bit hard to explain without writing a full tutorial, here is the .blend. Just have a look at the materials.


Bridge Edge Loops from the Ctrl E Edge menu is a pretty good lofting tool, with some limitations.

You can select multiple loops at a time.
It will loft meshes, not curves, and is only really satisfactory when the loops' vertex counts are the same.
You can make adjustments to the number of cuts, and interpolation, between loops
It's destructive.. you can't adjust later
If you want to loft along a curve, you would do that by hand, perhaps by assigning a 'Follow Curve' constraint to the profiles as separate objects before joining and bridging. See @batFINGER's answer here

Bsurfaces was a more flexible tool for lofting, IMO, but it's broken now. I would love to see it come back to life. If it doesn't, maybe if/when I get good enough at scripting, I'll give it a shot, in 2.8


The leaves generated by the Sapling addon are already unwrapped. You should be able to texture them without unwrapping.

Incidentally, you can unwrap them the same way that the addon does by choosing "reset" as the unwrap mode. This just maps each face to the whole UV area, so you can use one image for all of them.


Transforming multiple objects to have equal dimensions

Just press the Alt key before clicking any of the value text boxes and inserting you values.

That will affect all selected objects instead of just the active one. It will also work for modifiers and most other properties.

Edit

If all your planes belong to the same object you have to separate them before controlling sizes directly, since absolute size control will only work in Object Mode, not Edit Mode.

Enter edit mode in your planes object
Select all with A
Separate all planes with P > Loose Parts
Now exit edit mode
Select all separated plane objects
Move their object center to the center of the geometry so their positions wont change when you change their scale, by pressing Shift + Ctrl + Alt + C > Origin to Geometry
Now you can change size

Don't forget to apply transforms afterwards with Ctrl + A > Scale


For scenes where the light bounces around a lot (think indoor scenes) you're going to need more samples.  Renders that look good at only 50 samples are probably more open than yours.

That being said, setting max bounces to 0 will get rid of your fireflies, but you will also lose all of the nice bounce lighting.  And at that point you might as well use the blender internal.  My advice is to turn up your samples and go get a cup of coffee.  I wouldn't worry about it.


How to make animated armature move in opposite direction

You chose to both parent the armature to the curve with Follow Path AND to give it a Follow Path constraint. You should choose either one or the other solution.

1) Follow Path constraint: So, first solution, unparent the armature and keep the Follow Path constraint. In the Follow Path constraint, choose the curve as Target. Click on the Animate Path button. If you see that the armature goes in the bad direction, select the curve, go in Edit mode and click W > Switch Direction. If you want to control the speed of the animation and the position of the armature at any time, you need to remove the Generator that has been automatically generated when you pressed the Animate Path button: Select your curve, go in the Graph Editor, on the left panel unfold the BezierCurve track to select Evaluation Time, then display the Graph Editor properties panel with N, select the Modifiers tab, and remove the Generator. Now to control the speed and position of the armature keep your curve selected, go in the Properties panel > Data > Path Animation, and put some keyframes on the Evaluation Time.

2) Parent with Follow Path option: Second solution, instead of Follow Path constraint you could prefer to simply parent with Follow Path option, in that case, same thing, if you see that the armature goes in the bad direction, select the curve, go in Edit mode and click W > Switch Direction. Then delete the Generator and use the curve Evaluation Time to animate the armature.


How to turn off symmetry in texture paint mode

This option is only available in the upcoming version, 2.75. It's not present in Blender 2.74 so there is no way to enable or disable it in this version.

You can either wait for the 2.75 release or if you want this option right now, download a release candidate version of Blender:

http://download.blender.org/release/Blender2.75/


How to do number-pad actions like: "Number-Pad ." to zoom into an object

In User Preferences, under Input, there is an option to emulate the Numpad (makes regular numbers function as numpad numbers). You can then zoom using the regular + and - keys as well.


EDIT

To create a bent conical object. Start with a Curve and a Bezier Circle (Add Curve->Circle) as Bevel object:

Then change the Radius for the control points of the curve:

Other Ideas:

Do the whole object as a curve:

then fill it as a 2D

Then add a bevel:

If you add a Curve->Circle as a bevel Object you can so something like this:


I began with a cube that I subdivided smooth several times. And actually I ended up with a sort of UV Sphere. But anyway you could include the 6 holes part anywhere in a smoothed cube, as shown with the second sphere.

Note that in my modifiers stack I've used a Mirror, then a Subsurf, then a Shrinkrwrap.

The Target of the Shrinkwrap is also a smooth subdivided cube (or UV Sphere),as big as my object. It allows my object to nicely stick to a spherical shape. In my screenshot I made it invisible, of course.


A topology is an elementary thing of everything, you can animate high poly sculpt, it would be a pain and your computer would just explode. Good topology makes model deform in a good way with low effort.
It doesn't matter if you start with low poly from scratch or model a high poly and then do a retopology. As long as you want to manipulate the model and animate it you need the low poly. If the model is just for printing or visual it doesn't matter that much, but even tho good topology makes things easier.


Animation Nodes - Offset object location

Ok I find the solution, you can update the "Initial Transforms" value. To do that:

Select the "Object ID key" node
Select the object that need to have the Initial Transforms update
In the Tool panel of the 3D view, go the the AN tab
Click on "From Current Transforms"

Repeat for each object and it works!


In my case, my character does not appear because it was restricted for rendering (or invisible for rendering)

Bad configuration:

Bad result:

Good configuration:

Result:

The solution is "Restrict rendering"

Good Luck!


Why is my animation not correctly keeping location and rotation?

This is a perfect example of why we should use Quaternion rotations instead of Euler, when more than 2 axes of rotation are involved in a movement.
To simply solve, you can go to the first frame, switch to quaternions, insert a rot keyframe, turn back to euler, go to the second keyframe, switch to quaternion, insert a rot keyframe. Solved.
For this kind of objects it's better to build an armature or use some empties, make them parents of the objects, and use them to animate, so that those simple movements happen on a single rotation axis, and they get easily edited and automatically avoid theese problems.
Also, you should get the good habit of apply your rot and scale before animating (Ctrl A), and use real world dimensions (now it's 90 meters wide).


Step 1) Create a cube object, create a different cylinder object.

Step 2) Enter edit on the cube and unwrap it as you wish.  Object mode, select the cylinder, unwrap that as well.

Step 3) Still in edit with the cylinder selected, open a UV editor window.  'a' select all vertices.  'g' 'x' '512' to move it 512 pixels in the x axis.  If you have an image open, you will need to use a different number of pixels, equal to the x resolution of your image.

Step 4) Leave edit mode.  Select both the cylinder and the cube and join them (ctrl j).

For your ultimate goal, you migh find a UV Warp modifier useful.  By scaling -1 about the x=1 (UV space, not pixel space) axis, you can achieve something similar to what you want.  (Not necessarily the same, as you are probably translating, not mirroring.)  Once you create this modifier, it can easily be copied between objects using the ctrl-L menu.  Offering this in case this is an easier way to achieve your ultimate goal that scripting is.


Blender 2.8 (python) - how do I get the vector of the direction the camera points

Since a clear rotation camera (0,0,0) point down z-axis.

So the vector should be $camera\ rotation\ matrix\times Vector(0,0,-1)$

In code:

v = Vector((0,0,-1)) #Down vector
v.rotate(camera.rotation_euler)

v #this vector

  Except

  Keep in mind that camera can have another transform by parent offset and some other modifier. If the camera rotation is not pure, you will need to apply the transform to that rotation as well.


How can I export UV Baked Image Filmic Log Encoding Layer (Save as Image)

By changing color space you don't actually change the image itself but rather the view of it, same image seen differently.
If you want to bake the view in the texture you need to check save as render when you save your image.

But what is it for? Will your texture will be lighted in the other program?
If it's the case it's isn't a good aproach, better bake it as an Albedo.
The transfer fonction of the filmic from scene referred data to display referred data must be the last operation on the image. It means that if your texture will be light after Blender you would need filmic in the other software.

EDIT1

You're not in the right place to manage color, here it's just the color space of the texture when you look at it.
To save your image with the right look you must :

-Go in the scene tab
-Under color management set display device to sRGB, view to Filmic Log, and look choose the one you want.
-After that you can save your image.

EDIT2

I think I have the point now, you are confused by what happens in the image editor. When you rendered your texture and saved it, you already baked the filmic look in the texture, then you load the texture in the image editor and change the color space to filmic.
What is happening in image editor when you change the color spaces to Filmic is that it bring back the transformation to linear (only if you baked your image with filmic).

The steps you made:

Linear scene referred datas (raw render) to BT.709/Filmic Log color space (saved image)
BT.709/Filmic Log back to linear scene referred data.
Consider the image color space in the image editor a invertor of thansformation curves.

Like this you can encode a linear scene referred data (that you can normally only export in EXR 32bit) in a 8/16bit image (with the possibility to decode back to linear scene referred data) exept for the desaturation part of the Filmic. I think to decode back without loss you'll need 16bit image.

So for your need, bake your image with the Filmic (like I said in the Edit1 part), then put it in your other software (emission shader or so, strength to 1) you're done.

And if you want to see a texture in image editor let it by default unless you know why you change it. In your case you must set it to sRGB EOTF.


Why am I getting frame rates less than 2 frames per second for my animations when I have an nVidia GeForce GTX card?

2 frames a second on an animation render is pretty good, considering even most simpler animations + keyframes render at about 1.5-3 seconds a frame are the times most home PC GPU renders get on a render.
If you're sure these are bad frame times, you could try checking if Blender is actually using the GPU to render (if you're running cycles that is):

As others have said, it also depends on what GTX card - There's a big difference between a 1080 and a 1050.
Honestly though, like I said, 2 frames per second on any animation is not bad at all.


Why can't I add sky nodes to a lamp in Blender Cycles?

You cant add sky nodes to a lamp, you have to create a new World "material" and add nodes to it's setup, not the Sun lamp.

In the Properties Window go to the world tab (Fourth tab with a blue globe) and add a new one there if there isn't one already.

Then in the Node editor Window switch to World node type in bottom header, second button with the same blue globe icon.


Break a loop animation (Make Cyclic) to start a new one

I guess you will have to do it by the NLA Editor: push your first animation in the NLA Editor (down arrow), open the N menu of the NLA Editor > Animation Tab > Action Clip > Playback Settings > Repeat as much as you want, come back to the Dopesheet in Action Editor mode, create your second animation, then push it in the NLA Editor, by default it will appear on a second track above the first one, then move the clip of this second animation where you want it to interrupt your loop.


Add enum property to existing dropdown menu

scene.cycles.bake_type is already registered as a property of the CyclesRenderSettings class.  We can get the details of the enum from the class itself, or in the example below from  the instance; scene.cycles.rna_type.properties("bake_type")

Add a new item to the enum property list and redefine the property with our appended list.

import bpy
from bpy.props import EnumProperty

context = bpy.context
scene = context.scene
prop = scene.cycles.rna_type.properties["bake_type"]
items = [(i.identifier, i.name, i.description, i.icon, i.value)
              for i in prop.enum_items.values()]

# add one
if 'FOO' not in [i[0] for i in items]:
    items.append(('FOO', "Foo", "New Foo Item", 'NONE', 11))

    bpy.types.CyclesRenderSettings.bake_type = EnumProperty(
                                             name=prop.name,
                                             description=prop.description,
                                             default=prop.default,
                                             items=items)

Would need to append a draw method to the panel that recognises the new enum prop 'FOO'.

Note: could get some hassles if cycles code doesn't know what to do with your new bake_type.


How can we explain texture effect on the point light

This is caused by the color of the Diffuse surface. A whiter surface reflects more light, while a grayer surface reflects less. The only difference between the below planes is the color, the distance from the light source and the other material options are identical.

As you can see the difference is quite pronounced. The whiter plane (right side) reflects much more light. When you use a texture to drive color, you are mixing the two of these, resulting in a more broken up diffuse shading.


Can I create a CollectionProperty of brushes?

Make a PropertyGroup with a brush type member.

Can use a pointer property to point to an ID type, in this case a brush. brush = bpy.props.PointerProperty(type=bpy.types.Brush)

import bpy

# Assign a collection
class SceneSettingItem(bpy.types.PropertyGroup):
    name = bpy.props.StringProperty(name="Test Prop", default="Unknown")
    brush = bpy.props.PointerProperty(type=bpy.types.Brush)

bpy.utils.register_class(SceneSettingItem)

bpy.types.Scene.brushes = \
    bpy.props.CollectionProperty(type=SceneSettingItem)

print("Adding All Brushes")

for brush in bpy.data.brushes:
    my_item = bpy.context.scene.brushes.add()
    my_item.name = brush.name
    my_item.brush = brush

Python console check after running script above.

>>> C.scene.brushes['Twist'].brush
bpy.data.brushes['Twist']


This specific structure is a bit complicated by using normal methods, such as other guys suggested, However, you can do it quite well by a combination of a few modifiers:

Create the unit model for half round of the bandage;
Subdivide, tweak position of each vertex;
Model the other half round of that bandage.
Add Shrinkwarp, Array and Solidify modifier.

Tip: Shrinkwrap modifier is always not so "accurate" by default, but using VGroup with weights assigned will make things more flexible.

example file


Eevee - Mesh light illuminating scene from within glass (i.e., light bulb)

Couple of things to note here.

Mesh lights do not work in EEVEE the same as Lights (mainly they do not cast shadows). I've pointed to it here: In Blender 2.8, how do I light an EEVEE scene with an HDR?
You can use Point Light to have effect you want without baking anything. Use Radius and Strength to manipulate it.
You need to turn on Screen Space Reflections with Refraction for your scene:

For the Glass material you need to properly set below options to be able to see light source and allow it to light the scene:

Keep Solidify modifier on the Bulb object. What is strange is that even with value 0 it is working fine :)


How can I change the color of fly/walk mode crosshair?

This option is now supported, but not in time for version 2.70. Later versions will have this option and meanwhile you can download a daily build.

To change this setting go to: User Preferences > Themes > 3D View (on the left) and select View Overlay.

The option affects:
- the cursor (fly/walk and the default black part of the 3D cursor),
- the camera guides (enabled in Camera Panel > Display), and
- the stippled line guide that appears when scaling objects.


How to insert key to a constrained bone with "child of"

The "Child Of" constraint is a tricky one to get right. I would recommend using multiple parent objects, and adding a "Child Of" constraint for each parent.

Create a parent empty on the ground at the "pick up" location.
Create a parent empty on the ground at the "put down" location.
Create a parent empty that you parent to the hand bone.
Create three "Child Of" constraints, one for each parent empty.

Now you can animate the influence of each constraint. When the sword should be at the "pick up" location, that constraint has an influence of 100%. When the sword is picked up, the "hand bone" constraint gets 100% influence. When the sword is put down, the "put down" contstraint gets 100% influence.


Join all faces in a mesh together at once

In Edit Mode select all, Merge by Distance, and keep increasing the merge distance from the default value until all the intersection points merge.


How to lock vertex to axis during bone rotation?

Consider setting the deforming bone option Relation Parent [Inherit Rotation] False as depicted below.  The bone will still be moved by parent movement.

Here a parent bone is rotated.  Parent bone set to [deform] False.  This is an attempt to emulate your images in the question.

Below a bone constraint.

You can restrict bone axis movement.  In general restrict bones rather than vertices.

The default armature automatic weights were accepted.  Weight paint mode below.

The vertex density supports the curved images.


Imported 3D scan displays texture in editor, but renders without texture

Even though you might see an image on texture view, you need to assing a material that uses that texture.

Create a material and assign your texture to it:


Does Blender API have any evaluation function for Bezier curves?

Ok I found it: mathutils.geometry.interpolate_bezier().


The file you sent seems to work fine for me (Running Blender version 2.75a):

Make sure "Custom Weight Paint Range" in the User Preferences under System is unticked:


Is there a way to delete unneeded keyframes automatically?

Yes you can.

In the Dope Sheet, select all channels by pressing A while hovering over the list of channels, then press O. All unnecessary keyframes will be erased.


I can't point out the exact issue without the blend file. My best guess is that you should check the harden normals checkbox in the bevel or use the weighted normals modifier.


When can a Color Ramp be used to create a gradiant in a Cycles shader?

The ColorRamp node only remaps existing information. So without an input, you will only get a solid color as output (the solid color in the middle of the ramp, to be exact).

This is easily fixed by providing an input, such as a procedural gradient texture node:


How can I make this weaved pattern more realistic?

First of all you should work on the texture. You can do it procedurally (for example mixing some Wave node textures) but the easiest way to do it is to use a repeatable wood image texture. Then you can duplicate this material and vary the color with a Color > Hue/Saturation node. Don't forget to put a bit of glossiness at the end.


How to make emitted particles disappear when they hit a surface?

On the object that should make particles disappear when they come into contact with it, set the 'Kill Particles' option after enabling 'Collision' on the Physics tab of the Properties editor:


The add-on hasn't been properly updated for Blender 2.80. It tries to access color_space on an Image Texture node, which is no longer part of ShaderNodeTexImage in Blender 2.80. It used to be in Blender 2.79b and before.

The proper way of accessing the color space settings is to retrieve the Image object referenced by ShaderNodeTexImage which has the colorspace_settings.

The issue has already been reported to the developer.


How to render a normal map from a camera+mesh?

Blender 2.8

Properties -> Render Properties -> Render Engine = Workbench
Properties -> Render Properties -> Lighting = MatCap
Properties -> Render Properties -> Studio Light = check_normal+y.xer
Properties -> Render Properties -> Color Management -> View Transform = Standard

I also recommend:

setting the scene background to #8080ff aka RGB(0.5, 0.5, 1.0) aka HSV(0.666, 0.265, 1.0), camera to orthographic, and output to a power-of-two square render.

Note: Blender shows a "Gamma Corrected" footnote on Hex numbers and gives me this strange value: #BCBCFF instead of the expected #7f7fff or ~#8080ff, I recommend using the RGB input

Properties -> Scene -> World -> Viewport Display -> Color = RGB(0.5, 0.5, 1.0)
Active Camera -> Properties -> Camera -> Lens -> Type = Orthographic
Properties -> Output Properties -> Dimensions -> Resolution X = 1024
Properties -> Output Properties -> Dimensions -> Resolution Y = 1024

Render as usual, be sure to inspect your output closely! color management is quite fickle especially since we're not representing color data

You can compare your render to a public example normal map: https://en.wikipedia.org/wiki/Normal_mapping#/media/File:Normal_map_example_with_scene_and_result.png


In the Curve editor select the keyframs and press T to change the interpolation for the keyframes to bezier


Appending an object brings duplicated objects

To summarize the answers in the comments, it looks like you can solve the problem by simply deleting the erroneously copied brick(s).

To avoid this problem entirely in the future, you can used an Array modifier on the bricks, then separate them into individually manipulatable meshes using the techniques outlined at How can I use an array modifier to create individually manipulatable objects?.

A third option, depending on the kind of manipulation you are doing to the brick meshes, would be to automate the randomness of the bricks using a Displace modifier (applied after applying an Array modifier). In order to make each one of the bricks have a different deformation, set the Displace modifier setting 'Texture Coordinates' to object and select any object in your scene (though preferably an empty).


Coupling particles textures and position

Particles change color based on age / lifetime. I have left in transparency.  You can determine if position corresponds to that number.


Animation Nodes - How to create transition with the gif-animated squares

We shall create the animation by morphing between those shapes sequentially. The first shape is a four-petal flower shape, this can be created by modulating the the amplitude of a circle based on a positive sine wave. First, we create a circle using its parametric equation:

Then the circle is scaled based on the absolute of a sine wave. The integral multiple of the parameter range controls the frequency of wave which controls the number of petals. A phase shift is introduced by adding some scalar to the parameter, this effectively rotates the flower. Moreover, the power of the wave controles its curvature and a scalar addition to the wave controls the radius of the center part:

The next shape is a squircle that turns into a superellipse (A squircle is a special case of a superellipse), so lets create a superellipse. The superellipse is just a circle that was powered retaining its sign:

Finally, it turns into a square, which is the limit of the superellipse as the power approaches zero. So, lets animate between all those shapes. We start with the petal shape (Which is a superellipse with a unity power) that have a zero radius and animate the radius to reach the required state, we are also going to animate the phase shift to rotate the petal at some point:

Then, we are going to animate to a squircle with a constant radius. This is done by animating the petal factors to a constant radius and the power of the superellipse to half:

Then, we animate to a high power:

Finally, we animate to a square, remember that a square is the superellipse as its power approaches zero:

Finally, we create a mesh from those vertices:

To create a grid of those objects, create a loop with a time offset:

Adjust the timing, durations, offsets, and other parameters to get the result you are looking for.


Mirror texture paint on selected faces of an object?

SOLVED

I just had to turn on X symmetry in the texture paint tool pane.


The tagged texture is alpha and black if outside the texture, using clipping in the image texture node.
You can use this alpha channel this way so that the fac value stays 0 when outside of the texture:


How to use bridge edge loops to make a pipe bend in Blender 2.8/9

These settings work for me..

You certainly don't want a profile factor if you want the diameter of your pipe to be constant along its length.

It's only trial and error that gets me to go with 'Blend Surface' and this 'Smoothness'.. maybe someone who knows the code can tell us what the maths is?


How to toggle between Flat and Smooth shading during animation?

Animatable (custom property) toggle

import bpy

def toggle_shading(self, context=bpy.context):
    """Toggle smooth shading"""
    value = self["use_smooth"]
    if self.polygons[0].use_smooth is not value:
        for poly in self.polygons:
            poly.use_smooth = value

def frame_handler(scene):
    """Update shading on frame change"""
    for mesh in bpy.data.objects.data.meshes:
        try:
            toggle_shading(mesh)
        except KeyError:
            pass

bpy.types.Mesh.use_smooth = bpy.props.BoolProperty(
    description=toggle_shading.__doc__, update=toggle_shading)
bpy.app.handlers.frame_change_pre.append(frame_handler)

Paste the script above in the Text Editor, click Register and Run Script.

Text block name must end with ".py" to activate the register functionality (run script on load).

In the Properties Window, under Object Data, Add a custom property with Property Name use_smooth and Property Value of 0.

You can now animate this value the toggle smooth shading.


Is it possible to have a procedural texture radiate from the CENTER of a sphere?

In order to have the procedural texture radiate from the centre you need to base in on the direction and the distance from the centre - you can then animate an offset on the distance in order to animate the 'blobs' moving in the desired direction from the centre.

Using Object coordinates, a direction vector can easily be obtained by using the Vector Maths Normalize node. This will produce a vector of length 1.0 in the direction of that point in the texture, in relation to the origin (0.0, 0.0, 0.0).

Similarly, for the distance you can use the Vector Maths Dot Product node - by feeding the Object coordinate into both inputs the Dot Product will produce the square of the distance. A Power maths node set to 0.5 will take the square root, producing the distance from the origin.

We can now generate the procedural texture from the Vector (X,Y,Z) and Distance (D).

In order to demonstrate this, we can use a trick used in How to animate musgrave texture? to create a texture that has more than three 'input' dimensions. This allows us to use X,Y,Z as the input Vector and D as one of the other inputs.

The node group uses vector maths to combine a pair of Noise textures to produce a noise-like output that is based on the 6 input values (X,Y,Z,T1,T2,Seed).

This new node group can be used as follows :

Note that the Add node can be varied to animate the texture so that the pattern moves outwards from the centre. This can produce the following result :

Blend file included

EDIT : Since we have a 'spare' input of the Noise5D texture group we can use a similar technique to that described in How to set musgrave to get something periodic? to make the texture repeat - to make the animation cyclic. For this we take D (the distance from the centre, adjusted to add an offset for the animation) and convert it into circular coordinates - to feed into T1 and T2 instead of just T1. This makes the pattern repeat after a specified distance (as set by the Value node feeding into the Divide maths node). By adjusting the scale of the circular coordinates (the Value node feeding to the Multiply nodes) we can adjust the scale of the pattern before it repeats.

Note the Multiply node set to 2*pi (6.283) to set a whole rotation (for the cyclic repeat). This allows the Value feeding to the Divide to set the period of repeat on the input coordinate (as animated by the Value node feeding to the Add node for the offset.

Animating the 'offset' with linear interpolation over the set range can now produce the following cyclic result :

Additional blend file included


Switching between Image Sequence and Movie Clip for Compositing

Nevermind, found a workaround.
Just used a scale node on the image.


Use modern features like SURF in camera tracking?

Blender currently uses a KLT-Tracker (Kanade–Lucas–Tomasi) which is documented here .

While algorithms like SIFT and SURF are patented, ORB (Oriented Brief) could be an alternative (BSD licensed) it was developed in 2011 and is already implemented in openCV

ORB

I have no idea whether there are plans to use other algorithms in Blender.


Your problem is that you've enabled Ambient Occlusion. Ambient Occlusion is a fake light that was mostly used in Blender Render to improve the shadows. I'm not sure it's still very useful with 2.8 except maybe for some effects like baking shadows...

Vader explanation here. Manual explanation here.


Displaying the wireframe of a beveled Bezier curve

Thanks to this answer, I realized that you need to check the "Wire" checkbox within the Object Properties panel.


How to change shortcut for snap to view?

At the very bottom of this image you can see where the shortcut can be changed in User Prefs → Keymap.I searched "MM" (middle mouse) by Key-Binding to find it more easily.


You should be able to do it rather easily. Just do what you already did (make each face a different color/material) - just make the material a Glass BSDF. Don't forget to turn the roughness down. You may also need to play with the individual IOR's to get the effect you need.


How to translate plane coordinates x,y to equirectangular?

It seems to me, that the number, that used in Power node is not exactly equals 2. It can be like 2.0001, but in widget it rounds 2. Why is important? Coordinates are in range -1 ... 1 so part of coordinates are negative. And raising a negative number to a fractional degree is impossible (because of math), so it brakes the resulted circle.

Equals 2:

Does not equal 2:


How to not slide off the stairs in game mode?

May I suggest you switch it around. Instead of adding a mesh along the stair's geometry you could just make your character's collision mesh with a chamfer. In that way you don't have to create extra meshes for your stairway.

Without the ramp object the mesh will not slide down a gradient but rest on the surface of perfectly flat geometry in your scene when you stop.


Hide Blender's grid floor programmatically

To show or hide the grid floor you must first find the 3D view space, then use the space's show_floor porperty:

import bpy

def find_3dview_space():
    # Find 3D_View window and its scren space
    area = None
    for a in bpy.data.window_managers[0].windows[0].screen.areas:
        if a.type == 'VIEW_3D':
            area = a
            break

    if area:
        space = area.spaces[0]
    else:
        space = bpy.context.space_data

    return space

space = find_3dview_space()
space.show_floor = False

What you tried to do is to access the SpaceView3D type, which is the class of the 3D view space object. You cannot access methods directly from the class, but rather need to find the object instantiating that class as specified above.


I think you need to "bake your simulation"
It sounds like you are recalculating it every single time you play it
and your computer isnt fast enough to calculate the animation in real time

But if you bake it, it will save the calculations so it wont have to
re-calculate it all the time.

https://www.blender.org/manual/physics/smoke/baking.html


How to easily add cloth seam channel to a model

The easy way is to simply draw it on a bump map.  Are you doing a 1mm flyby of your foot?  Are you carefully lighting the scene for your tabi seam to catch dramatic shadows?  Unless you are, geometry is pointless, save your verts for somewhere they matter.

But I dunno, maybe you're doing a foot flyby.  The way to do it with geometry is to first fix the topo on your mesh-- you need an edge flow that follows the seams, something that is not yet present on your image.  What you want is topo where there is some edge loop that you can cleanly select that represents the seam.

Once you have that topo, it's pretty trivial.  Select your seam loop and start with a bevel-- mouse wheel up to get an extra edge loop in the center:

Ctrl numpad - to shrink your selection to only the central loop of the bevel, ctrl , to set pivot point to median, alt-s to scale along normals, scale to taste and confirm, and you have a seam.


How do I transfer my high poly sculpt to my low poly retopo mesh so I can paint it?

Your retopo attempt is looking fine. Try to Shade Smooth (right-click in Object Mode) and it should look much smoother.
You have created a low-poly mesh (step 1c, see below). If you want to animate/pose the character, you will also need to retopo the body or use a base body mesh and add the head to it.
Next, you can add a MultiRes modifier if you want and then start texturing.
A common workflow the following:

use a low-poly base mesh to form the shape of the character. This can be done in Sculpt Mode or Edit Mode. You have several options here:
a) you can use an existing base mesh and shape it in Sculpt Mode
b) OR box model it from scratch (Edit Mode)
c) OR sculpt it from scratch. The result is a high-poly mesh and you need to do a retopology to create a low-poly version from it.

optional: add a Multires Modifier to add details like wrinkles for the face, collarbones, scales, wrinkles for clothes, etc. You can transfer the details from your sculpt that you did in 1c with a Shrinkwrap Modifier.

texturing / texture baking
a) bake the Normal Map from the Multires Modifier OR bake it from the high-poly sculpt (1c) to the low-poly version. The purpose is to have a low-poly mesh but with the details of the high-poly/MultiRes version. (Low-poly + normal map == high-poly)
b) block out the base colors (Diffuse color) with a basic node setup (Ambient Occlusion and Pointiness). These nodes only work in Cycles. Baking them makes them available in Eevee and speeds up rendering
c) do a paint-over to adjust the colors. Add face color zones, make-up, etc on an extra image and mix it with the baked base colors (try MixRGB modes like Mix, Overlay, Multiply)
d) paint a Roughness map
e) optional: bake the final textures (to speed up render time and for export to game engines)


How to translate(bengali) tabs, tools etc

The language options can be found under Edit > User Preferences, then under the Interface category, then near the bottom, under the Translation section.

Sadly, not every language is available. Possibly including yours.


How can I get rid of the link (thick horizontal line) between two keyframes?

The yellow lines do not represent "links" but selected keyframes with the same value.

Form the Blender Manual

  One of the key feature of this window is that it allows you to visualize immediately which channel (i.e. Ipo curve) is really affected. When the value of a given channel does not change at all between two neighboring keyframes, a gray (unselected) or yellow (selected) line is drawn between them."

If what's bothering you is the way the interpolation works between keyframes , you should edit those not the dope sheet but on the Graph editor window.

In this example you can see the same key frames for the location of the X channel represented on the dope sheet and the graph editor, Notice how the Yellow lines between keyframes coincide with the flat regions of the graph, and how the line disappears where there is some transformation on the value in the graph.

EDIT
A note on the Hierarchical system and the Dope Sheet

Everytime you add keyframes using the I key you are presented with an option to choose what channels you want to use for the keyframe, for example Loc,Rot_Scale or Loc_Scale, Rotation only, all channels, only selected channels. The channels you choose are what is called a Keying Set.

The idea behind keying sets is to keep things organized, for example if you don't want to have a location keyframe when you just need to rotate.

In the DopeSheet you have access both to the keying sets and individual channels and they are organized in a hierarchical structure. You can move, delete or add keyframes with ease.

Here's an example:
At the top of the Hierarchy you'll find the dopesheet summary that encompasses every keyframe on the scene.
On the second level there are the individual objects with their own keyframes.

Click on the trianlges on the left to reveal the next levels down.

The lines rows in green are the Keying Sets

And further down are the individual channels.

Depending on where in the hierarchy you move (or add, or delete) the keyframes, you might affect everything, just the keying set or individual channels.

As for the Yelllow line... Sorry Still no magic nothing there... It doesn't hold anything inside it: It doesn't have any other purpose than to show information in unchanging values between keyframes.


Ok, seems that the problem I was facing was mdue to the positioning of the cylinder to the "plywood". Once I created a circle on the same origin I could bend the plate to my wishes. Now just figuring out the exact amount of degrees but for now close enough.
This gives me a rough estimate what the plate will cover


How add primitives or other objects to scene using python

There are several operators that add primitive objects to a scene, look at the reference for each to see all available options.

An example of adding several objects -

import bpy

for x in range(10):
    bpy.ops.mesh.primitive_cone_add(location=(x,0.0,1.0), radius1=0.5, radius2=0.1)
    bpy.ops.mesh.primitive_cube_add(location=(x,0.0,2.0), radius=0.5)
    bpy.ops.mesh.primitive_ico_sphere_add(location=(x,0.0,3.0), size=0.5)
    bpy.ops.mesh.primitive_monkey_add(location=(x,0.0,4.0), radius=0.5)

You can also find similar operators available when using bmesh, which is a better option when you want to edit mesh objects, or build more complex models.

Note that after you add an object using one of the primitive operators, it becomes the active object, that means you can get the object using bpy.context.active_object and make further adjustments after you have created it.

This answer gives an example of creating multiple materials and assigning them to different faces.


Blender 2.8 API how to get a list of custom transform orientations

orient_slot = bpy.context.scene.transform_orientation_slots[0]
custom = orient_slot.custom_orientation
custom.matrix

reference:
https://blenderartists.org/t/2-80-cheat-sheet-for-updating-add-ons/1148974


My gpu doesn't supports cycles but it rendered succesfuly. How can it be?

Unless you specifically change it, Cycles will render with the CPU by default.  CPU will almost always work, but it will probably be slower due to not having the massive parallelization that GPU's have.

If you are using GPU and it is working, Blender not supporting a GPU specifically doesn't mean it won't work, it just isn't guaranteed to work well.


Add and link the vertex colour node.

Adds a new material using mat = bpy.data.materials.new()

Recommend: almost never use bpy.ops.materials.new() The material bpy.data.materials[mat] in script in question is confusing and varies dependant on pre existing materials "Material" and "MyMaterial".

Notice I used the index of the io when making links. Could use vcol.outputs["Color"] for vcol.outputs[0], however if the user is using a different language, then "Color" will be in that language.

The principled bsdf base color is input 0. A simple test in python console to save counting by eye.

>>> for i, o in enumerate(bsdf.inputs):
...     i, o.name
...
(0, 'Base Color')
(1, 'Subsurface')
(2, 'Subsurface Radius')
(3, 'Subsurface Color')
(4, 'Metallic')
(5, 'Specular')
(6, 'Specular Tint')
(7, 'Roughness')
(8, 'Anisotropic')
(9, 'Anisotropic Rotation')
(10, 'Sheen')
(11, 'Sheen Tint')
(12, 'Clearcoat')
(13, 'Clearcoat Roughness')
(14, 'IOR')
(15, 'Transmission')
(16, 'Transmission Roughness')
(17, 'Emission')
(18, 'Alpha')
(19, 'Normal')
(20, 'Clearcoat Normal')
(21, 'Tangent')

Script to add material, add vertex colour node, link it to base color of bsdf.

import bpy

newmat = bpy.data.materials.new("VertCol")
newmat.use_nodes = True
node_tree = newmat.node_tree
nodes = node_tree.nodes

bsdf = nodes.get("Principled BSDF")
'''
# alternatively

output, bsdf = nodes
'''

assert(bsdf) # make sure it exists to continue

vcol = nodes.new(type="ShaderNodeVertexColor")
vcol.layer_name = "VColor" # the vertex color layer name

# make links

node_tree.links.new(vcol.outputs[0], bsdf.inputs[0])


What is the shortcut to Select Linked Flat Faces in 2.8 Beta?

you have to right click and assign your own in blender 2.80


How can I combine multiple textures so that they blend together?

The traditional way to do this was vertex colors. The amount of (say) red would be the blend factor between the textures. Use a node setup like this.

Set the 3D View to Material preview and switch to Vertex Paint mode. Paint black where you want the first texture to show through, and red where you want the second.

Alternatively, you could use a third texture to control the blend amount and paint it in Texture Paint mode.


what does it mean when you HAVE to provide UV coordinates using a Texture Coordinate node (to apply materials)?

You don't normally connect a UV socket to a Normal socket, the Normal socket is generally used for displacement or bump type of effects using either a texture or a normal map.

The fact that you connecting the UV socket to the Normal input of the material worked is probably just a coincidence, and a side effect of the fact that you mesh probably has some sort of geometrical glitch or wrong facing normals.

Try entering edit mode and clearing or recalculating your normals be selecting all faces and pressing Ctrl + N and see if that solves the problem.

Have in mind that this may destroy any custom normals your model might have (if any).


I don't see any problem in your file, except that the light sources are really dim. If you look closely in your screenshot, you can even see a faint reflection. Note that you have volumetric scattering on, which will make things dimmer than they would be otherwise.

Things you can try:

Increase the emission strength of the spot lamp (a lot, for some reason spot lamps tend to be dimmer).
Increase the emission strength of the emission shader on Cylinder.001.
Increase the emission size of the spot lamp. This won't make it brighter, but it will help it converge faster.
Increase the exposure in Properties > Render > Color Management.


Trying to realistically deform an inflated balloon so that it retains its volume

I found a solution that gave the more dramatic expansion that I was hoping for. First, as @Markus von Broady mentioned, lowering the cloth modifiers tension, but in addition I added pressure to the simulation when an object with collision put pressure on the system. So I added key-frames to the 'Pressure' setting that coincided with the system getting more pressure from an external force.


Maybe you have some modifiers on your mesh, such as "Mirror modifier", "skin modifier", "sub surface", etc.
Just apply those modifiers, check if they got out from the hierarchy on the right tab under your mesh.
Then select your mesh and your armature and go to pose mode: from there select Parent > Automatic weight > Automatic weight.
You should be able to see the weight on your mesh then.
Good work and have a nice day.


you are missing the shader after the texture...
and i recommend to change flat to box in this case for better result
good luck (y)


Align vertices with another vertex, but vertices must stay on their edges

There isn't a simple way. You can move the vertices on the z-axis and use snapping to align them to the other verts, unfortunately snapping does not work while using edge slide.

To get the result you are after -

Select the four corners of the part you want to align to
Press ⇧ ShiftDESC which will duplicate the vertices and leave them in the same location.
Press F to make a face from these vertices
Scale S this face so that it is larger than the outer edges
Choose Mesh->Faces->Intersect (Boolean)
Now select your top vertices and edge slide GG, you can move them right down - against the new vertices that are cut in the edges in line with the inner section.
Now select all A then w->remove doubles,
Select and delete the extra bits left behind. I got an extra 2 faces under the section that is now flat, I deleted the two extra edges and dissolved the two vertices to end up with the desired mesh.


The quads are not planar. But you have most probably flat shading. And so you will see the shading for the two underlying tris of this quad therefore.

Try to activate Auto Smooth, and give it a angle of let's say 5. Increase or decrease the value to your needs. Auto Smooth can be found in the Properties editor in the Data tab.


You already have the snake mesh, create a bezier curve, bend it in edit mode so it creates the pattern in which you want to slither it. Add the Curve modifier to the snake and choose the bezier curve you just created for the modifier, play around with the axis parameters. Once you get it right just move the bezier curve up and down (or back and forth), you'll get the slither.


I don't think it's possible at the moment: if you start bevelling using Ctrl+B you are forced to use the keyboard-based workflow.

However, you can use the bevel tool (green icon in the left-side toolbar) instead of the bevel operation, which gives you access to some more options (not all the shortcuts though).

In combination with the "tool settings" header, it allows you to change the options right before starting your bevel operation:

Actions performed in the above gif:

Edit mode, select your edge
Select the Bevel tool
If it's not active already, activate the "Tool Settings" header by right-clicking on the 3D Viewport header
Adjust the setting
Hold down the mouse button and drag

Alternatively to the "Tool settings" toolbar, you can display a "Tool properties" panel in the Properties area.


The simplest way to handle this is to add a keyframe for the particle lifetime. To make the particles stop emitting, set the lifetime to zero.

If you have very fast-moving particles (such as bullets), you will also need to keyframe the initial velocity down to zero.


Hold Shift and press Numpad 4 or Numpad 6 until your camera is at the correct angle.


Animate Object to appear 1 layer at a time

The easiest way is probably the boolean modifier. Set it to difference or intersection, whichever works better for you. Then, create an object (probably a cube) that either cuts off the parts you don't want or just includes the parts of your object you want the camera to see. Then animate the cube to move upwards as slow or fast as you want it to move.
Obviously, set the cube to not be rendered.

Two downsides of this method: You need a clean topology, otherwise the boolean modifier might create awkward results. The more vertices your object has, the longer the first initialisation of each frame will be once you hit the render button and especially when editing. For a couple of hundred or thousand of vertices this is probably no concern though.

Another method might be to animate the camera's clipping. This will not create a filling face on the top, however. And the camera has to be on top of your "3d print". This method is very rudimentary in general.


Pin/Parent Vertex of OBJ1 to Vertex of OBJ2

if you select two objects, you can hook a vertex from the last selected (after entering edit mode) to "selected object", ie to the last object selected (to its origin). You could move the origin to a vertex in this last object... but it's not ideal

Or, you can do this, perhaps better:

from the object 1 (the one that has the vertex you wish to pin to), select the vertex and move the 3d cursor there (Shift+S > "cursor to selected")
then add a new empty, and move it to the 3d cursor (Shift+S > "selected to cursor")
then parent the empty to the object 1
then selected the empty and then the object 2 with the vertex you wish to pin to the object 1 vertex
enter edit mode, and select the object 2 vertex to be pinned
from mesh > vertices > hooks > "hook to selected object" (the empty)

if I got it well...


That tutorial, as you can see here, is for 2.73, and since then the Blender UI changed a bit, you can find that option in "file=>user preferences=>system" now (it's called "compute device").

You could also download an old 2.73 from the Blender website, to make it easier to follow the tutorial.

Anyway, remember:

be sure to use "cycles" render before creating the "quick smoke" setup.
save the file in order to enable the cache settings
before rendering, run the simulation from the start (frame 1) since it could need recalculations
if something in the simulation seems to be stuck after some settings change, try also to delete (and thus rebuild) the cache

Also, on the above page you can download a "finished" .blend which could help you understand better.


How to add an object at a specific posistion in Blender Game Engine

Move emitter to desired location

If you move the emitter (with whatever method you want) before adding the new object will be added there.

Move added object to desired location

You let the emitter create the object at one place and move it later (even in the same frame)
example:

import bge

scene = bge.logic.getCurrentScene()
object = scene.addObject("Sphere","Sphere")
object.worldPosition = [1,1,1]

to find out more about module/script mode please have a look at the BGE Guide to Python Coding


What is the difference between a linear and angular motor (rigid body physics)?

An angular motor rotates stuff (angular impulse), and a linear motor pushes stuff (linear impulse):


Cycles Node to tell Distance from an Empty

You can use Drivers to do this.

Add a value node, then right click on the number button and select Add Driver

In the Graph editor, switch to drivers in the header:

Select the driver on the left panel, then set it to Sum values or Averaged value to avoid your driver being blocked by the python security features. Then set the variable type to Distance and select the empty and the object to which the material is assigned. Unfortunately there doesn't seem to be a way to reference the object(s) to which the material is assigned without specifying them individually with separate drivers.


Try these settings. Using PRINCIPLED BSDF seemed to work well for me.
2.79 sorry.


How to quickly jump from one entry box to another?

The eyedropper button next to each setting activates an operator, which means you can connect it to a keyboard shortcut.

In the preferences under Input you can add a new keyboard shortcut. I would suggest adding it under 3DView/ObjectMode. By scrolling down to the bottom you will find an Add New button which you click and then you fill in the details.

For the operator name, which starts as none, enter cgcookie.eye_dropper, then the target_property will become available where you enter source_object to set the source and target_object for the target. Then choose the shortcut settings you want to use for each. By clicking the Save User Settings button, the shortcut will be available every time you start blender.

Here I set ⎇ AltW to set the source object and ⎇ AltE to select the target object.

Now you can press ⎇ AltW and click an object to set it as the source object and ⎇ AltE to choose the target object.


hope you are working on the mesh which is already mirrored so after applying knife it eidt mode it should mirrored.


I got it working. As PG Math proposed I used Alpha Overs and Mask. I didn't use Z transform.

For each object layer ( except background ) i set all other object layers as a mask. The camera can now freely move around the scene and the objects are blurred nicely and the objects render correctly.


Partially UVW Animated alpha mask for circuit board shader

I found a solution. I wanted to have a mask that I can animate to determine the alpha channels overall opacity, overriding the alpha mask information. (can be used in literally any game vfx...) I have to figure out though how to add this as decal to other materials but that is another one.
Here is the solution:
And here is the solution I used to blend it onto another material. If you can tell me how to make a more clean, proper version of this i would be very grateful. This feels a little bit wacky.


Fade out reflection in mirror with cycles

EDIT: As mentioned in a comment above, using a glossy shader for the mirror and simply adding a small amount of roughness will give a similar result, although you will lose some of the definition in the reflection that you can get with blender internal. My solution is a way to get defined reflections that still fade out.

As far as I know, there is no 'proper' way to do this, as in there is no setting that will allow you to make the reflection fade out a certain distance from the material.

However, there are some ways to fake what you are doing, and in the case of replicating the image above they work quite well. However, if you try to scale this up to larger, more complex models or a non planar mirror you may have some issues (I haven't tested this).

The way to fake this in Cycles is to modify the material on the object being reflected, and leave the plane with just a glossy shader with a roughness of 0. Any roughness will work just fine, but 0 will make everything much easier to preview as you set up. In my file I gave it a bit of a blue color as well.

For the cube, we'll use a combination of a gradient texture and the light path node. Using the light path node, we can isolate the reflected cube by using the Is Reflection Ray Output. If you use the node wrangler addon, you can CtrlShift click on a node to preview it. Which will look like this:

We can multiply the reflected cube by a gradient texture, which will produce a gradient on the reflected cube. You will have to rotate the gradient texture by 90 degrees using the mapping node, and I used a color ramp to adjust the falloff. Again previewing this step results in this:

EDIT: If you replace the Texture Coordinates node with a geometry node and use the position output, as well as set the x location value of the mapping node to 0.5, the result behaves more like the blender internal method, with less reflection the further away the cube is (you will also want to adjust the color ramp to get a nicer falloff as well).

Then we simply use this as a factor for a mix node that combines a diffuse shader and a transparent shader. Which gives this result:

Do note that you will want to disable reflective caustics if possible, as leaving that enabled causes a huge amount of noise and fireflies.

Here is the final node setup for the cube:


How to bend one side of a planar mesh fade the bending effect towards the other side

Here is how to do it. Doing it with modifiers isn't possible as far as I know. If you need more control, comment.

Start by adding a circle.
rotate the circle by 90 degrees on the X axis(RX90).
Delete the bottom half of it.
Take the bottom to vertices and duplicate the by 2 units on the y axis (Shift-DY2).

fill the two vertices.
hit (Ctrl-R).
add 1 less loop cuts then half the number of vertices in your circle you can use the scroll wheel to do this.
Join up all the faces (Ctrl-E>Bridge Edgeloops).
add some loop cuts until your faces are about square.
tweak the shape using proportional editing.


Sorry for bothering, looks like it was a floating bug. Аfter some another runs all first frames are correct, seems python driver works after that unclear behavior. Question is closed for me.


how to fix a hole in a photoscanned rock?

if it is using a UV texture you can use the clone brush in texture paint mode and copy texture from other places (using clone brush, control + left mouse button to choose area to clone, and then paint with left mouse button and drag)


The makeMaterial function's return statement isn't indented correctly. The semicolon is syntactically allowed, but it's used to place multiple statements on a single line. 2 space indentation makes it less obvious where your indentation is incorrect, standard Python practice is 4 spaces.

This works:

import bpy
def makeMaterial(name, diffuse, specular, alpha):
  mat=bpy.data.materials.new(name)
  mat.diffuse_color = diffuse
  mat.diffuse_shader = 'LAMBERT'
  mat.diffuse_intensity = 1.0
  mat.specular_color = specular
  mat.specular_shader = 'COOKTORR'
  mat.specular_intensity = 0.5
  mat.alpha = alpha
  mat.ambient = 1
  return mat

def setMaterial(ob, mat):
  me = ob.data
  me.materials.append(mat)

def run(origin):
  red = makeMaterial('Red', (1,0,0), (1,1,1), 1)
  blue = makeMaterial( 'Blue', (0,0,1), (0.5,0.5,0), 0.5)
  bpy.ops.mesh.primitive_plane_add(location = origin)
  setMaterial(bpy.context.object, red)
  bpy.ops.mesh.primitive_uv_sphere_add(location = origin)
  bpy.ops.transform.translate(value = (1,0,0))
  setMaterial(bpy.context.object, blue);
  bpy.ops.render.render()

if __name__=="__main__":
  run((0,0,0))

Setting a material is a little bit easier too:

obj.active_material = bpy.data.materials['Blue']

this also works, reusing the makeMaterial function:

def run(origin):
    red = makeMaterial('Red', (1,0,0), (1,1,1), 1)
    blue = makeMaterial( 'Blue', (0,0,1), (0.5,0.5,0), 0.5)
    bpy.ops.mesh.primitive_plane_add(location = origin)
    bpy.context.object.active_material = red
    bpy.ops.mesh.primitive_uv_sphere_add(location = origin)
    bpy.ops.transform.translate(value = (1,0,0))
    bpy.context.object.active_material = blue
    bpy.ops.render.render()

if __name__=="__main__":
    run((0,0,0))

You won't see the objects or material changes until the render has completed.

Changing the render call to bpy.ops.render.render('INVOKE_DEFAULT'), will switch the current TextEditor window to a UV editor, and show the render progress. When we press the UI button for render.render() it does a few more things behind the scene, like pick where to display the render based on the setting in render.display_mode.

Which amounts to something like this:

def find_largest_3dview_and_switch():
    collected_areas = []
    for window in bpy.context.window_manager.windows:
        for area in window.screen.areas:
            if area.type == 'VIEW_3D':
                size = area.height * area.width
                collected_areas.append([size, area])

    # no 3dview found? use texeditor.
    if len(collected_areas) == 0:
        bpy.ops.render.render('INVOKE_DEFAULT')
        return

    # else use largest 3dview.
    for area in sorted(collected_areas, reverse=True):
        area[1].type = 'IMAGE_EDITOR'
        bpy.ops.render.render('INVOKE_AREA')
        return

Instead of calling the naked bpy.ops.render.render() you could call something like find_largest_3dview_and_switch() and let that decide how to call the render function. It would switch any available 3dview (or largest) to an 'IMAGE_EDITOR' and show the render progress.


May be the possible solutions :

Best option : Manually edit and make it quads.
Option 2 : convert to
triangles-> decimate modifier(try planner)-> convert to tris->convert
to quads-> remove doubles  ( try adding bevel modifier)
option 3 :
remove doubles if any -> add a bevel modifier
option 4 : subdivide
too much-> export to zbrush and use decimation process


Streaky artefacts, subsurf, how to avoid?

Avoid using n-gons (polygons with more than 4 vertices) those will not subdivide nicely..

Get rid of it (and the one on the other side of the object)

Add one more loop cut (so that you have an even number of vertices in the edge loop)

Select the edge ring, use Grid fill and set the span to something that makes sense.

Grid fill will create proper topology based on quads.

Repeat grid fill on the other side of the object.


You basically need to combine two of the Templates in Text Editor that ship with Blender:

An Operator and a panel. In the panel's draw() method, you add an operator to the layout, which will be represented by a clickable button. Clicking it will run the operator's execute() method.

Here is an example how interface and actions play together:

http://wiki.blender.org/index.php/Dev:2.5/Py/Scripts/Cookbook/Panels_and_Operators/Ping_Pong


Blender 2.79 - Can't find Spiral tools in toolbox

If you are completely new to Blender, you really should follow a tutorial. I highly recommend Blender Guru's introductory series.

There are a few ways you could approach your problem. The easiest way would be to extrude(select and press e) and rotate(press r and lock it onto an axis by pressing x, y, or z). If you wanted to be more precise, you could use a curve, and taper it with another circle curve. However, this is rather excessive for someone inexperienced. It will take time to get the hang of Blender.


Apply mesh transformations to primitive_uv_sphere_add()

This can be achieved by getting the mesh of the object and multiplying the transformation matrix to each vertex. (Possibly there is a convenience function for that).

import bpy
from bpy import context
import mathutils
from mathutils import Vector,Quaternion
import math

obj = bpy.data.objects["Cube"]  # particular object by name
#obj = bpy.context.scene.objects.active # active object

# setup whatever matrix
mx = mathutils.Matrix.Rotation(math.radians(15.0), 4, 'X')

mesh = obj.data
for vert in mesh.vertices:
    vert.co = mx * vert.co


How to batch rename bones and their corresponding vertex groups?

Usually an armature is the parent of the mesh that it deforms (from using ⎈ CtrlP->Automatic Weights), this means we can get the mesh deformed by the armature by looking at it's children property. We can then rename both the bone and vertex group to a new name that is unique among all armatures allowing a conflict free merge. Adding the rig name to the bone name so that "Bone" might become "Leg1_rig_Bone" seems like a good approach.

import bpy

for rig in bpy.context.selected_objects:
    if rig.type == 'ARMATURE':
        for mesh in rig.children:
            for vg in mesh.vertex_groups:
                new_name = rig.name + '_' + vg.name
                rig.pose.bones[vg.name].name = new_name
                vg.name = new_name


As far as I know, you will have to save these manually every time. Blender will discard everything not used, and not saved. Therefore you will have to save the texture, for it not to vanish.

OR you can pack the image into the blend file.

See this post regarding the same subject:

Why did the texture I painted in texture paint mode disappear?


Passing float texture to fragment shader returns incorrect value in Blender 2.8

Somehow, I figured out myself, this is quite a newbie mistake. The generated image should be created with float_buffer.

from:

bpy.data.images.new(IMAGE_NAME, WIDTH, HEIGHT)

to:

bpy.data.images.new(IMAGE_NAME, WIDTH, HEIGHT, alpha=True, float_buffer=True)

One more thing is that the alpha value should be 1.0 since it will be used as masks for other. Ref from documentation


Trying to dissolve edge, but sometimes blender brings the origin to a face instead and doesn't dissolve the face. REALLY annoying!

I think you are confused about how to use  dissolve..  or about the differences between dissolve and delete:

check this fast video I made for you:

https://www.youtube.com/watch?v=7vEnOqUZ7Lk

also check:

Differences between dissolve and delete?

and this:


The encoding options from previous versions are still there, but now they have organized differently
One of the big changes in version 2.79 is that they finally separated containers and codecs.
If you select FFMpeg video, there will be a new tab for Encoding options.

There you can select the container and the codec for the output file.
Container is the file format for the file, (Mov, Avi, Ogg, MP4, to name a few) sometimes is referred as a "wrapper".
Codec (short for Compression-Decompression) Is how the image is compressed. The picture quality, file size and processing power needed to view the file are largely determined by the kind of codec used and the settings used for it.
For 2.8
The interface is similar but it is further divided into Encoding and Video, but the same principles apply.

But Why FFMpeg?
FFMpeg is a free software project that produces libraries and programs for handling multimedia data. Most video encoding in blender is done using those libraries.
But why FFMpeg and not just "video" or something less obscure?
Somehow the developers presumed that everybody would know all there is to know about FFMpeg and Encoders and Containers...
But why?...
Ask the developers...
See the Wiki for changes to the encoding interface: https://wiki.blender.org/index.php/Dev:Ref/Release_Notes/2.79/More_Features


Boolean Intersect/Difference Only Uses Edges

Wow, I really don't know what I'm doing, huh?

Following a comment on the same YouTube video of the tutorial, I removed doubles.
(In Blender 2.80, it is now named "Merge by Distance, and can be found in Edit Mode, Mesh > Clean Up > Merge by Distance"

So I learned a thing. I apologize if I wasted anyone's time with this.

\o/


Put the object and curve origin at the exact same position :

Select the curve and press ShiftS > Cursor to Selected
Select the object and press ShiftS > Selection to Cursor

Move the object along the Y axis if you want it to follow the curve.


How do I correctly reduce geometry on part of a mesh?

You can try the decimate modifier. It can take a vertex group so first add the faces you want less detailed into a group, then select it in the modifier.


Edge selection does not result in highlighted edge for one object in scene

When I had removed doubles, I got the selection highlighting back.

Now, why would that change anything?


I found it, the solution was to go to "Particle edit" mode, select "particule select mode: path, then Select -> Roots and finally Particles -> Weight set with the strenght set to 1 in the tool panel.


What am I doing wrong with my rigged body?

Deactivate the Snap option (magnet icon on the horizontal bottom bar of your 3D view).


Try setting the frame and then rendering it.

bpy.ops.render.render() is an operator which renders the current scene.
bpy.context.scene.frame_set() is an operator which sets the scene frame.

Here is a simple example:

import bpy

scene = bpy.context.scene
fp = scene.render.filepath # get existing output path
scene.render.image_settings.file_format = 'PNG' # set output format to .png

frames = 5, 9, 17

for frame_nr in frames:

    # set current frame to frame 5
    scene.frame_set(frame_nr)

    # set output path so render won't get overwritten
    scene.render.filepath = fp + str(frame_nr)
    bpy.ops.render.render(write_still=True) # render still

# restore the filepath
scene.render.filepath = fp