How do I make volumetric light fade to nothing

The issue is that your volume scattering domain is interacting with all of the other lights on the scene. To make it the less visible you could use a gradient texture node and a color ramp (as detailed in this answer), or you can do a quick trick at the expense of realism by suppresing shadow rays for on the volume scatter object and disabling volume scattering rays in the rest of the lamps.

Select the object you are using as container for volume scattering and disable Shadow in the Ray visibility section of Cycles settings.

(also get rid of the volume absorption and add shader nodes you are using in the materials)

Then disable visibility for volume scatter for all of the other lights on the scene (so that they do not interact with the volumetric rays).

Another issue with your file is that you have a very low number of bounces for the headlights of your vehicle (Area and Area.001). In the settings for bounces bring up the value to 1024.

Lastly, know that you are going to need a lot of samples to render the image (don't rely on the denoiser, it will smudge your image)

I rendered a preview using branched path tracing using 300 AA samples and 900 for volume. But you might need more samples to get a clean image at the 8.7k render you want to do....

An alternative to this is not to use a mesh for volume scattering, and use volume scattering in the world and use cone lamps in the headlights instead. (all other lights still need to be disabled for Volume Scatter rays). This will give you a more natural effect, as in real life, where light beams are visible because of the suspended particles in the air. You will the shape of the beam will be more natural and it will interact better with the scene. All this at the expense of more samples and rendering time.


It really depends on how you want things to look in the end. It doesn't mean you will notice a difference if you were to connect them.
If you try to connect complex parts you also end up with a higher vertex count.

Inherently there is nothing wrong with having loose parts. Lots of weapons are made like that.

If you intend to control some parts trough code or animation, having them in separate objects works too.

I say play around with it and see what you're comfortable with. This is going to be a trial and error journey on your part anyways. Ultimately it comes down to technical choices and the workflow that works for your project.


How do you bake several materials onto one object in Cycles Render?

EVERY material (on the active object) needs an active texture. Note: it doesn't need to be connected to anything...just needs to be there with a valid image and be selected. That error report will tell you which material its missing from so you can quickly add it. It would be a good idea to hook a uv map node up to it if you have more than 1 uv map on the object.


The Node Editor won't work for the object selected

Make sure Use Nodes is enabled in the header of the node editor or in the properties editor:


How to set specific sample spacing (meters in between each pixel) for a Blender Cycles Render

I'm assuming Metric is set as Unit System and Meters as Length in Scene Properties tab. If you're using any other unit, including those from Imperial system, simply convert the values calculated below as meters to the unit of your choice [Blender also operates on meters and converts them to other units if necessary ].
Using Orthographic camera, Blender takes the longer of the output dimensions and treats it as unit_scale * orthographic_scale meters. So increasing either Unit Scale or Orthographic Scale increases the area visible by the orthographic camera. Since Blender automatically scales objects when you change the Unit Scale, you can see the change by observing the grid in Top Orthographic View:

So for 200x100 dimensions, 1.0 unit scale, 1.0 orthographic scale, 200 pixels represent 1.0*1.0 = 1 meter and 1 pixel represents 1/200 = 0.005 meters or half a centimeter. For 100x500 dimensions, 2.0 unit scale, 2.0 orthographic scale, 500 pixels represent 2.0*2.0 = 4 meters and 1 pixel represents 4/500 = 0.008 m or 8 mm. Assuming square pixels here.
pixel_width = pixel_height = unit_scale * orthographic_scale / longer_output_dimension
You have output dimensions and target pixel dimensions (distance between centers of pixels), but you want to calculate the orthographic_scale, so you can multiply both sides of the equation by longer_output_dimension and then divide both sides by unit_scale to move them to the other side:
pixel_width * longer_output_dimension / unit_scale = orthographic_scale.
For 512x512 dimensions, 0.4 m pixel width and 1.0 unit scale:
orthographic_scale = 0.4 * 512 / 1.0 = 204.8.
Step by step example
Let's say we want to duplicate (yes, not delete) starting cube a few times and make sure cubes are aligned to pixels. Therefore, pixel dimensions should equal cube dimensions - 2 m, and axis-aligned distances between cubes have to be multiples of 2 m.

Press Numpad 7 for Top Orthographic View.
Select the cube. Press SHIFT + D to duplicate it, hold CTRL and position it. Repeat a few times.

Select the original (center) cube, press / to center view on it, then CTRL + ALT + Numpad 0 to set the camera to active view and / again to exit Local View.

Since each cube should correspond to one pixel, in this example we can fit everything in 5x5 dimensions, so let's set such dimensions in Output Properties tab
Press Numpad 0 for camera view, select the camera and in the Object Data Properties  tab change its type to Orthographic. Set the Orthographic Scale to 2 * 5 [2 m cube dimension times longer output dimension] - Blender will accept a simple expression like that.

As you can see, cubes are aligned to pixels.


Can I use VSE result in Movie Clip Editor?

You can only use unedited clips in the motion tracker for now.


Smoke+fire wispy and transparent in render, but fine in render preview

Unfortunately, (as mentioned in the linked thread), this issue is a bug.

There is a workaround however, which isn't ideal or 100% polished, but its a quick and dirty method to get the job done.

1. As you can see in the screenshot, I have the same issue (Note: This bug only applies to the 'Fire' flow type, the 'Fire & Smoke' type renders without issues).

2. Begin by ensuring that Transparent is checked under Film in the Render Properties Panel, and also that the PNG Type is set to RGBA in Output.

3. Next add a large plane behind the fire object. Ensure that it is wider than the bounds of the camera and is far enough back from the fire object as not to cast light onto it. Give it a simple deep blue emission shader, with strength set to 1. (Note: I've noticed a bug here in 2.74 whereby if there is an object behind the viewport display of the smoke and fire, it wont dispay properly. Don't worry though, this doesn't seem to affect the renders.)

4. Render the image and jump on into the Compositing Screen Layout. Check the Use Nodes, Free Unused, and Backdrop boxes below the Node Editor, and add in a Viewer node.

5. Hit Shift+A and go Matte>Keying, add this to the Node tree.

6. In the Key Colour setting, use the Eye Dropper tool to sample the blue from the original render, this will mask out all hues from the render which display the selected colour. If the blue appears black, it's likely that you don't have the Use Alpha check-box ticked on the Viewer and Composite nodes.

7. This should update the render automatically in the bottom left Image Editor. If it has simply hover over the transparent render and hit F3. If not just give it another render, ensuring that the Compositing check-box is ticked under the Post Processing tab in the Render Properties Panel, and it should display the composite fine.

Et Voila, the final render! :) As I mentioned it's not a perfect solution, and where the blue was subtracted from the edge of the flame it has become slightly pink tinted, but for all intensive purposes it works okay, and colour correction could be applied either in Blender or in Photoshop/Gimp. Finger's crossed the bugs'll be fixed in the next release.


Can I render to a custom output file format?

I don't think that's possible, without adding this to the source and compile it. As workaround you can try to create a custom render engine class and create property to add a path to your application like this:

The following script creates a discription scene file (text) for every frame you've selected in the scene and uses custom application to render it:

import bpy
import mathutils
from mathutils import Vector

# LOGIC
class CustomRenderEngine(bpy.types.RenderEngine):

    # These three members are used by blender to set up the
    # RenderEngine; define its internal name, visible name and capabilities.
    bl_idname = 'custom_renderer'
    bl_label = 'Application Name'
    bl_use_preview = True

    def formatNumbers(self, number):
        return '%0*d' % (4, number)

    def get_allObjectsInSceneByType(self, type_string):
        objects = []
        for objs in bpy.data.objects: # searches for type in the selection
            if (objs.type == type_string):
                if objs.hide == True:
                    pass
                else:
                    objects.append(objs)
        return objects

    # Return Object Transformations
    def get_objectLocation(self, object):
        return bpy.data.objects[object.name].location

    def get_objectRotation(self, object):
        return bpy.data.objects[object.name].rotation_euler

    def get_objectScale(self, object):
        return bpy.data.objects[object.name].scale

    # Return Geo Type
    def get_geoType(self, object):
        verticies = []
        for vertex in object.data.vertices:
            verticies.append(vertex.co)
        if len(verticies) == 8:
            return "CUBE"
        else:
            return "SPHERE"

    # Return verticies of Object
    def get_objectVerts(self, object):
        verticies = []
        for vertex in object.data.vertices:
            verticies.append(vertex.co)
            #print (vertex.co)
        return verticies

    # Return Geo Center
    def get_GeometryCenter(self,obj):

        sumWCoord = [0,0,0]
        numbVert = 0
        if obj.type == 'MESH':
            for vert in obj.data.vertices:
                wmtx = obj.matrix_world
                worldCoord = vert.co * wmtx
                sumWCoord[0] += worldCoord[0]
                sumWCoord[1] += worldCoord[1]
                sumWCoord[2] += worldCoord[2]
                numbVert += 1
            sumWCoord[0] = sumWCoord[0]/numbVert
            sumWCoord[1] = sumWCoord[1]/numbVert
            sumWCoord[2] = sumWCoord[2]/numbVert
        return sumWCoord

    # Return max vert distance
    def max_vertDistance(self, ob):

        verts = ob.data.vertices
        centre = Vector([0,0,0])
        for vert in verts:
            centre += vert.co

        centre = centre / len(verts)
        distanceFromCentre = 0.0

        for vert in verts:
            vecFromCentre = vert.co - centre
            vertDistanceFromCentre = vecFromCentre.length
            if vertDistanceFromCentre > distanceFromCentre:
                distanceFromCentre = vertDistanceFromCentre
                vert1 = vert

        distance = 0.0
        for vert in verts:
            vec = vert.co - vert1.co
            vertsDistance = vec.length
            if vertsDistance > distance:
                distance = vertsDistance
                vert2 = vert

        #return vert1, vert2, distance
        print ("vert:", vert1.co)
        return vert1.co, vert2.co

    # Return max vert distance NEW
    def max_vertDistance2(self, ob):

        verts = ob.data.vertices
        centre = Vector([0,0,0])
        for vert in verts:
            centre += vert.co

        centre = centre / len(verts)
        distanceFromCentre = 0.0

        for vert in verts:
            vecFromCentre = vert.co - centre
            vertDistanceFromCentre = vecFromCentre.length
            if vertDistanceFromCentre > distanceFromCentre:
                distanceFromCentre = vertDistanceFromCentre
                vert1 = vert

        distance = 0.0
        for vert in verts:
            vec = vert.co - vert1.co
            vertsDistance = vec.length
            if vertsDistance > distance:
                distance = vertsDistance
                vert2 = vert

        twoVerts = [vert1, vert2]

        newTwo = []
        wm = ob.matrix_world
        for v in twoVerts:
            world = wm * v.co
            #print(world)
            newTwo.append(world)

        #return vert1.co, vert2.co
        return newTwo

    # Calculate Raduis of sphere
    def get_radiusSphere(self, obj):
        return (obj.dimensions[0] / 2)

    # Return Materials of Geo
    def get_material(self, object):

        mat_diff = bpy.data.objects[object.name].active_material.diffuse_color
        mat_diff_int = bpy.data.objects[object.name].active_material.diffuse_intensity
        mat_spec = bpy.data.objects[object.name].active_material.specular_color
        mat_spec_int = bpy.data.objects[object.name].active_material.specular_intensity
        mat_amb = bpy.data.worlds["World"].ambient_color
        mat_amb_int = bpy.data.worlds["World"].custom.world_amount

        return mat_diff, mat_diff_int, mat_spec, mat_spec_int, mat_amb_int

    def diff_dimensions(self, dimensions):
        dimList = [round(dimensions.x, 3), round(dimensions.y, 3), round(dimensions.z, 3)]
        return [i for i in dimList if dimList.count(i) > 1]

    # Return Material List
    def get_materialList(self):
        materialNames = []
        for material in bpy.data.materials:
            materialNames.append(material.name)
        return materialNames

    def app_materials(self):
        string = ""

        amb_r = bpy.context.scene.world.ambient_color.r
        amb_g = bpy.context.scene.world.ambient_color.g
        amb_b = bpy.context.scene.world.ambient_color.b
        ambient_int = bpy.context.scene.world.custom.world_amount

        for i in bpy.data.materials:
            diff_r = bpy.data.materials[i.name].diffuse_color.r
            diff_g = bpy.data.materials[i.name].diffuse_color.g
            diff_b = bpy.data.materials[i.name].diffuse_color.b
            diff_int = bpy.data.materials[i.name].diffuse_intensity

            spec_r = bpy.data.materials[i.name].specular_color.r
            spec_b = bpy.data.materials[i.name].specular_color.b
            spec_g = bpy.data.materials[i.name].specular_color.g
            spec_int = bpy.data.materials[i.name].specular_intensity
            spec_hardness = bpy.data.materials[i.name].specular_hardness

            string += ("define material ") + i.name + " "

            # ambient
            string += str(amb_r * ambient_int)[:5] + " "
            string += str(amb_b * ambient_int)[:5] + " "
            string += str(amb_g * ambient_int)[:5] + " "

            # diffuse
            string += str(diff_r * diff_int)[:5] + " "
            string += str(diff_g * diff_int)[:5] + " "
            string += str(diff_b * diff_int)[:5] + " "

            # specular
            string += str(spec_r * spec_int)[:5] + " "
            string += str(spec_g * spec_int)[:5] + " "
            string += str(spec_b* spec_int)[:5] + " "
            string += str(spec_hardness)

            string += "\n"

        return string

    # This is the only method called by blender, in this example
    # we use it to detect preview rendering and call the implementation
    # in another method.
    def render(self, scene):
        scale = scene.render.resolution_percentage / 100.0
        self.size_x = int(scene.render.resolution_x * scale)
        self.size_y = int(scene.render.resolution_y * scale)

        if scene.name == 'preview':
            self.render_preview(scene)
        else:
            self.render_scene(scene)

    # In this example, we fill the preview renders with a flat green color.
    def render_preview(self, scene):
        pixel_count = self.size_x * self.size_y

        # The framebuffer is defined as a list of pixels, each pixel
        # itself being a list of R,G,B,A values
        green_rect = [[0.0, 1.0, 0.0, 1.0]] * pixel_count

        # Here we write the pixel values to the RenderResult
        result = self.begin_result(0, 0, self.size_x, self.size_y)
        layer = result.layers[0]
        layer.rect = green_rect
        self.end_result(result)

    # In this example, we fill the full renders with a flat blue color.
    def render_scene(self, scene):
        pixel_count = self.size_x * self.size_y

        materialstring = self.app_materials()

        # collect geometry
        geo = self.get_allObjectsInSceneByType("MESH")
        geostring = ""
        transformstring = ""

        for item in geo:

            if (self.get_geoType(item) == "CUBE"):

                #print ("Location:", self.get_objectLocation(item))
                #print ("CENTER IS:", self.get_GeometryCenter(item))
                #print ("dimensions:", item.dimensions)
                #self.get_objectVerts(item)

                geostring += "define shape box "
                geostring += item.name + " "

                # first point
                geostring += str(self.max_vertDistance2(item)[0][0])[:5] + " "
                geostring += str(self.max_vertDistance2(item)[0][3])[:5] + " "
                geostring += str(self.max_vertDistance2(item)[0][4])[:5] + " "

                # second point
                geostring += str(self.max_vertDistance2(item)[1][0])[:5] + " "
                geostring += str(self.max_vertDistance2(item)[1][5])[:5] + " "
                geostring += str(self.max_vertDistance2(item)[1][6])[:5] + " "

                # material
                geostring += " " + bpy.data.objects[item.name].active_material.name
                geostring += "\n"

            else:

                geostring += "define shape sphere "
                geostring += item.name + " "

                # center
                geostring += str(self.get_objectLocation(item)[0])[:5] + " "
                geostring += str(self.get_objectLocation(item)[2])[:5] + " "
                geostring += str(self.get_objectLocation(item)[1])[:5] + " "

                # radius
                geostring += str(self.get_radiusSphere(item))[:5]

                geostring += " " + bpy.data.objects[item.name].active_material.name
                geostring += "\n"

                # check for transformation
                dims = bpy.data.objects[item.name].dimensions
                #print (round(dims.x, 3), round(dims.y, 3), round(dims.z, 3))
                #print (self.diff_dimensions(dims))

                if len(self.diff_dimensions(dims)) < 3:
                    #print ("Transformation found!", item.name)
                    scle = bpy.data.objects[item.name].scale
                    transformstring += "transform "
                    transformstring += item.name + " scale " + str(round(scle.x,3)) + " " + str(round(scle.z,3)) + " " + str(round(scle.y,3)) + "\n"
                    transformstring += "transform " + item.name + " translate 0 0 0\n"
                '''
                print (scene.custom.app_path)
                print (scene.custom.scene_name)
                print (bpy.data.worlds["World"].ambient_color)
                print (bpy.context.scene.world.ambient_color)
                print (self.get_materialList())
                '''

        # collect lamps
        lamps = self.get_allObjectsInSceneByType("LAMP")
        lampstring = ""

        amb_r = bpy.context.scene.world.ambient_color.r
        amb_g = bpy.context.scene.world.ambient_color.g
        amb_b = bpy.context.scene.world.ambient_color.b

        for i in lamps:
            lampstring += "define light " + i.name + " "

            # position
            lampstring += str(self.get_objectLocation(i)[0])[:5] + " "
            lampstring += str(self.get_objectLocation(i)[2])[:5] + " "
            lampstring += str(self.get_objectLocation(i)[1])[:5] + " "

            # light ambient
            lampstring += str(amb_r)[:5] + " "
            lampstring += str(amb_g)[:5] + " "
            lampstring += str(amb_b)[:5] + " "

            # light diffuse
            lamp_energy = bpy.data.lamps[i.name].energy
            lampstring += str(bpy.data.lamps[i.name].color[0] * lamp_energy)[:5] + " "
            lampstring += str(bpy.data.lamps[i.name].color[1] * lamp_energy)[:5] + " "
            lampstring += str(bpy.data.lamps[i.name].color[2] * lamp_energy)[:5] + " "

            lampstring += "\n"

            #print ("Lamp energy:", bpy.data.lamps[i.name].energy)
            #print ("Lamp color:", bpy.data.lamps[i.name].color)
            #print ("Lamp location:", self.get_objectLocation(i))

        # get active camera

        obj_camera = bpy.context.scene.camera
        cameraName = obj_camera.name
        camerastring = "define camera " + cameraName + " "
        camerastring += str(bpy.data.cameras[cameraName].lens)[:5] + " "
        #camerastring += "35" + " "
        camerastring += str(self.get_objectLocation(obj_camera)[0])[:5] + " "
        camerastring += str(self.get_objectLocation(obj_camera)[2])[:5] + " "
        camerastring += str(self.get_objectLocation(obj_camera)[1])[:5] + " "

        # calculate up and direction vector
        cam = bpy.data.objects[obj_camera.name]
        #up = cam.matrix_world * Vector((0.0, 1.0, 0.0))
        #up = cam.matrix_world.to_3x3() * Vector((0.0, 1.0, 0.0))

        up = cam.matrix_world.to_quaternion() * Vector((0.0, 1.0, 0.0))
        #up = Vector((0.0, 1.0, 0.0))
        print ("UPVECTOR:", up)

        #cam_direction = cam.matrix_world * Vector((0.0, 0.0, -1.0))
        #cam_direction = cam.matrix_world.to_3x3() * Vector((0.0, 0.0, -1.0))

        cam_direction = cam.matrix_world.to_quaternion() * Vector((0.0, -1.0, -1.0))

        #cam_direction = Vector((0.0, 0.0, -1.0))
        #cam_direction.normalize()
        #up.normalize()

        camerastring += str(cam_direction[0])[:5] + " "
        camerastring += str(cam_direction[1])[:5] + " "
        camerastring += str(cam_direction[2])[:5] + " "

        camerastring += str(up[0])[:5] + " "
        camerastring += str(up[1])[:5] + " "
        camerastring += str(up[2])[:5] + " "

        camerastring += "\n"

        #camerastring = "define camera auge 60.0 1.0 1.0 3 0 -0.1 -1.0 0 1 0\n"

        # background color

        bgColor = bpy.data.worlds["World"].ambient_color
        bgColorstring = "define background-color " + str(bgColor[0]) + " " + str(bgColor[1]) + " " + str(bgColor[2]) + "\n"

        # ------------------------------------------------------------------------
        # render settings
        # ------------------------------------------------------------------------

        renderer = bpy.path.abspath(scene.custom.app_path)
        frameNumber = bpy.data.scenes["Scene"].frame_current

        scenename = scene.custom.scene_name
        scale = scene.render.resolution_percentage / 100.0
        size_x = int(scene.render.resolution_x * scale)
        size_y = int(scene.render.resolution_y * scale)

        if not scenename:
            scenename = "AppScene"

        outfile_ppm = bpy.data.scenes["Scene"].render.filepath + scenename + "_" + str(self.formatNumbers(frameNumber)) + ".ppm"
        outfile_custom = bpy.data.scenes["Scene"].render.filepath + scenename + "_" + str(self.formatNumbers(frameNumber)) + ".sdf"

        rendersettingstring = "render " + obj_camera.name + " "
        rendersettingstring += outfile_ppm + " "
        rendersettingstring += str(size_x) + " "
        rendersettingstring += str(size_y) + " "
        rendersettingstring += "\n"

        file_content = bgColorstring + materialstring + geostring + transformstring + lampstring + camerastring + rendersettingstring

        # write custom file
        f = open(outfile_custom,'w')
        f.write(file_content)
        f.close()

        import signal
        import subprocess, time

        # for single image
        single_frame = subprocess.call([renderer, outfile_sdf])

        # for animation
        '''
        app_animation = subprocess.Popen([renderer, outfile_sdf])
        print ('app_animation\'s pid = ',app_animation.pid)
        time.sleep(170)
        app_animation.terminate()
        '''
        print (materialstring + geostring + lampstring + camerastring + rendersettingstring)

        # The framebuffer is defined as a list of pixels, each pixel
        # itself being a list of R,G,B,A values
        blue_rect = [[0.0, 0.0, 1.0, 1.0]] * pixel_count

        # Here we write the pixel values to the RenderResult
        result = self.begin_result(0, 0, self.size_x, self.size_y)
        layer = result.layers[0]
        layer.rect = blue_rect
        self.end_result(result)

# Register the RenderEngine
bpy.utils.register_class(CustomRenderEngine)

# ======================================================================================
# UI
# ======================================================================================

from bpy.types import (AddonPreferences,
                       PropertyGroup,
                       Operator,
                       )
from bpy.props import (StringProperty,
                       BoolProperty,
                       IntProperty,
                       FloatProperty,
                       FloatVectorProperty,
                       EnumProperty,
                       PointerProperty,
                       )

# -----------------------------------------------------------------------------------
# Render properties
# example: https://github.com/meta-androcto/blenderpython/blob/master/scripts/archive/game_gamekit/ui.py
# -----------------------------------------------------------------------------------

from bl_ui import properties_render
properties_render.RENDER_PT_render.COMPAT_ENGINES.add('custom_renderer')
properties_render.RENDER_PT_dimensions.COMPAT_ENGINES.add('custom_renderer')
#properties_render.RENDER_PT_antialiasing.COMPAT_ENGINES.add('custom_renderer')
#properties_render.RENDER_PT_shading.COMPAT_ENGINES.add('custom_renderer')
properties_render.RENDER_PT_output.COMPAT_ENGINES.add('custom_renderer')
del properties_render

class RenderButtonsPanel():
    bl_space_type = 'PROPERTIES'
    bl_region_type = 'WINDOW'
    bl_context = "render"
    # COMPAT_ENGINES must be defined in each subclass, external engines can add themselves here

    @classmethod
    def poll(cls, context):
        rd = context.scene.render
        return (rd.use_game_engine is False) and (rd.engine in cls.COMPAT_ENGINES)

class RenderCustomSettingsScene(PropertyGroup):

    deletefiles_enable = BoolProperty(
            name="Delete files",
            description="Delete files after rendering.",
            default=True)
    scene_name = StringProperty(
            name="Scene Name",
            description="Name of sdf scene to create.",
            maxlen=1024)
    app_path = StringProperty(
            name="Export scene path",
            # description="Path to directory where the exported scene is created"
            description="Path to Custom Engine",
            maxlen=1024, subtype="FILE_PATH")

class RENDER_PT_custom_export_settings(RenderButtonsPanel, bpy.types.Panel):
    bl_label = "Render Connection"
    COMPAT_ENGINES = {'custom_renderer'}

    def draw_header(self, context):
        self.layout.label(icon='CONSOLE')
    def draw(self, context):
        layout = self.layout
        scene = context.scene

        row = layout.row()
        row.column().prop(scene.custom, "app_path", text="Path to App")
        row = layout.row()
        row.column().prop(scene.custom, "scene_name", text="Scene Name")
        #row = layout.row()
        #row.column().prop(scene.custom, "deletefiles_enable", text="Delete files after Rendering")

# -----------------------------------------------------------------------------------
# Material properties
# -----------------------------------------------------------------------------------

from bl_ui import properties_material
properties_material.MATERIAL_PT_context_material.COMPAT_ENGINES.add('custom_renderer')
properties_material.MATERIAL_PT_diffuse.COMPAT_ENGINES.add('custom_renderer')
#properties_material.MATERIAL_PT_preview.COMPAT_ENGINES.add('custom_renderer')
#properties_material.MATERIAL_PT_shading.COMPAT_ENGINES.add('custom_renderer')
#properties_material.MATERIAL_PT_shadow.COMPAT_ENGINES.add('custom_renderer')
properties_material.MATERIAL_PT_specular.COMPAT_ENGINES.add('custom_renderer')
#properties_material.MATERIAL_PT_transp.COMPAT_ENGINES.add('custom_renderer')
del properties_material

class MaterialButtonsPanel():
    bl_space_type = 'PROPERTIES'
    bl_region_type = 'WINDOW'
    bl_context = "material"
    # COMPAT_ENGINES must be defined in each subclass, external engines can add themselves here

    @classmethod
    def poll(cls, context):
        mat = context.material
        rd = context.scene.render
        return mat and (rd.use_game_engine is False) and (rd.engine in cls.COMPAT_ENGINES)

class RenderCustomSettingsMaterial(PropertyGroup):

    test_enable = BoolProperty(
        name="Enable",
        description="test enabler",
        default=False)

    test_amount = FloatProperty(
        name="amount",
        description="test",
        min=0.0, max=1.0, soft_min=0.01, soft_max=1.0, default=0.25)

# -----------------------------------------------------------------------------------
# Camera properties
# -----------------------------------------------------------------------------------

from bl_ui import properties_data_camera
properties_data_camera.DATA_PT_lens.COMPAT_ENGINES.add('custom_renderer')
del properties_data_camera

# -----------------------------------------------------------------------------------
# Lamp properties
# -----------------------------------------------------------------------------------

from bl_ui import properties_data_lamp
properties_data_lamp.DATA_PT_lamp.COMPAT_ENGINES.add('custom_renderer')
properties_data_lamp.DATA_PT_preview.COMPAT_ENGINES.add('custom_renderer')
del properties_data_lamp

# -----------------------------------------------------------------------------------
# World properties
# -----------------------------------------------------------------------------------

from bl_ui import properties_world
class WorldButtonsPanel():
    bl_space_type = 'PROPERTIES'
    bl_region_type = 'WINDOW'
    bl_context = "world"
    # COMPAT_ENGINES must be defined in each subclass, external engines can add themselves here

    @classmethod
    def poll(cls, context):
        wld = context.world
        rd = context.scene.render
        return wld and (rd.use_game_engine is False) and (rd.engine in cls.COMPAT_ENGINES)

class RenderCustomSettingsWorld(PropertyGroup):

    world_amount = FloatProperty(
        name="amount",
        description="test",
        min=0.0, max=1.0, soft_min=0.01, soft_max=1.0, default=0.25)

class WORLD_PT_world(WorldButtonsPanel, bpy.types.Panel):
    bl_label = "World"
    COMPAT_ENGINES = {'custom_renderer'}

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

        row = layout.row()
        row.column().prop(wld, "ambient_color")
        #row = layout.row()
        #row.column().prop(wld, "world_amount")
        row = layout.row()
        row.column().prop(wld.custom, "world_amount", slider=True)

#bpy.utils.register_class(WORLD_PT_world)

# ======================================================================================
# Register
# ======================================================================================

def register():
    bpy.utils.register_module(__name__)
    bpy.types.Scene.custom = PointerProperty(type=RenderCustomSettingsScene)
    #bpy.types.Material.custom = PointerProperty(type=RenderCustomSettingsMaterial)
    bpy.types.World.custom = PointerProperty(type=RenderCustomSettingsWorld)

def unregister():
    bpy.utils.unregister_module(__name__)
    del bpy.types.Scene.custom
    del bpy.types.Material.custom
    del bpy.types.World.custom
    del bpy.types.Scene.custom

if __name__ == "__main__":
    register()

Note: The script was written a while ago, it is a bit messy but I hope you get the idea.

For a simpler approach you can also extend the render panel. Best practice is to take a look into the templates that are shipped with blender:

To define your custom file output you can create a custom file property like this:

app_path = StringProperty(
            name="Export files to:",
            description=""
            description="Path",
            maxlen=1024, subtype="DIR_PATH")

or use scn.render.filepath. For this case here you can find a working example: Is it possible to render only keyframes from Dope-sheet?


I downloaded your file and all the faces are there. My Blender is 2.75, try updating yours :)

