object_cloud_gen.py

# ##### BEGIN GPL LICENSE BLOCK #####
#
#  This program is free software; you can redistribute it and/or
#  modify it under the terms of the GNU General Public License
#  as published by the Free Software Foundation; either version 2
#  of the License, or (at your option) any later version.
#
#  This program is distributed in the hope that it will be useful,
#  but WITHOUT ANY WARRANTY; without even the implied warranty of
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#  GNU General Public License for more details.
#
#  You should have received a copy of the GNU General Public License
#  along with this program; if not, write to the Free Software Foundation,
#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#
# ##### END GPL LICENSE BLOCK #####


bl_addon_info = {
    'name': 'Object: Cloud generator',
    'author': 'Nick Keeline(nrk)',
    'version': '0.1',
    'blender': (2, 5, 3),
    'location': 'Tool Shelf ',
    'description': 'Creates Volumetric Clouds',
    'url': 'http://wiki.blender.org/index.php/Extensions:2.5/Py/' \
        'Scripts/Object/Cloud_Gen',
    'category': 'Object'}


"""
Place this file in the .blender/scripts/addons dir
You have to activated the script in the "Add-Ons" tab (user preferences).
The functionality can then be accessed via the Tool shelf when objects
are selected

Rev 0 initial release
Rev 0.1 added scene to create_mesh per python api change.
"""

import bpy
import mathutils
from math import *
from bpy.props import *

# Deselect All
bpy.ops.object.select_all(action='DESELECT')


# This routine takes an object and deletes all of the geometry in it
# and adds a bounding box to it.
# It will add or subtract the bound box size by the variable sizeDifference.
def makeObjectIntoBoundBox(object, sizeDifference):
    # Deselect All
    bpy.ops.object.select_all(action='DESELECT')

    # Select the object
    object.selected = True

    # Go into Edit Mode
    bpy.ops.object.mode_set(mode='EDIT')

    mesh = object.data
    verts = mesh.verts

    #Set the max and min verts to the first vertex on the list
    maxVert = [verts[0].co[0], verts[0].co[1], verts[0].co[2]]
    minVert = [verts[0].co[0], verts[0].co[1], verts[0].co[2]]

    #Create Max and Min Vertex array for the outer corners of the box
    for vert in verts:
        #Max vertex
        if vert.co[0] > maxVert[0]:
            maxVert[0] = vert.co[0]
        if vert.co[1] > maxVert[1]:
            maxVert[1] = vert.co[1]
        if vert.co[2] > maxVert[2]:
            maxVert[2] = vert.co[2]

        #Min Vertex
        if vert.co[0] < minVert[0]:
            minVert[0] = vert.co[0]
        if vert.co[1] < minVert[1]:
            minVert[1] = vert.co[1]
        if vert.co[2] < minVert[2]:
            minVert[2] = vert.co[2]

    #Add the size difference to the max size of the box
    maxVert[0] = maxVert[0] + sizeDifference
    maxVert[1] = maxVert[1] + sizeDifference
    maxVert[2] = maxVert[2] + sizeDifference

    #subtract the size difference to the min size of the box
    minVert[0] = minVert[0] - sizeDifference
    minVert[1] = minVert[1] - sizeDifference
    minVert[2] = minVert[2] - sizeDifference

    #Create arrays of verts and faces to be added to the mesh
    addVerts = []

    #X high loop
    addVerts.append([maxVert[0], maxVert[1], maxVert[2]])
    addVerts.append([maxVert[0], maxVert[1], minVert[2]])
    addVerts.append([maxVert[0], minVert[1], minVert[2]])
    addVerts.append([maxVert[0], minVert[1], maxVert[2]])

    #x low loop
    addVerts.append([minVert[0], maxVert[1], maxVert[2]])
    addVerts.append([minVert[0], maxVert[1], minVert[2]])
    addVerts.append([minVert[0], minVert[1], minVert[2]])
    addVerts.append([minVert[0], minVert[1], maxVert[2]])

    # Make the faces of the bounding box.
    addFaces = []

    # Draw a box on paper and number the vertices.
    # Use right hand rule to come up with number orders for faces on
    # the box (with normals pointing out).
    addFaces.append([0, 3, 2, 1])
    addFaces.append([4, 5, 6, 7])
    addFaces.append([0, 1, 5, 4])
    addFaces.append([1, 2, 6, 5])
    addFaces.append([2, 3, 7, 6])
    addFaces.append([0, 4, 7, 3])

    # Delete all geometry from the object.
    bpy.ops.mesh.select_all(action='SELECT')
    bpy.ops.mesh.delete(type='ALL')

    # Must be in object mode for from_pydata to work
    bpy.ops.object.mode_set(mode='OBJECT')

    # Add the mesh data.
    mesh.from_pydata(addVerts, [], addFaces)

    # Update the mesh
    mesh.update()


