diff --git a/object_cloud_gen.py b/object_cloud_gen.py
new file mode 100644
index 0000000000000000000000000000000000000000..3a245c3a513d011905d3791b6f187eed3f0c5997
--- /dev/null
+++ b/object_cloud_gen.py
@@ -0,0 +1,624 @@
+# ##### 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': '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()