But if you still have the problem after updating your Blender, try selecting all the edges and vertices and press space and search for "Fill Holes" and select. This should fix it :)


create a folder in a specific path using Blender python

You have following options. I use the file name myfile.xxx as placeholder for whatever file shall be opened.

Open within the folder where blender is installed:

    fout = open("myfile.xxx")

However you might run into permission issues when the installation folder is write protected.

Open in the user Application folder (Appdata)

    import bpy
    import os
    userdir = bpy.utils.resource_path('USER') # see note
    mypath  = os.path.join(userdir,"myfile.xxx")

    fout    = open(mypath)

Note: Please check also bpy.utils.user_resource(...)

Open in the same folder where the current blend file is located

    import bpy
    import os
    blenddir = py.path.abspath('//')
    mypath   = os.path.join(userdir, "myfile.xxx")

    fout     = open(mypath)

Note: If the current session has not yet been saved to a blend file, then blenddir is returned as empty string! You might need to test for this in your script.

Open in addon folder

    import bpy
    import os
    import myaddon
    myhome = os.path.dirname(myaddon.__file__)
    mypath = os.path.join(myhome, "myfile.xxx")

    fout     = open(mypath)

Hint: When you have installed the Addon by using the Addon Tab in User Preferences, then myhome points to Blender's scripts/addons/myaddon folder in the Appdata directory.