def applyScaleRotLoc(scene, obj):
    # Deselect All
    bpy.ops.object.select_all(action='DESELECT')

    # Select the object
    obj.selected = True
    scene.objects.active = obj

    #bpy.ops.object.rotation_apply()
    bpy.ops.object.location_apply()
    bpy.ops.object.scale_apply()


def makeParent(parentobj, childobj, scene):

    applyScaleRotLoc(scene, parentobj)

    applyScaleRotLoc(scene, childobj)

    childobj.parent = parentobj

    #childobj.location = childobj.location - parentobj.location


def addNewObject(scene, name, copyobj):
    '''
    Add an object and do other silly stuff.
    '''
    # Create new mesh
    mesh = bpy.data.meshes.new(name)

    # Create a new object.
    ob_new = bpy.data.objects.new(name, mesh)
    tempme = copyobj.data
    ob_new.data = tempme.copy()
    ob_new.scale = copyobj.scale
    ob_new.location = copyobj.location

    # Link new object to the given scene and select it.
    scene.objects.link(ob_new)
    ob_new.selected = True

    return ob_new


def combineObjects(scene, combined, listobjs):
    # scene is the current scene
    # combined is the object we want to combine everything into
    # listobjs is the list of objects to stick into combined

    # Deselect All
    bpy.ops.object.select_all(action='DESELECT')

    # Select the new object.
    combined.selected = True
    scene.objects.active = combined

    # Add data
    if (len(listobjs) > 0):
            for i in listobjs:
                # Add a modifier
                bpy.ops.object.modifier_add(type='BOOLEAN')

                union = combined.modifiers
                union[0].name = "AddEmUp"
                union[0].object = i
                union[0].operation = 'UNION'

                # Apply modifier
                # Can't use bpy.ops.object.modifier_apply because poll fails.
                combined.data = combined.create_mesh(scene,
                    apply_modifiers=True,
                    settings='PREVIEW')
                combined.modifiers.remove(union[0])


# Returns True if we want to degenerate
# and False if we want to generate a new cloud.
def degenerateCloud(obj):
    if not obj:
        return False

    if "CloudMember" in obj:
        if obj["CloudMember"] != None:
            if obj.parent:
                return True

            else:
                del(obj["CloudMember"])

    return False


class View3DPanel(bpy.types.Panel):
    bl_space_type = 'VIEW_3D'
    bl_region_type = 'TOOLS'


class VIEW3D_PT_tools_cloud(View3DPanel):
    bl_label = "Cloud Generator"
    bl_context = "objectmode"

    def draw(self, context):
        active_obj = context.active_object

        degenerate = degenerateCloud(active_obj)

        if active_obj and degenerate:
            layout = self.layout

            col = layout.column(align=True)
            col.operator("cloud.generate_cloud", text="DeGenerate")

        elif active_obj and active_obj.type == 'MESH':
            layout = self.layout

            col = layout.column(align=True)
            col.operator("cloud.generate_cloud", text="Generate Cloud")

        else:
            layout = self.layout

            col = layout.column(align=True)
            col.label(text="Select one or more")
            col.label(text="objects to generate")
            col.label(text="a cloud.")

