# ##### 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 ##### import bpy from bpy.props import * import os import math import mathutils __bpydoc__ = """ Light Field Tools This script helps setting up rendering of lightfields. It also supports the projection of lightfields with textured spotlights. Usage: A simple interface can be accessed in the tool shelf panel in 3D View ([T] Key). A base mesh has to be provided, which will normaly be a subdivided plane. The script will then create a camera rig and a light rig with adjustable properties. A sample camera and a spotlight will be created on each vertex of the basemesh object axis (maybe vertex normal in future versions). Vertex order: The user has to provide the number of cameras or lights in one row in an unevenly spaced grid, the basemesh. Then the right vertex order can be computed as shown here. 6-7-8 | | | ^ 3-4-5 | | | | y 0-1-2 x-> There is also a tool to create a basemesh, which is an evenly spaced grid. The row length parameter is taken to construct such a NxN grid. Someone would start out by adding a rectengular plane as the slice plane of the frustrum of the most middle camera of the light field rig. The spacing parameter then places the other cameras in a way, so they have an offset of n pixels from the other camera on this plane. Version history: v0.3.0 - Make compatible with 2.64 v0.2.1 - Empty handler, multiple camera grid, r34843 v0.2.0 - To be included in contrib, r34456 v0.1.4 - To work with r34261 v0.1.3 - Fixed base mesh creation for r29998 v0.1.2 - Minor fixes, working with r29994 v0.1.1 - Basemesh from focal plane. v0.1.0 - API updates, draft done. v0.0.4 - Texturing. v0.0.3 - Creates an array of non textured spotlights. v0.0.2 - Renders lightfields. v0.0.1 - Initial version. TODO: * Restore view after primary camera is changed. * Apply object matrix to normals. * Allign to normals, somehow,.... * StringPropertie with PATH tag, for proper ui. """ class OBJECT_OT_create_lightfield_rig(bpy.types.Operator): """Create a lightfield rig based on the active object/mesh""" bl_idname="object.create_lightfield_rig" bl_label="Create a light field rig based on the active object/mesh" bl_options = {'REGISTER'} layer0 = [True] + [False]*19 numSamples = 0 baseObject = None handler = None verts = [] imagePaths = [] def arrangeVerts(self): """Sorts the vertices as described in the usage part of the doc.""" #FIXME get mesh with applied modifer stack scene = bpy.context.scene mesh = self.baseObject.data verts = [] row_length = scene.lightfield.row_length matrix = self.baseObject.matrix_local.copy() for vert in mesh.vertices: # world/parent origin # ???, normal and co are in different spaces, sure you want this? co = matrix * vert.co normal = vert.normal verts.append([co, normal]) def key_x(v): return v[0][0] def key_y(v): return v[0][1] verts.sort(key=key_y) sorted_verts = [] for i in range(0, len(verts), row_length): row = verts[i:i+row_length] row.sort(key=key_x) sorted_verts.extend(row) return sorted_verts def createCameraAnimated(self): scene = bpy.context.scene bpy.ops.object.camera_add(view_align=False) cam = bpy.context.active_object cam.name = "light_field_camera" # set props cam.data.angle = scene.lightfield.angle # display options of the camera cam.data.lens_unit = 'FOV' # handler parent if scene.lightfield.create_handler: cam.parent = self.handler # set as primary camera scene.camera = cam ### animate ### scene.frame_current = 0 for frame, vert in enumerate(self.verts): scene.frame_current = frame # translate cam.location = vert[0] # rotation cam.rotation_euler = self.baseObject.rotation_euler # insert LocRot keyframes cam.keyframe_insert('location') # set anim render props scene.frame_current = 0 scene.frame_start = 0 scene.frame_end = self.numSamples-1 def createCameraMultiple(self): scene = bpy.context.scene for cam_idx, vert in enumerate(self.verts): # add and name camera bpy.ops.object.camera_add(view_align=False) cam = bpy.context.active_object cam.name = "light_field_cam_" + str(cam_idx) # translate cam.location = vert[0] # rotation cam.rotation_euler = self.baseObject.rotation_euler # set camera props cam.data.angle = scene.lightfield.angle # display options of the camera cam.data.draw_size = 0.15 cam.data.lens_unit = 'FOV' # handler parent if scene.lightfield.create_handler: cam.parent = self.handler def createCamera(self): if bpy.context.scene.lightfield.animate_camera: self.createCameraAnimated() else: self.createCameraMultiple() def getImagePaths(self): path = bpy.context.scene.lightfield.texture_path if not os.path.isdir(path): return False files = os.listdir(path) if not len(files) == self.numSamples: return False files.sort() self.imagePaths = list(map(lambda f : os.path.join(path, f), files)) return True def createTexture(self, index): name = "light_field_spot_tex_" + str(index) tex = bpy.data.textures.new(name, type='IMAGE') # load and set the image #FIXME width, height. not necessary to set in the past. img = bpy.data.images.new("lfe_str_" + str(index), width=5, height=5) img.filepath = self.imagePaths[index] img.source = 'FILE' tex.image = img return tex def createSpot(self, index, textured=False): scene = bpy.context.scene bpy.ops.object.lamp_add( type='SPOT') spot = bpy.context.active_object # set object props spot.name = "light_field_spot_" + str(index) # set constants spot.data.use_square = True spot.data.shadow_method = "RAY_SHADOW" # FIXME spot.data.distance = 10 # set spot props spot.data.energy = scene.lightfield.light_intensity / self.numSamples spot.data.spot_size = scene.lightfield.angle spot.data.spot_blend = scene.lightfield.spot_blend # add texture if textured: spot.data.active_texture = self.createTexture(index) # texture mapping spot.data.texture_slots[0].texture_coords = 'VIEW' # handler parent if scene.lightfield.create_handler: spot.parent = self.handler return spot def createLightfieldEmitter(self, textured=False): for i, vert in enumerate(self.verts): spot = self.createSpot(i, textured) spot.location = vert[0] spot.rotation_euler = self.baseObject.rotation_euler def execute(self, context): scene = context.scene obj = self.baseObject = context.active_object if not obj or obj.type != 'MESH': self.report({'ERROR'}, "No selected mesh object!") return 'CANCELLED' self.verts = self.arrangeVerts() self.numSamples = len(self.verts) if scene.lightfield.create_handler: #create an empty bpy.ops.object.add(type='EMPTY') empty = bpy.context.active_object empty.location = self.baseObject.location empty.rotation_euler = self.baseObject.rotation_euler self.handler = empty if scene.lightfield.do_camera: self.createCamera() if scene.lightfield.do_projection: if self.getImagePaths(): self.createLightfieldEmitter(textured=True) else: self.createLightfieldEmitter(textured=False) return {'FINISHED'} class OBJECT_OT_create_lightfield_basemesh(bpy.types.Operator): """Creates a basemsh from the selected focal plane""" bl_idname="object.create_lightfield_basemesh" bl_label="Create a basemesh from the selected focal plane" bl_options = {'REGISTER'} objName = "lf_basemesh" def getWidth(self, obj): mat = obj.matrix_local mesh = obj.data v0 = mat * mesh.vertices[mesh.edges[0].vertices[0]].co v1 = mat * mesh.vertices[mesh.edges[0].vertices[1]].co return (v0-v1).length def getCamVec(self, obj, angle): width = self.getWidth(obj) itmat = obj.matrix_local.inverted().transposed() normal = itmat * obj.data.polygons[0].normal.normalized() vl = (width/2) * (1/math.tan(math.radians(angle/2))) return normal*vl def addMeshObj(self, mesh): scene = bpy.context.scene for o in scene.objects: o.select = False mesh.update() nobj = bpy.data.objects.new(self.objName, mesh) scene.objects.link(nobj) nobj.select = True if scene.objects.active is None or scene.objects.active.mode == 'OBJECT': scene.objects.active = nobj def execute(self, context): scene = context.scene obj = context.active_object # check if active object is a mesh object if not obj or obj.type != 'MESH': self.report({'ERROR'}, "No selected mesh object!") return 'CANCELLED' # check if it has one single face if len(obj.data.polygons) != 1: self.report({'ERROR'}, "The selected mesh object has to have exactly one quad!") return 'CANCELLED' rl = scene.lightfield.row_length # use a degree angle here angle = math.degrees(scene.lightfield.angle) spacing = scene.lightfield.spacing # resolution of final renderings res = round(scene.render.resolution_x * (scene.render.resolution_percentage/100.)) width = self.getWidth(obj) # the offset between n pixels on the focal plane fplane_offset = (width/res) * spacing # vertices for the basemesh verts = [] # the offset vector vec = self.getCamVec(obj, angle) # lower left coordinates of the grid sx = obj.location[0] - fplane_offset * int(rl/2) sy = obj.location[1] - fplane_offset * int(rl/2) z = obj.location[2] # position on the focal plane fplane_pos = mathutils.Vector() for x in [sx + fplane_offset*i for i in range(rl)]: for y in [sy + fplane_offset*i for i in range(rl)]: fplane_pos.x = x fplane_pos.y = y fplane_pos.z = z # position of a vertex in a basemesh pos = fplane_pos + vec # pack coordinates flat into the vert list verts.append( (pos.x, pos.y, pos.z) ) # setup the basemesh and add verts mesh = bpy.data.meshes.new(self.objName) mesh.from_pydata(verts, [], []) self.addMeshObj(mesh) return {'FINISHED'} class VIEW3D_OT_lightfield_tools(bpy.types.Panel): bl_space_type = "VIEW_3D" bl_region_type = "TOOLS" bl_context = "objectmode" bl_label = "Light Field Tools" def draw(self, context): layout = self.layout scene = context.scene col = layout.column() col.prop(scene.lightfield, "row_length") col.prop(scene.lightfield, "angle") col.prop(scene.lightfield, "create_handler") col.prop(scene.lightfield, "do_camera") col.prop(scene.lightfield, "animate_camera") col.prop(scene.lightfield, "do_projection") col = layout.column(align=True) col.enabled = scene.lightfield.do_projection col.prop(scene.lightfield, "texture_path") col.prop(scene.lightfield, "light_intensity") col.prop(scene.lightfield, "spot_blend") # create a basemesh col = layout.column(align=True) col.operator("object.create_lightfield_basemesh", "Create Base Grid") col.prop(scene.lightfield, "spacing") layout.operator("object.create_lightfield_rig", "Create Rig")