Open in Preset folder (where to store addon presets)

    import bpy
    import os
    import myaddon
    presets   = bpy.utils.user_resource('SCRIPTS', "presets")
    mypresets = os.path.join(presets, myaddon.__name__)
    if not os.path.exists(mypresets):
        os.makedirs(mypresets)
    mypath = os.path.join(mypresets, "myfile.xxx")

    fout     = open(mypath)


Using 3D Bezier Curve but having different shading

Is your curve made from a single continuous segment, or does it have multiple separate segments?

If it has multiple separate segments some of them may have a different direction, yielding inverted normals. You can either:

Invert the curve direction of the affected segments in Edit Mode, by pressing Switch Direction button in the tool shelf, or
Tick the Calc Order in the Screw modifier to make them consistent automatically

If you already converted it to a mesh or applied all modifiers just enter edit mode, select all faces and press Ctrl+N to recalculate normals.


Corrupted? Plane with White material rendering Black in Solid view

The problem is you need to apply your scale transforms on the objects. The reason the faces are shading poorly is because of Z-fighting, which is occurring because your objects have zero Z scale value. Applying scale will also allow your modifiers to work.

To apply the scale, select all your objects in object mode, press Ctrl-A and Scale. Or in the viewport header, Object -> Apply -> Scale

Your scale values should now read 1.0, 1.0, 1.0.