classes = [VIEW3D_PT_tools_cloud]


def register():
    register = bpy.types.register
    for cls in classes:
        register(cls)


def unregister():
    unregister = bpy.types.unregister
    for cls in classes:
        unregister(cls)

if __name__ == "__main__":
    register()


class GenerateCloud(bpy.types.Operator):
    bl_idname = "cloud.generate_cloud"
    bl_label = "Generate Cloud"
    bl_description = "Create a Cloud."
    bl_register = True
    bl_undo = True

    def execute(self, context):
        # Make variable that is the current .blend file main data blocks
        main = context.main

        # Make variable that is the active object selected by user
        active_object = context.active_object

        # Make variable scene that is current scene
        scene = context.scene

        if active_object and active_object.type == 'MESH':
            # Parameters the user may want to change:
            # Number of points this number is multiplied by the volume to get
            # the number of points the scripts will put in the volume.
            numOfPoints = 35
            maxNumOfPoints = 100000
            scattering = 3
            pointDensityRadius = 0.4

            # Should we degnerate?
            degenerate = degenerateCloud(active_object)

            if degenerate:
                # Degenerate Cloud
                if active_object["CloudMember"] == "MainObj":
                    mainObj = active_object

                else:
                    mainObj = active_object.parent

                cloudMembers = active_object.children

                # Find the created objects children of main and delete.
                createdObjFound = False

                createdObjects = []
                i = 0
                for member in cloudMembers:
                    applyScaleRotLoc(scene, member)

                    if (member["CloudMember"] == "CreatedObj"):
                        createdObjects.append(member)
                        del cloudMembers[i]

                    # @todo check if it wouldn't be better to remove this
                    # in the first place (see del() in degenerateCloud)
                    member["CloudMember"] = None
                    i += 1

                for createdObj in createdObjects:
                    # Deselect All
                    bpy.ops.object.select_all(action='DESELECT')

                    # Select the object and delete it.
                    createdObj.selected = True
                    scene.objects.active = createdObj
                    bpy.ops.object.delete()

                # Delete the main object
                # Deselect All
                bpy.ops.object.select_all(action='DESELECT')

                # Select the object and delete it.
                mainObj.selected = True
                scene.objects.active = mainObj

                # Delete all material slots in mainObj object
                for i in range(len(mainObj.material_slots)):
                    mainObj.active_material_index = i - 1
                    bpy.ops.object.material_slot_remove()

                # Delete the Main Object
                bpy.ops.object.delete()

                # Select all of the left over boxes so people can immediately
                # press generate again if they want.
                for eachMember in cloudMembers:
                    eachMember.max_draw_type = 'SOLID'
                    eachMember.selected = True
                    scene.objects.active = eachMember

            else:
                # Generate Cloud

                ###############Create Combined Object bounds##################
                # Make a list of all Selected objects.
                selectedObjects = bpy.context.selected_objects

                # Create a new object bounds
                if len(selectedObjects) == 0:
                    bounds = addNewObject(scene,
                        "CloudBounds",
                        [])

                else:
                    bounds = addNewObject(scene,
                        "CloudBounds",
                        selectedObjects[0])

                bounds.max_draw_type = 'BOUNDS'
                bounds.restrict_render = False

                # Just add a Definition Property designating this
                # as the main object.
                bounds["CloudMember"] = "MainObj"

                # Since we used iteration 0 to copy with object we
                # delete it off the list.
                firstObject = selectedObjects[0]
                del selectedObjects[0]

                # Apply location Rotation and Scale to all objects involved.
                applyScaleRotLoc(scene, bounds)
                for each in selectedObjects:
                    applyScaleRotLoc(scene, each)

                # Let's combine all of them together.
                combineObjects(scene, bounds, selectedObjects)

                # Let's add some property info to the objects.
                for selObj in selectedObjects:
                    selObj["CloudMember"] = "DefinitioinObj"
                    selObj.name = "DefinitioinObj"
                    selObj.max_draw_type = 'WIRE'
                    selObj.restrict_render = True
                    makeParent(bounds, selObj, scene)

                # Do the same to the 1. object since it is no longer in list.
                firstObject["CloudMember"] = "DefinitioinObj"
                firstObject.name = "DefinitioinObj"
                firstObject.max_draw_type = 'WIRE'
                firstObject.restrict_render = True
                makeParent(bounds, firstObject, scene)

                ###############Create Cloud for putting Cloud Mesh############
                # Create a new object cloud.
                cloud = addNewObject(scene, "CloudMesh", bounds)
                cloud["CloudMember"] = "CreatedObj"
                cloud.max_draw_type = 'WIRE'
                cloud.restrict_render = True

                makeParent(bounds, cloud, scene)

                bpy.ops.object.editmode_toggle()
                bpy.ops.mesh.select_all(action='SELECT')
                bpy.ops.mesh.subdivide(number_cuts=2, fractal=0, smoothness=1)
                bpy.ops.object.location_apply()
                bpy.ops.mesh.vertices_smooth(repeat=20)
                bpy.ops.mesh.tris_convert_to_quads()
                bpy.ops.mesh.faces_shade_smooth()
                bpy.ops.object.editmode_toggle()

                ###############Create Particles in cloud obj##################
                # Turn off gravity.
                scene.use_gravity = False

                # Set time to 0.
                scene.frame_current = 0

                # Add a new particle system.
                bpy.ops.object.particle_system_add()

                #Particle settings setting it up!
                cloudParticles = cloud.active_particle_system
                cloudParticles.name = "CloudParticles"
                cloudParticles.settings.start = 0
                cloudParticles.settings.end = 0
                cloudParticles.settings.emit_from = 'VOLUME'
                cloudParticles.settings.draw_as = 'DOT'
                cloudParticles.settings.ren_as = 'NONE'
                cloudParticles.settings.normal_factor = 0
                cloudParticles.settings.distribution = 'RAND'

                ####################Create Volume Material####################
                # Deselect All
                bpy.ops.object.select_all(action='DESELECT')

                # Select the object.
                bounds.selected = True
                scene.objects.active = bounds

                # Turn bounds object into a box.
                makeObjectIntoBoundBox(bounds, .2)

                # Delete all material slots in bounds object.
                for i in range(len(bounds.material_slots)):
                    bounds.active_material_index = i - 1
                    bpy.ops.object.material_slot_remove()

                # Add a new material.
                cloudMaterial = main.materials.new("CloudMaterial")
                bpy.ops.object.material_slot_add()
                bounds.material_slots[0].material = cloudMaterial

                # Set Up the Cloud Material
                cloudMaterial.name = "CloudMaterial"
                cloudMaterial.type = 'VOLUME'
                mVolume = cloudMaterial.volume
                mVolume.scattering = scattering
                mVolume.density = 0
                mVolume.density_scale = 1
                mVolume.transmission_color = [3, 3, 3]
                mVolume.step_size = 0.1
                mVolume.light_cache = True
                mVolume.cache_resolution = 75

                # Add a texture
                vMaterialTextureSlots = cloudMaterial.texture_slots
                cloudtex = main.textures.new("CloudTex")
                cloudMaterial.add_texture(cloudtex, 'ORCO')
                cloudtex.type = 'CLOUDS'
                cloudtex.noise_type = 'HARD_NOISE'
                cloudtex.noise_size = 2

                # Add a texture
                cloudPointDensity = main.textures.new("CloudPointDensity")
                cloudPointDensity.type = 'POINT_DENSITY'
                cloudMaterial.add_texture(cloudPointDensity, 'ORCO')
                pDensity = vMaterialTextureSlots[1].texture
                vMaterialTextureSlots[1].map_density = True
                vMaterialTextureSlots[1].rgb_to_intensity = True
                vMaterialTextureSlots[1].texture_coordinates = 'GLOBAL'
                pDensity.pointdensity.radius = pointDensityRadius
                pDensity.pointdensity.vertices_cache = 'WORLD_SPACE'
                pDensity.use_color_ramp = True
                pRamp = pDensity.color_ramp
                pRamp.interpolation = 'LINEAR'
                pRampElements = pRamp.elements
                #pRampElements[1].position = .9
                #pRampElements[1].color = [.18,.18,.18,.8]

                # Estimate the number of particles for the size of bounds.
                numParticles = int(bounds.dimensions[0] * bounds.dimensions[1]
                    * bounds.dimensions[2]) * numOfPoints
                if numParticles > maxNumOfPoints:
                    numParticles = maxNumOfPoints
                print(numParticles)

                # Set the number of particles according to the volume
                # of bounds.
                cloudParticles.settings.amount = numParticles

                # Set time to 1.
                scene.frame_current = 1

                ###############Create CloudPnts for putting points in#########
                # Create a new object cloudPnts
                cloudPnts = addNewObject(scene, "CloudPoints", bounds)
                cloudPnts["CloudMember"] = "CreatedObj"
                cloudPnts.max_draw_type = 'WIRE'
                cloudPnts.restrict_render = True

                makeParent(bounds, cloudPnts, scene)

                bpy.ops.object.editmode_toggle()
                bpy.ops.mesh.select_all(action='SELECT')

                bpy.ops.mesh.delete(type='ALL')

                meshPnts = cloudPnts.data

                listCloudParticles = cloudParticles.particles

                listMeshPnts = []
                for pTicle in listCloudParticles:
                    listMeshPnts.append(pTicle.location)

                # Must be in object mode fro from_pydata to work.
                bpy.ops.object.mode_set(mode='OBJECT')

                # Add in the mesh data.
                meshPnts.from_pydata(listMeshPnts, [], [])

                # Update the mesh.
                meshPnts.update()

                # Add a modifier.
                bpy.ops.object.modifier_add(type='DISPLACE')

                cldPntsModifiers = cloudPnts.modifiers
                cldPntsModifiers[0].name = "CloudPnts"
                cldPntsModifiers[0].texture = cloudtex
                cldPntsModifiers[0].texture_coordinates = 'OBJECT'
                cldPntsModifiers[0].texture_coordinate_object = cloud
                cldPntsModifiers[0].strength = -1.4

                # Apply modifier
                # Can't use bpy.ops.object.modifier_apply because poll fails.
                cloudPnts.data = cloudPnts.create_mesh(scene,
                    apply_modifiers=True,
                    settings='PREVIEW')
                cloudPnts.modifiers.remove(cldPntsModifiers[0])

                pDensity.pointdensity.point_source = 'OBJECT'
                pDensity.pointdensity.object = cloudPnts

                # Deselect All
                bpy.ops.object.select_all(action='DESELECT')

                # Select the object.
                cloud.selected = True
                scene.objects.active = cloud

                bpy.ops.object.particle_system_remove()

                # Deselect All
                bpy.ops.object.select_all(action='DESELECT')

                # Select the object.
                bounds.selected = True
                scene.objects.active = bounds

                # Add a force field to the points.
                #cloudField = bounds.field
                #cloudField.type = 'TEXTURE'
                #cloudField.strength = 2
                #cloudField.texture = cloudtex

                # Set time
                #for i in range(12):
                #    scene.current_frame = i
                #    scene.update()
                #bpy.ops.ptcache.bake_all(bake=False)

            #self.report({'WARNING'}, "Generating Cloud")

        return {'FINISHED'}

bpy.types.register(GenerateCloud)

if __name__ == "__main__":
    bpy.ops.cloud.generate_cloud()