Detail lost when cycles baking to texture

Your problem is that your UVs in their present state are really bad for baking. This may seem to work for your other texture, but the UVs are heavily distorted in the main body area where you noticed the issue.

You can use "Smart UV Project" to get a decent set of baking UVs so that you don't need to waste time on it (make it a new UV so as not to overwrite the old one).

Here is a quick bake and the results in texture mode:


When I texture paint when I repeat and tile brush to get smaller it gets worse?

I think that if your target's resolution (image texture being painted on) is low, it will have problems interpreting the projected pixels. If you instead paint on a larger image of at least double the resolution, you will get a better result.

Here I made a 2048x2048 brush, set to repeat like yours and painted into a 4096x4096 target image.


Textures turn magenta when the shader fails to locate the image texture assigned to it. Double check the image paths for the rock and sand diffuse textures in the node tree. Reopen the images if it need be.

Hope it helps!


How does scultping fit into the workflow?

Generally speaking, sculpting is used either to add details to a model, or the replicate organic organisms. In the former, it is used as a final stage to create a normal map, and does not significantly alter the shape of the model. In the latter, all but the most basic blocking out is done using sculpting, and the topology is created after the fact, using retopology.

Adding Details

When you use sculpting to add details, those details are generally baked into a normal map. Create a model that fully defines the overall shape of your mesh, and then sculpt fine details on it. Just keep a pre-sculpt copy of the mesh, and then use blender built-in baking features to turn those details into a normal map.

Organic Organisms

While some people do use sculpting to create hard surface objects, this is the exception and a fairly advanced use of sculpting. CG Cookie once made a tutorial on this (requires a subscription) if you are interested.

The majority of users use sculpting to create creatures and characters. Often they model a basic mesh that defines the shape, and then sculpt from there. They will then retopologize the mesh and possibly bake any lost details into a normal map. The retopology makes the mesh animation ready, and brings down the insanely high polygon count.


This Answer is incomplete, but might bring you closer to your goal.

I used a Volume shader hooked up to a voronoi texture to create the bubbles, but I didn't manage to make them glossy or refractive.
Is that even possible, using volumes?

The biggest problems with your render are:

it is only one closed volume, it will never give realistic results
don't use emission shaders in non-emissive materials

With materials like this, I would strongly recommend using a completely procedural way, without any image textures.


Blender mist pass final render looks darker than viewport

Just change color management view Transform to Raw. Seems mist pass wont apply the filmic color filter.


Apply linear transformation to a set of vertices

I found a simple solution to this particular problem, if you rotate the pyramid such that the largest face lies on the x-y plane and scale in the z-direction, you can create a regular tetrahedron.

I'm leaving the question open however, because I'm interested in how to apply general linear transformations to meshes.


How can I batch render multiple blendfiles consecutively?

Basics of Blender's CLI (Command line interface)
The command line is definitely the way to go. Here is a little training that should be enough to get anyone up and running:
blender

Is the command to run Blender from the command line (you may need to setup an alias to have this on Mac or Linux).
blender -b

-b is a flag that will run Blender in background mode. This is generally what you eventually want when rendering because it is generally faster. However, until you are confident with the command line, you may want to load the UI anyway, so that you can see what it's doing. To do so, simply omit the -b flag. Note that to do the rest of these commands effectively, you must ensure that you have the -b flag enabled.
blender -b filename.blend

Will open the file in the background, but still close immediately. This is not very useful, though, so we do something like this...
blender -b filename.blend -a

This will render out the animation as if you had opened the file and hit "Render Animation."
blender -b filename.blend -f framenumber

This will render out only the frame that was named, e.g.,
blender -b test.blend -f 10

will only render frame 10, then close.

Multi-file rendering
You can, however, string multiple files together. Suppose you are in a folder that has three blend files a.blend, b.blend, and c.blend. You want to render the 15th frame of a.blend, the entire b.blend animation, and the first frame of c.blend.
blender -b a.blend -f 15 b.blend -a c.blend -f 1

This command accomplishes this for us quite easily. Note that this is essentially the same thing as writing the following.
blender -b a.blend -f 15
blender -b b.blend -a
blender -b c.blend -f 1

In most command lines, you can also replace it with the following.
blender -b a.blend -f 15; blender -b b.blend -a; blender -b c.blend -f 1

Note that this is just the previous commands strung together on one line and separated by semicolons.

A bit about directories
There is something when using the command line called the current directory. You can change directory (the current directory) with the cd command. The above assumes that all of the blend files are in the current directory which means that you can leave off the absolute file paths.
Suppose in the command above, we want to access three blend files that are on the desktop. We could cd into the desktop (change the current directory to the desktop), so that the files can be accessed relative to that directory. On Unix systems (mostly Linux and MacOS), you could do something like this.
cd /Users/Username/Desktop/

The user's home directory has a shortcut ~, so this is the same as the following.
cd ~/Desktop/

Default preferences for the terminal probably open it where the current directory is the user's home directory, so you can probably just do...
cd Desktop/

To see what is in the folder you are in, you can use...
ls       # Mac/Linux

dir      # Windows

To see the folder path...
pwd      # Mac/Linux

cd       # Windows (just use change directory without arguments)

The clunky way - absolute paths
That said, you could just use absolute paths and completely disregard the current directory stuff. I wanted to avoid showing this because of the difference between Unix and Window's ways of writing paths. Unix separates folders with / and Windows separates folders with \. I'll be showing the Unix style in this example. Note the use of the ~...see above for what this means.
blender -b ~/Desktop/a.blend -f 15 ~/Documents/BlendFiles/b.blend -a /Users/Freddy/Desktop/c.blend -f 1

So if the Desktop is in the Freddy directory, a.blend and c.blend are both in the same folder.

Paths with spaces in them
One problem that you may encounter as Delagone mentioned in the comments is something like trying to navigate to:
/Users/Freddy/My Folder/

...where My Folder/ has a space in it. Because the command line separates arguments by spaces, you'll need to put double quotes around that argument to tell the command line to treat it all as one argument. For example, you could do something like the following.
cd "/Users/Freddy/My Folder"

This is one reason why most programmers tend to name folders without spaces; it makes it easier when working from the command line to navigate. Instead you can always name folders with camel-case MyFolder or with underscores my_folder.
If you are on a Unix-based system (I've not yet tested this on Windows), you can also escape the space and leave out the quotes. This is the default behavior for tab auto-completion on a Mac, while the quotes are default for Windows.
cd /Users/Freddy/My\ Folder/

The \ is the escape character and tells the command line to not interpret the next character in the usual way. In this case, it makes it treat it as a regular space character without separating them as arguments.


Use Outliner to select the object that causes this problem.

And avoid subdividing objects more than 4 times as this may be too much for your hardware.

Almost three million faces for such simple objects is a bit of an exaggeration, most likely it's beyond the limit of what your computer can handle.


Outliner : show objects match name with wildcards

I found the solution (only for 2.9 above , not working in 2.8 ) , the search box in outliner can accept regex (unix regex) pattern.
floor [1,3,12-14]

1,3 -> to match floor 1, floor 3
12-14 -> match range between 12 to 14 -> floor 12 , floor 13, floor 14
and will skip other number outside the range 1,3,12-14
We can also use ^ to exclude ( '^' means 'NOT') . For example if we type 'Floor [^143]', it will show everything starts with 'Floor ' but NOT starts with 'Floor 1' , 'Floor 4' and 'Floor 3'.


boolean modifiers working in viewport but not in renders

Ergh, so dumb. I found the issue while simplifying the file as suggested. It was a solidify modifier on the boolean object that was turned off in viewport but on in render. The issue arose because I created the bool object based on the window and didn't delete the modifier.


How to write a python script that opens My_file.blend and applies a script on it?

Start with the basics

blender --background my.blend --python myscript.py

where myscript.py contains your logic and

bpy.ops.render.render(write_still=True)

To produce the render

in your script you can change just about anything e.g.

bpy.context.scene.render.image_settings.file_format='PNG'

Set the output filename

You can also pass parameters and include multiple python scripts.


Controlling vector mapping using object geometry

Yes, you can do this pretty easily in Cycles using a Mix RGB node.  Since Cycles considers colors and vectors to be no different from each other you can actually run vectors through color sockets and vice-versa.

Just use a Mix RGB node to mix the two vectos with the Backfacing value plugged into the factor.  You can then plug the "Color" output from the Mix node right into the image texture nodes.


How to render Animation with solid shading?

Sometimes one need some time to find the right button :-)


You need to select the edges at the end of your cylinder when you add the bevel.

It looks like you have selected an edge loop that is offset from the end, which just adds extra edge loops along the cylinder.

The bevel tool needs a corner to do add a bevel. Use the  mouse wheel to add extra cuts to get the rounded bevel.


Texture not showing using Project from View

You obviously have not set the texture for the "white" material (Material), but for the "wooden" material (Material.002) only. Just add the texture to the white material.

Or if you don't need the white material, just remove it by selecting it and clicking the (-)-button to the right side. Since you would have then just one material, everything of this object should then be made of that one material.

I hope I could help!


Get camera focal length as scalar value in shader node

At its simplest:

Right-click in the Focal Length property-field of the camera, and 'Copy as New Driver'
Create an Input > Value node in your tree
Right-click in the Value field, and 'Paste Driver'.


Just posting this so I can post the pic. I suspect the problem is that you have your light radius set too large. It's hard to tell from the video, but it looks like you have a point light above your "room". As you can see from the image below, a large light bleeds through the walls and reflects off the roof similarly to how it does in your video. If you have a point light with a radius that is large, consider reducing the size. If you don't want it coming through the walls, also consider enabling contact shadows, but bear in mind, this may require your walls to have some thickness to work properly. See below:


Blender BGE move mesh in the direction its facing

Just activate the L in the motion actuator MoveUpAeither for Loc or Rot or both as desired.

It is already active for most other actions, only the forward motion is deactivated (probably by accident)


Is there an easy way in python to find the bpy.data.images that are used in a node?

Recurse the tree.
In question code, the major rate determining step will be checking the list for dupe to append, often quicker to add them all and use a set if only unique members are of interest.
Suggest can use list comprehension, or recursively walk the tree.
Here is an example, pass a node tree to a method and walk its nodes, if it has an image property yield it, if it has a node tree yield from it.
Personally I like the simplicity of yield syntax usage for traversing a tree, and the low memory hogging nature of generators, however they need a little tweaking to optimize for speed, see below
import bpy

def images_in_tree(node_tree):
    for node in node_tree.nodes:
        if hasattr(node, "image"):
            yield node.image
        if hasattr(node, "node_tree"):
            yield from images_in_tree(node.node_tree)

for mat in bpy.data.materials:
    if mat.use_nodes:
        print(set(filter(None, images_in_tree(mat.node_tree))))

Note could yield above getattr(node, "image", None) to avoid testing and filter out the Nones, however it may be a better idea to yield the node_tree, and the node.  The ID data of the node_tree node_tree.id_data will be a material or a node group.
Just the number of unique images in tree.
In answer to

Keep track of how many images are in use in a Material (Or node_tree)
in real time, printed on the UI, without having to press buttons or
the like

Instead of yielding the images returns only a count.
Used a boolean default dictionary to tag items. Any item is given the default value false
In response to

fyi, you can't use tag here. Or any optimization like caching.

Have tagged both the nodegroups and images with one dict to  make the method directly usable in a draw method, instead of using say a getter of a material property,
bpy.types.Material.image_users = IntProperty(get=num_images)

In which case could lay it out with
layout.prop(mat, "image_users")

and using the collection.tag(False) would be Ok in this context, and removes the need for the default dictionary.
As noted yielding and recursion can be slow in python, however using functools.lru_cache seriously fixes this see similar gain here https://blender.stackexchange.com/a/199075/15543 as well as other optimizations used. See lru_cache link re expiring or clearing cache on some interval
Basically it is caching the result of a call to memory.
import bpy
from collections import defaultdict
from functools import lru_cache

@lru_cache(16) # play with this
def num_images(mat):
    tag = defaultdict(bool)

    def unique(node):
        img = getattr(node, "image", None)
        if tag[img]:
            return False
        tag[img] = True
        return img is not None

    def images_in_tree(node_trees):
        for node_tree in node_trees:
            if tag[node_tree]:
                continue
            tag[node_tree] = True
            yield sum(unique(n) for n in node_tree.nodes)
            yield from images_in_tree((n.node_tree  for n in node_tree.nodes if hasattr(n, "node_tree")))
    return sum(images_in_tree((mat.node_tree,)))

# make an int material property
bpy.types.Material.image_users = bpy.props.IntProperty(get=num_images.__wrapped__)
# tack a draw method to text editor footer to test
from random import random
def draw(self, context):
    mat = context.object.active_material
    if mat:
        self.layout.prop(mat, "image_users")
        if random() <= 0.5:
            num_images.cache_clear()
        self.layout.label(text=f"{num_images(mat)}")

bpy.types.TEXT_HT_footer.prepend(draw)

The material property uses an uncached version of the method above, num_images.__wrapped__ the label uses the cached method.  The cache is cleared each time a random is below a threshold. The expectation above is that it is only calculated approximately every 2nd time.
Other methods to consider would be using a counter on the UI class, clearing in a draw, poll or __init__ method of classes in different regions, a draw call back.. (Or as mentioned prior expire the cache) or simply not use it at all.

Extra image tacked into test file, showing 8 images in material, removed shows 7, undo back to 8


Vertices that are not connect with bone get moved by bone

This is what I would do:

With the mesh selected, Tab into Edit mode. If the model snaps back to it's 'resting' state go into the modifier tab and on the Armature modifier click on the eye (Display modifier in viewport), the cube w/ 4 verts (Display modifier in edit mode) and the triangle (Adjust edit cage to modifier result), basically everything after the image of the camera.

You should now be able to see the exact vertices that are acting up. At this point you can select them individually and check the vertex groups that are affecting them.

Select a point and in the properties panel (n), near the top, under vertex weights you will see the offending bone in the list. Hit the 'X' next to it and watch the mesh snap back into place.

I hope this helps.


Read And save custom data outside .blend

You can save individual data blocks to blend files using the bpy.data.libraries.write() function:

import bpy

filepath = "//new_library.blend"

# write selected objects and their data to a blend file
data_blocks = set(bpy.context.selected_objects)
bpy.data.libraries.write(filepath, data_blocks)

# write all meshes starting with a capital letter and
# set them with fake-user enabled so they aren't lost on re-saving
data_blocks = {mesh for mesh in bpy.data.meshes if mesh.name[:1].isupper()}
bpy.data.libraries.write(filepath, data_blocks, fake_user=True)

# write all materials, textures and node groups to a library
data_blocks = {*bpy.data.materials, *bpy.data.textures, *bpy.data.node_groups}
bpy.data.libraries.write(filepath, data_blocks)

See the API documentation for more info.


Assign weight to specific vertices with normalization on

You can use 3D View > Side Bar > Item > Vertex Weights in edit mode.
Rewrite the group value of active vertex to one and
delete other group values with delete buttons.
Then use the copy button to copy the state of the active vertex to the other selected vertices.


Differences in texture painting between 2.7 and 2.8

Switch color space from RAW back to SRGB. Try it out. Additionally: Texture stencils will paint with the original color marked white. If you're trying to create details using a stencil, consider painting in a "layer" for oppacity or roughness instead of the direct color.


Another way to create a 3d grid could be to use a simple basic cube:

add a wireframe modifier for the cube
add an array modifier on X, fixed count (eg) 5
add an array modifier on Y, fixed count (eg) 5
add an array modifier on Z, fixed count (eg) 5

Like this:

At least you can play easily with modifiers until satisfied...

edit:

I'll try to explain (as I got it) what Mentalist suggested in comments: you can avoid the wireframe modifier, using a "wire" material, which allows to save a lot of geometry at the expenses of... geometry, ie: material wireframe width is not adjustable but also in this way you save so many vertices.

I'll also add the option to use a different base shape (a "3d cross" instead of a cube) to save quite more (unneeded) vertices, because using cube and arrays, all cubes share all their vertices... with the "3d cross" this is slightly better.


Trying to use Boolean (difference) Modifier on a ring design and its not working correctly?

Boolean operations sometimes fail when vertices between the two objects line up exactly.
You can work around this by moving one of the objects a very small amount.

Example .blend

Also see “Cannot execute boolean operation” when subtracting several spheres and cylinders from cube


Keyframe properties change after moving playhead

I believe I have done something wrong with my keying set, as removing all influence of the "child of" constraints (after positioning it) and then keying it seems to work fine.

I'll post when I have found a proper answer that doesn't obstruct workflow, but for now it seems to work fine.

In the meantime, any help would be appreciated.


How to write a small program to use the Crayola Easy Animation Studio with Blender?

The mannequin in the package is simply a few bits of plastic that clip together, there are no electronics in it. The included app that does the animation takes a photo of the mannequin and detects the location of each piece to then position the armature used for animation.

While any mannequin could be used for the same thing, you will find the odd shapes printed on this one will be used to get error free location detection of each piece.

Someone could write an app that detects the mannequin pieces and exports the armature data needed to match it. It will be about shape recognition within an image not reading any data being output by the mannequin.


How to copy material texture settings between faces

Following @moonboots' suggestion: If you  select all the faces to be mapped identically, and U unwrap them together, with the 'Reset' option, they will all be mapped to the full (0,0) > (1,1)  UV space. You can then line them all up together.

The shipped 'Magic UV' add-on collection also provides an option to copy and paste UVs, either between individual faces, or between ordered selections. if you copy > [default] a single face, you can then select  destination faces, and paste > [default] (N:M) the UVs into all of them.


Found a way to do it, scale out the top of the circle select the vertices from 10 to 2 o'clock then S Y 0 then extrude the straight edge to the adjacent edge of the mesh.

Repeat for the Vertices from 8 to 4 O'clock locations.

Add Loop cuts and joining up the vertices using the magnet tool, select all and press W and click on remove doubles.


BoolTool changes the way an object is displayed in the 3D window so that you can see the effect of the Boolean operation without the object getting in the way.  It looks like when you undid the BoolTool operation the object remained displayed as "Bounds."
Here's how to check this:
In the properties editor, in the "Object Properties" tab there is a "Viewport Display" item.  Open it and it will show you a list of things that are displayed about the object:

The next to last item is "Display As". This has a drop down menu:

If you leave it as "Textured", then you get the normal behavior where the 3D menu for scene display decides whether to show the wire frame, solid, textured, or rendered view, via:

But if you set it to one of the other values, then it will display the object as no more that that form.
BoolTool does something fairly common in the Boolean based modeling workflow so as to avoid confusing you. Here's an example of a Boolean where I am using a cylinder to cut a hole in the default box:

Because the cylinder is still visible, you can't see the hole in the cube.  So BoolTool and other boolean based workflows like hardops or boxcutter set the cylinder to only display as wireframe or bounding box:


Bmesh - Append selected vertices to a List (Working script not "Reloading" correctly)

Since there was no change in the actual mesh,updating the mesh with update_edit_mesh() was not required.Also setting object context directly to "Edit"mode as opposed to a context mode_set poll() works.

Code can be found here.


After checking my settings , i finally found a solution.
It appears that after animating my character , i didn't turn off the auto-keyframe button which is in the animating layout. Thus , when i move around my character , it automatically set location to the character meshs. Which corrupt with my armature and dynamic.So i deleted my character meshs action editor and it fixed it .
Hope this will help people who will come across this problem like me .
Remember to turn off your auto-keyframe button after you done animation.
Cheers and have a nice day.


What causes the output of this noise texture to be different from the example?

He's using the Object output socket of his Texture Coordinate whereas you're using the UV output socket.


How to add two parents to a single child object in blender?

An object can only have one parent. In the example you give, you want one wheel bone to control the wheel. This bone would be animated to rotate on its Y-axis, this bone is then parented to a steering bone that will "turn" the wheel bone, but does not directly move the wheel mesh.


Image Texture is duplicating itself across the back of the image?

In the unwrapped sphere, the center of the flower pattern is probably where you want the iris to show up.  The "pedals" represent the sides and back of the sphere.  Blender automatically wraps the "pedals" around over the image again if they go off the edge.  On the other hand, if they don't go off the edge, the iris is too large.  Probably the easiest solution is to edit the iris image itself to make the iris smaller and then have more white background.

The original iris picture I used (https://image.shutterstock.com/image-illustration/illustration-blue-iris-digital-artwork-260nw-566777233.jpg) had the white just barely fitting around the iris.  I used Gimp to shrink the iris and make more white margin.

When I used the new iris picture for the texture, it worked.

As you can see, the iris is still huge, but that would have been solved if I had made the iris smaller in Gimp.  You can probably use most other image editors to shrink the iris (maybe even blender, though I couldn't figure out any easy way to do that).  If you have Gimp, I made the iris smaller by selecting the iris and shrinking it with the scale tool.  Then I selected the main (Iris.png) layer and filled the alpha area with white.


Is there a way to change the mortar color of an image texture from black to white through node editor?

You can use a setup similar to this answer.
Since the target color is black, you can calculate the relative length of each channel, use a Math node set to "Less than" and tweak the threshold to mask the grout part.
Then use a Mix RGB set to Mix to set the grout color (here, white)

Result :

Since the grout is not pure black, you have to tweak the Compare node threshold to get the desired effect. Too little, and you have persisting black spots. Too high, and you begin masking undesired darker colors.


How to make the compositing to use the Z Channel in Blender?

First off you are going to want to get the depth data in a better format. The image in your question is an eight bit png, meaning it can only hold 256 different values. You need more precision then that to get a good depth map.

Now in the compositor, take your two images (color, and depth) and plug them in to a Defocus node. I had to do some manipulations to the depth data before it was usable. First use a ColorRamp node to move the black to white range to where you need it. (In your depth image the black part goes from .0061 to about .122 then jumps to white.) So I moved the black slider to .005, and crushed the white end down to .011. Now the lack of precision in the depth image becomes very clear. To compensate for that I blurred the depth image after the ColorRamp node.
Now that can be used as the Z for the Defocus node.

Tweek the Z-Scale (blur amount), Max Blur and Threshold in the Defocus node till you get an image that is to your liking.

This is what I got with the nodes above and using your two images.


Blender Game Engine Rigid Body Instability

You want something like this?

Notice the bottom right of the screen. I have locked the X and Z rotation for all the legs (Both upper and lower).

Alternatively, you could use this method, but it stiffens the joints so it's able to stand:

Notice that I have deselected the Angle X limiter. In addition, I changed the joint type to hinge for all upper limbs.

Alternatively, disregard the modifiers on your upper limbs, and assign them to the lower limbs instead using a hinge pivot like this if you don't want the stiffness of the previous solution:

Note that the hinge modifier only affects the LOCAL X axis, not the global. So you have to re-orientate the limbs like I did to get the local X axis pointing the same way as the global axis (Just for reference, they have to point directly 90 degrees out from your limbs.

If you look closely, you'll see a gap between the lower legs and the main body compared to the back legs. I made this quickly, so I didn't adjust to the 100% accurate values, but you have to tweak the Angle X min/max values to your liking. This will determine how far the legs are allowed to rotate along the X axis. Too high and the legs will go through each other, too low and the lower legs won't connect with the main body when it's laying down. Depending on your needs, these numbers will be different from the ones I gave you, but again, you have to tweak these to your liking. Again, these are local X values relevant to your upper limb.

This deals with your spasm issues.

Hope this helps. Let me know if this wasn't the answer you were looking for.


Arm joint Mesh not moving with Chest mesh when animating

If you switch your armature to Pose mode then your mesh to Weight Paint mode you'll see that the chest bone has zero influence on the arm joints. If you join a mesh to another one Blender can't guess what group the new mesh vertices are supposed to be part of. So use a weight paint brush or assign these vertices to the chest group.


(Blender Eevee 2.9) Soft shadow appear as hard shadow in render

I got a same problem here using EEVEE. But I realized I had a sunlight hiding in my scene. Somehow I press  F12 to final render the hidden sunlight will show up. So I delete that sun light and everything works fine.


Corner of the room is a little bit lighter and shinier

In your shader setup the Image Texture nodes for the Normal Map and the Bump Map should have the Colorspace set to Non-Color, not to Filmic Log.
The Eevee settings look good. Maybe activate Contact Shadow in the settings of the light if you haven't yet.
To make the scene more "real" play with the lights. Where comes the light from? Is there a window? Is it dark outside and there is a table lamp? Try an HDRI for the world background.
Make the car metallic and reduce the Roughness value. If the table and books have no Roughness maps then you can add a Noise Texture node with high scaling to the Roughness. This will make them look less "clean" and "flat" (It's hard to tell from the screenshots if you have already done this)


The Final Output is Different (In terms of world background) than the 3D EEVEE viewport blender 2.92.0

ok, then make that cube.001 hide in render view too.


Blender Basic Bevel is Flat - Not Curved

You can add bevel segments with the mouse wheel or the segments in the options that pop up bottom left of the view port when you confirm your bevel.  This will make them curved.


With the Edge Select mode enabled select the whole edge with Alt+RMB, then go to Select-->Checker Deselect. Set it up to select every second edge segment, then press X-->Edge Collapse.


This is really a personal preference thing. I personally dislike appending objects because it often ruins the loops of the mesh. The ugliness of the mesh is fixable by point manipulation. you can drag the points to move them into places that look better. another thing that might help with that is the "adjust cage to modifier result" Basically it makes the lines appear as if they are actually on the subdivided mesh, making point manipulation a lot easier to visualize. I used this when making a face model, it saved me a ton of time.


Mesh Analysis - Why the thickness is uneven on sphere?

Your Y-scale factor is 0.189, perhaps this is skewing your expectations.


Connect vertices from inner circle to outer circle

You should use the Bridge Edge Loops tool.

You can get to it three ways:

CtrlE > Bridge Edge Loops (CtrlE L)
W > Bridge Edge Loops (W E)
From the 3D view header Mesh > Edges > Bridge Edge Loops

alternatively, AltF then AltJ, which will "Beauty" fill the the hole with triangles, then convert the tris to quads.


[Cycles]Is there any way to bake float values

There is currently no support for sending data from an OSL node to a file, values can only be passed into a nodetree used by cycles, which does mean that your OSL script can replace the image node you would use for a bumpmap.

By setting a float output value you pass your calculated height directly into the node setup to be used to alter the displacement or bump of the material.

shader myosl(output float Height = 0.0 )
{
    Height = sin(P[1] + 0.25);
}

While you probably don't want to use both displacement and normal adjustment, you may realize that you don't have to use a closure output in your script. You can calculate any value you want and integrate it in your nodes where you need it.


Same as in 2.7.

Press N while in Object Mode.

Or press on the little < sign on the right of the screen to bring out the window. If the transform section has been minimized, press on the triangle to expand it.


faces semi-transparent in edit mode, revealing background plane

You don't need to have your reference image as a plane, you can also have it as a background which is visible in wireframe mode too. To do so you have to press N to open up the properties and then you have to scroll down to 'Background Images'. Check the box, click 'Add Image' and open up your Image. From there on you can modify the image the way you want like changing it's opacity or making it only visible from top view.

Another way of doing this is to change the maximum drawing type of your car hood to 'Wire' in the 'Object' tab (orange cube, then scroll down to display). This makes only the car hood appear in wire mod and everything else is in the mode you want e. g. Textured, so you can see through your hood but you can still see your background plane textured.


Texturing: Texture not covering complete face

The problem could arise from the fact that the face you are trying to uvmap is an ngon, a polygon with greater than 4 sides. Try pressing CTRL+F and select triangulate faces and then project again. Also make sure that your apple has no non-uniform scale.


How to make precisely defined trails along orbits in space

Trails can be created in Blender using particles. These trails can be generated from simulations or animation. Since the trails are created as geometry, modifiers, shaders, and compositing can be used to achieve a broad range of effects. This image below was generated using this approach.

Step by step instructions (Blender 2.76)

Setup a scene with an object which which will move. For this example, a physics simulation will generate the motion of a bouncing ball. The details of the physics setup are not discussed. Add a sphere out of view of the camera. Call this sphere 'particle-sphere'. It will be used to visualize the trail with the particle system.

Parent a single vertex to the object. This vertex will be the emitter for all particles on the trail. The vertex will emit the particles for the trail.
Create a particle system for the vertex. To simplify things, choose a large number, like 2000, and set the number of particles, the lifetime of the particles and the emission end at this number. This will lead to a single particle being emitted at each frame. Set the render object to a sphere added for visualization. Set the field weight for gravity to 0. This will prevent the particles from moving.

Simulate/animate the scene. Usually, the spacing between the particles will be too high, resulting in a dotted trail. (This will be corrected in a few steps.)

To fade the trail, a shader is used which make the particles increasingly transparent as they age.

To close up the spacing on the dots, the timing needs to be adjusted. First adjust the animation end time. For this example, the end time will be set to 2000 frames. The retiming can be done in several ways. One method is to retime the physics. The other is to bake the physics, (see How to bake rigid body physics frame in blender render? ) then retime the animation. This is opening the dope sheet, selecting the animation channels, a scaling using 's'. In this example, the original 250 frame animation was scaled by 8 to stretch to 2000 frames.

Finally, this retiming will change the real time playback of the animation. To fix this, the animation is rendered skipping frames. Since the animation was retimed by a factor of 8, the animation is rendered using every 8th frame.

This animation is finally generated!

The blend file for the space animation is located here:

The blend file for the example is located here:


Fluid Domain disappears in cycles viewport render

Solution - to bring Fluid Domain whole visible in a viewport:

under Render Properties > Performance > Dynamic BVH change to Static BVH

or under Object Data Properties > Normals enable Auto Smooth

I don't have an explanation for that, very precise pixel based cut looks like some kind of clipping, but I don't see any type active. Also I was thinking about some flipped normals that caused something similar to me once (that's why auto-smooth probably worked here), but since the cliping is straight, it can't be a faces of fluid sim rather than something that cross it, but there is nothing like that ... :) Did you used FlipFluid add-on for that?

So, mystery wasn't explained yet :) But probably future generations will find some useful string of meanings from my notes, that brings a light into this dark old 2.79x ... :)

Anyway I don't have this issue in 2.8x


Is it possible to restore default viewport condition?

File>Defaults>Load Factory Settings. This will reset everything, like your addons, custom startup file too.


You can Shear the top of the cylinder by using Shift+Ctrl+Alt+S, then hit Y to shear Vertically or X Horizontally and adjust the amount of Shearing with the mouse or input a value, then hit Enter to apply.

Note that the mesh is Sheared relative to the view angle.


Too many objects need random emission values

Thanks for your suggestion, but I figured out a different way to tackle the problem. I made all of the windows all as a separate object, and I discovered the random selection tool and randomly selected individual faces to be assigned to emission material


Blender Scripts

Pressing the "run script" button makes the code be executed as Blender script. This does not rely to the BGE. Importing the BGE API will always fail with:

ImportError: No module named 'bge'

BGE scripts

BGE Python code gets executed by python controllers. This means in the logic editor you add a python controller.

The code gets executed when any connected sensor triggers the controller. e.g. by an Always sensor right after loading the object.

Script mode

In Script mode you enter the name of the text block into the value field. The text block will be executed from top to to bottom.

E.g. drawALine

import bge

bge.render.drawLine([0,0,0], [10,10,10], [1,1,1,1]])

Script: drawALine

Module Mode

In Module mode you enter the name of the module (the file name without ".py") with "." which concatenates a function name of the module. The module can be a text block or an external python file that is in the python search path.

E.g. painter.py

import bge

def drawALine(controller):
    bge.render.drawLine([0,0,0], [10,10,10], [1,1,1,1]])

Module: painter.drawALine

Blender API inside the BGE

Using the Blender API bpy inside the BGE will not fail when you run your game embedded in Blender. But any writing to the Blender API will not take effect before ending your game.

When running your game without Blender importing bpy will fail the same way as running BGE scripts inside of Blender:

ImportError: No module named 'bpy'


How to imitate scaling a mesh in Edit Mode without Edit Mode (ie. keeping object transforms at 1, 1, 1 with modal control of the scale)

Use shape keys

Demo, set up with array (fit curve) and curve modifier. The cone is given a shape key which is 1 / 10 the scale of original.  Because the array modifier is using the mesh dimension this "emulates applying scale" in the modifier.

For set up above, when the shapekey value is dragged to  1, the "scale" is 1/10 making 10 x more cones fit the path.


How to sweep a profile along two rotation axes? (how to model globoid worm gear)

That can be a "screw" and a "simple deform" modifiers:

Make a profile (bottom left below).
Set the external part into a vertex group.
Add a screw modifier (use 'calculate order' to set the orientation of the faces correctly).
Add a simple deform modifier. Stretch mode and centered on an empty placed at the center of the screw. Use Z axis to deform around it and the vertex group to be deformed (so only the external part).
Then tune the modifier factor (or scale the empty) so that it corresponds to the wanted circle.


How to apply (make real) a curve generated by modifier in Graph Editor?

Select object, hit SPACE BAR, write Bake Action and Enter.
In pop-up properties window you can keep default setup for this purpose.
Confirm, that's it.


Copy part of a UV sphere to rounded surface

One method could be:

In Edit mode, with those faces selected, use SHFT + D to copy the faces followed by P  to separate the copy into a new mesh object.

Now you can edit the new object ( or copy and paste to a new scene ).


What is relation between edit_bone roll and and pose.bone rotation_quaternion?

I managed to overcome roll differences by resetting roll on all bones to zero without affect final pose (much). Procedure is little hackish but it works:

create armature clone in same place as donor one
add rotation constraint in WORLD coordinates on each bone of clone
reset roll to 0 on all edit bones of clone (bones will do thier best to stay intact due constraint)
execute "Apply Visual Transform to Pose" - bpy.ops.pose.visual_transform_apply() - on clone bones to flush contraints into real bone properties
remember clone rotation_quaternions and delete clone
set roll=0 and rotation_quaternion to remembered values on original armature.

That is all. After that we have almost the same pose, but all roll values on each bone are zeroed out

Code: https://gist.github.com/IPv6/0209f6ff4e013c575ca69ef0fbc0fe14


How should I weight paint for shoulder Region?

You need to change the IK Pole Angles to -90° so that it doesn't deform your mesh:

Also you need to change the modifiers stack, this seems to be more logical (and enable the Armature modifier's Preserve Volume option):


Most efficient way to remove unwanted vertices in an object with 59,000 points?

In edit mode, press C, that will enter you into a Circle select. Just hold LMB  and drag over what you want deleted. When you have selected all you want to delete, Right click. Then press delete (or x) and chose vertices.

There is also a border selection method, which works in ether edit mode or object mode. Press B, just drag with the LMB  held down, when you release it the selection is done.  Delete the same way as above.  If you selected too much you can unselect it by, dragging with the MMB  in either border select or circle select mode.


Checker deselect with disconnected faces on same object

Okay, as Jachym Michal pointed out checker deselect only looks in all directions and stops at disconnected geometry. It doesn't jump over to the next elements index of the object when it finds disconnected geometry.
Here is a script that selects every other polygon, assuming their indices are ordered.
import bpy
obj = bpy.context.active_object
i=0
for p in obj.data.polygons:
    if i%2:
        p.select = True
    i+=1


Unwrap not joining the torso front, back and head UV

Figured it out, the middle vertices (yellow) were duplicated after I applied the mirror, if anyone get the same problem, just delete them and fill the holes again ^^


How can I get the x,y location of an object at each frame of animation?

Here is the code from https://blender.stackexchange.com/a/14746/15543 slightly modified to make the region and region_3d global and put the area into camera view.

import bpy

from bpy_extras.view3d_utils import location_3d_to_region_2d

def view3d_find():
    # returns first 3d view, normally we get from context
    for area in bpy.context.window.screen.areas:
        if area.type == 'VIEW_3D':
            v3d = area.spaces[0]
            rv3d = v3d.region_3d
            for region in area.regions:
                if region.type == 'WINDOW':
                    return region, rv3d
    return None, None

region, rv3d = view3d_find()
# put the region into camera perspective
rv3d.view_perspective = 'CAMERA'

def view3d_camera_border(scene):
    obj = scene.camera
    cam = obj.data
    frame = cam.view_frame(scene)
    # move into object space
    frame = [obj.matrix_world * v for v in frame]
    # move into pixelspace
    frame_px = [location_3d_to_region_2d(region, rv3d, v) for v in frame]
    return frame_px

frame_px = view3d_camera_border(bpy.context.scene)
print("Camera frame:", frame_px)

This gives us the 2d region coordinates of what will be the rendered scene.
If we take out the smallest of these coords we are mapping to "region camera coords" only vectors in (0, 0) to max(cambounds) will be in rendered image.

# this is the camera bounds
blc = min(frame_px)
cambounds = [v - blc for v in frame_px]
print("camera is on screen as :", max(cambounds))

I get as a test case: my render resolution (scene.render.resolution_x, .. resolution_y) is  1920 x 1080 (the ratio x/y = 1.777)

  camera is on screen as : <Vector (328.3195, 184.6790)>

ie the camera rectangle you see in view3d window has size 328 x 184 which has the same ratio.  So all vectors below, like for instance objloc can be multiplied by (1920 / 328.3195) to return them as pixel coords of the rendered image. (nb not taking into account resolution_percentage and non square pixels)

Similarly for object location.

# object location
obj = bpy.context.object # the context object.
objloc = location_3d_to_region_2d(
                      region,
                      rv3d,
                      obj.matrix_world.to_translation()) - blc
print(objloc)

And a quick object bounds using bounding box, get the 2d coords from the 8 3d corners of the bounding box.

bounding_box = [v[:] for v in obj.bound_box]
bbox_px = [location_3d_to_region_2d(region, rv3d, v)
                         - blc for v in bounding_box]

min_x = min(v.x for v in bbox_px)
max_x = max(v.x for v in bbox_px)
bbox_width = max_x - min_x

#... etc to get the coords of bbox.

or this could be done by looping thru the verts of the object

mw = obj.matrix_world
#global vert locs
verts = [mw * v.co for v in obj.data.vertices]
# vert locations in "region camera coords"
verts_px = [location_3d_to_region_2d(region, rv3d, v)
                         - blc for v in verts]

and finding the min max for x, y as above for bounding box.

Note haven't put in code to loop thru frames and write to output file as that is trivial, it's the camera bounds that is difficult, but fortunately handed to us via ideasman42's answer.


First go to Material Tab, then click the + button next to your material, now press the 'Brows Material to be Linked' button and finally press the 2 button next to the material name. Now you have to go to edit mode and click the Assign button at the bottom of the materials list while the letter you want to give the particular material is selected.
By adjusting the new material you will now change the previous
Just see the Gif.


How to automatically rename empties created with hook operator

The hook is the object of last modifier.
When a modifier is added it is going to be the last one on the modifiers stack. Since the operator has added both the modifier and the empty and assigned it to the object property of the modifier, then
new_mod = obj.modifiers[-1]
new_mod.object.name = "Foo"

The whole process of adding hooks can be achieved without using the operator as demonstrated here, or any operator had the empties not been added with one
How can I animate a vertex translation of a triangular mesh?
and the "opposite" ie parenting empties to verts so they follow verts
Blender python to hook vertex and empty
Have used foreach_set to deselect all edges and faces and each vert.  Basically for a 3 vertex object
me.vertices.foreach_set("select", [True, False, False])

is equivalent to
me.vertices[0].select = True
me.vertices[1].select = False
me.vertices[2].select = False

Test Script.
import bpy

obj = bpy.context.object
me = obj.data
# deselect all faces and edges
me.polygons.foreach_set("select", (False,) * len(me.polygons))
me.edges.foreach_set("select", (False,) * len(me.edges))
n = len(me.vertices)
for i in range(n):
    bpy.ops.object.mode_set(mode='OBJECT')
    me.vertices.foreach_set("select", [i == j for j in range(n)])
    bpy.ops.object.mode_set(mode='EDIT')
    bpy.ops.object.hook_add_newob()
    obj.modifiers[-1].object.name = f"Hook_{i}"

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


Copy vertex shape key information to a different object

I would go like this: create a copy of the mesh with shape keys, delete all the vertices not interested by shape changes, delete the corrispondent vertices in the empty space mesh, connect the copied vertices (with the same shape keys) to the empty space mesh: ctrl J to join the two meshes, then delete double to connect the two separate parts.


How can I export a DAE file with a non-rest pose?

Select Apply Modifiers in the Collada export settings.


Is it possible to select all of one type of node in the node editor?

Here is a handy dandy little script that will select all nodes of the same type as the active selected node

import bpy

#Get composite nodes
nodes = bpy.context.scene.node_tree.nodes
#Get indentifer of the active node
find_type = bpy.context.scene.node_tree.nodes.active.bl_rna.identifier
#loop through nodes
for node in nodes:
    #if node has the same idetifier
    if node.bl_rna.identifier == find_type:
        #select it
        node.select = True

In action:


While as Luke mentions this is mostly an opinion based question, subject to personal preference, and largely dependent on what you are trying to achieve, I'll only add that while I see as sculpting a good starting point for planning the base shape of a model or as a finalizing step to add fine details over it, I find that in most situations it is often not a good "final product" on its own.

Sculpting will frequently produce triangulated output and messy meshes especially if using Dynamic Topology-like features. This results in poor topology that is largely unsuitable for the most common tasks that follow to produce a proper final product, like UV Mapping, rigging, armatures, making it hard to animate, tweak or texture.

This will not yield a pleasant model to work with, easy to edit or alter, as such I see sculpting more as a starting point then a final result.

If you plan to unwrap or UV map your model, animate, use modifiers, optimize your mesh or do anything involving exporting elsewhere (like game engines) you will eventually need a good base model, hand modeled with intent and proper quad dominant high quality topology.


I couldn't find which version of Blender had the option to clear when calculating roll, however this seems like it is something Blender should be able to do.

Added http://developer.blender.org/rB2177f645855c242399f3d3324f4d8e0357c3601c

Access from the armature roll menu, or by pressing Alt-R.


How can i export my 3D animation for 3D video?

In that case, here-

Looks like it works in Cycles and Eevee, but the rendered viewport display in Cycles is very broken, and has been a bug since March 2019; https://developer.blender.org/T62582
It does render (F12) OK by the looks of it.
It outputs 2 images from the L/R cameras in 'Stereo 3D' mode, so you'll have to join them into a single Anaglyph image.
If you use 'MultiView' mode it will output an Anaglyph image, but you need 2 cameras in the scene, with '_L' and '_R' suffixes on their names, and you'll have to manually set their position / convergence.

Cheers
Mark


You could try a couple things to improve your results. One is to use Brownian Force under the physics properties of the particle settings.
From the manual:

Brownian
Specify the amount of Brownian motion. Brownian motion adds random motion to the particles based on a Brownian noise field. This is nice
to simulate small, random wind forces.

Also, you may use the rotation values, which does provide a random parameter underneath the advanced tab.
Here are the settings that I used:

Furthermore, using multiple objects will help in your instance collection. The repetition will not be nearly as noticeable if you use 5 or more objects as if you only use one.
Here is the result:

As for the grid pattern, you can vary the density of your density group when you are in weight paint mode if needed. This is an image of my example:


Found it: Ctrl+Alt+G does "Remove From Group".


Does an HDR environment texture affect the Shadow pass?

The HDR environment does not affect the shadow pass. At all. The problem originated with the removal of the lighting setup.

In other words, the shadow pass only supports lamps. Mesh lights and world lighting will not affect it. See Why does the shadow pass not account for mesh lights?


Why does my extruded text go wonky like this? Why does my text go weird when I convert it to a curve?

Did you try using the text settings rather than manually extruding it?


Cell Fracture addon leaving unfractured boxes?

This is caused by a failed boolean operation.

The cell fracture uses the boolean modifier internally, if boolean fails because of geometry it can't handle (typically because of a non-manifold mesh), this happens.

Note that for 2.70 the boolean modifier has been upgraded to support ngons and a newer version of carve, so this will likely improve results in some cases, however there are limits to what boolean can operate on since it relies on calculating inside/outside of a mesh which can be problematic.


Whenever I render, the cube appears over the model but everything looks fine on the view port render

Welcome here!
Whenever you need help and post in any kind of website, it would be nice from you to provide more info about what you did, what you expected, what actually happened, what you tried to solve the problem, give screenshots to illustrate all of that, and indicate what software you're using (and its version) as well as your operating system. It will make everything easier and faster, both for us and you.

My first guess is that you disabled the visibility of your cube in the viewport, but not in the render.

Chac your outliner, you might have something like this :

Eye icon is for Viewport visibility, Cursor icon is for selectability, Camera icon is for renderability. The simplest way to not have your cube in the render is to uncheck the camera icon.

If this doesn't solve your issue, you will have to do what I said above: give more infos.


Blender 2.8 - Object index pass in Eevee

In 2.8, Cycles there is something called the cryptomatte node. Unfortunately, at the time of writing this, it is not implemented for Eevee.

I found a solution by creating view layers, then evaluating the depth in both. View layers are like 2.79's render layers, so you can exclude objects from being rendered in each.

Next, I evaluated depth in both view layers. Since one of the view layers is missing the object, you can use a greater than or lesser node to create a mask.

Here's a video on view layers: https://youtu.be/BBuD64KhxeY?t=1502

I imagine 2.8 Eevee will gain cryptomatte in the future.


select the exploding box then press:
R, Z, 180 --> done!

R = rotation
Z = rotate on Z axis
180 = rotate 180 degree


i have solved it. it was just that the skin modifier was not applied


you shouldn't need to rebuild the proxies if you have already made them - so long as they are the right files in the right places, just set the paths, and you should be able to switch to proxy viewing modes.


Texture paint with face selection masking now shows wireframe

I found it out, this was caused by the edge split modifier.
With it being visible it looks like this.


Check your 3D printer settings and limitations for how much empty space you are permitted between structures, sometimes you will have to model in support beams in hollow areas and you will have to remove them once printed. You could print a mold and use latex and resin or print and glue together two halves.


Where are the options for the Loop Cut and Slide?

The last operation box is in the bottom left, just click to unfold:


The simplest way to fix this problem is to pack the sounds inside your blend file..

Use the menu command : File -> External Data -> Pack All into .blend file.

(It also gives you some fps boost!)


Baking only one material on multi-material object

I am surprised, because I can bake multiple materials in cycles in blender  2.76b. The important thing I have to select an active image for all the materials linked to the object, and they can be different images. Active image is the selected one in the node setup of the material. So select a different image for the procedural textured. Please try it.

The selected image is the active, and not necessarily connected to the node graph. However you must select one for all of the materials of your object

If it fails try this instead

Make a duplicate from your character, delete all the materials except the one with the procedural texture. You will get the texture with baking, however it will be all over your UV map, but you can make a mask for it with a next bake

Use a pure white material instead of the procedural textured, and a pure dark for the others. You can use this mask to recover the wanted result from the previous bake.


While its undoubtedly possible to do some tricks to make a huge screen-shot (automate panning and capturing the view, then joining up the tiles), Blender has nothing built-in to perform such an operation.


Texture as Backfacing material in Blender Internal using Nodes

You have to use "window" method for texture projection.

Here is blender file with material both for Cycles and internal render, just press Shift+Z and select any of theese renders - result is almost same.

For Cycles it is Geometry Info node, for internal it is Coordinates parameter in texture block properties.


Your bell, archway and other parts are all sharing the same material node tree which means the objects will all share the same pixels in the image texture. Separate them by pressing the '12' next to the material name'Stone arch' to create individual user materials that can be changed, or assign them new material altogether.


You can do this automatically by:

Select your mesh
Enter edit mode
Select All
Press P then choose Separate by loose parts

If you want to separate the selected parts then:

Select your mesh
Enter edit mode
Select the part of mesh you want to separate from the mesh
Press P then choose Separate by Selection


Stuck at UV Mapping: mesh doesn't show in UV Window

see those mask icons on the bottom right corner of your UV/image window?

Select the one on the left and change it to view


It worked by disabling the generation of mipmaps with the GPU, in User Preferences


I figured it out. What the problem was is that I didn't move the 1st object above the surface of the scene before appending the other. But thanks for the help anyway.


Animate a circular deformity moving across the edge of an object

One way is to use the Wave Modifier.

Subdivide the plane a bit (5-6 levels of Subdivision Modifier)
Add the Wave Modifier and play with different values
Use the Video Sequencer slider to preview the animation


I would rotate the image in an external program like paint or Photoshop.
CORRECTION

https://i.stack.imgur.com/R0Y5Y.png

you can rotate it here.


How to make a bubble that doesn't reflect the inside

I have no solution for a glass material. Changing normals of the inside wall of glass or using a different material for the inside of the glass results in problems with refraction etc.
Instead you might try to change the material of the object inside the glass bubble. I've put an Emssion Shader on Suzanne so that the reflection is clearly visible. If I mix the Emission (or any other) Shader with a completely white Transparent BSDF and use Glossy Depth from the Light Path input as a mix factor, then the reflection only shows the transparent material i.e. nothing.

Of course that's not very handy if you try to put objects with many different materials into the bubble because you cannot simply have one glass material with the correct settings, but many other materials to prepare.


Use me.update(calc_edges_loose=True). Make sure you do it after you set the edges though, not before where you currently have me.update().


How to apply a soft body simulator on a certain part of an object?

Cloth simulation Pin Group should do the trick. Just assign the non moving vertices to a specific group and use it in the Shape/Pin Group field of the cloth simulation settings panel.


In cycles
use a gradient texture using a quadratic sphere as the color style blending.

Blender Internal
Use quadratic sphere for the blend and sphere for the projection:


Cursor is set to move by increments. how to reset to normal?

It sounds like you may have accidentally enabled Transform Snapping (⇧ Shift↹ Tab).

By default transform snapping will snap objects to fixed increments as they are being transformed.

  Transform snapping:
  The ability to snap Objects and Mesh element to various types of scene
  elements during a transformation is available by toggling the magnet
  icon (which will turn red) in the 3D view's header buttons.

  Increment:
      Snap to grid points. When in Orthographic view, the snapping increment changes depending on zoom level.

You can disable it by clicking the magnet icon in 3D view > Header, or by pressing Shift+Tab:

Enabled

Disabled

For Version 2.8.


Cannot manipulate UVs in the UV editor viewport

You have UV Sculpt enabled (hotkey is Q, maybe it's not terribly hard to hit it by accident)in the UV Editor's "t" panel. Hit t to show the panel, navigate to options tab and disable it or just hit Q while in UV Editor to get out of UV Sculpt mode:


Grease Pencil stroke thickness not behaving in render like in viewport

Thanks again from the help of the Blender Discord server users, I've been told that the "Adjustments > Stroke Thickness" does not render.

I managed to get the look I want using the "Strokes > Thickness Scale" setting only.

edit : This bug is now solved with the latest 2.82 build.