# Define the fragment shader for the 180-270 degree equirectangular conversion

"EQUI_L": '''

#define PI 3.1415926535897932384626

// Input cubemap textures

uniform sampler2D cubeLeftImage;

uniform sampler2D cubeRightImage;

uniform sampler2D cubeBottomImage;

uniform sampler2D cubeTopImage;

uniform sampler2D cubeFrontImage;

in vec2 vTexCoord;

out vec4 fragColor;

void main() {{

// Calculate the pointing angle

float fovd = {0};

float fovfrac = fovd/360.0;

float sidefrac = (fovd-90.0)/180;

float azimuth = vTexCoord.x * PI * fovfrac;

float elevation = vTexCoord.y * PI / 2.0;

// Calculate the pointing vector

vec3 pt;

pt.x = cos(elevation) * sin(azimuth);

pt.y = sin(elevation);

pt.z = cos(elevation) * cos(azimuth);

// Select the correct pixel

if ((abs(pt.x) >= abs(pt.y)) && (abs(pt.x) >= abs(pt.z))) {{

if (pt.x <= 0.0) {{

fragColor = texture(cubeLeftImage, vec2((((-pt.z/pt.x))+(2.0*sidefrac-1.0))/(2.0*sidefrac),((-pt.y/pt.x)+1.0)/2.0));

}} else {{

fragColor = texture(cubeRightImage, vec2(((-pt.z/pt.x)+1.0)/(2.0*sidefrac),((pt.y/pt.x)+1.0)/2.0));

}}

}} else if (abs(pt.y) >= abs(pt.z)) {{

if (pt.y <= 0.0) {{

fragColor = texture(cubeBottomImage, vec2(((-pt.x/pt.y)+1.0)/2.0,((-pt.z/pt.y)+(2.0*sidefrac-1.0))/(2.0*sidefrac)));

}} else {{

fragColor = texture(cubeTopImage, vec2(((pt.x/pt.y)+1.0)/2.0,((-pt.z/pt.y)+1.0)/(2.0*sidefrac)));

}}

}} else {{

fragColor = texture(cubeFrontImage, vec2(((pt.x/pt.z)+1.0)/2.0,((pt.y/pt.z)+1.0)/2.0));

}}

}}

''',

# Define the fragment shader for the 270-360 degree equirectangular conversion

"EQUI_H":'''

#define PI 3.1415926535897932384626

// Input cubemap textures

uniform sampler2D cubeLeftImage;

uniform sampler2D cubeRightImage;

uniform sampler2D cubeBottomImage;

uniform sampler2D cubeTopImage;

uniform sampler2D cubeBackImage;

uniform sampler2D cubeFrontImage;

in vec2 vTexCoord;

out vec4 fragColor;

void main() {{

// Calculate the pointing angle

float azimuth = vTexCoord.x * PI * ({0}/360.0);

float elevation = vTexCoord.y * PI / 2.0;

// Calculate the pointing vector

vec3 pt;

pt.x = cos(elevation) * sin(azimuth);

pt.y = sin(elevation);

pt.z = cos(elevation) * cos(azimuth);

// Select the correct pixel

if ((abs(pt.x) >= abs(pt.y)) && (abs(pt.x) >= abs(pt.z))) {{

if (pt.x <= 0.0) {{

fragColor = texture(cubeLeftImage, vec2(((-pt.z/pt.x)+1.0)/2.0,((-pt.y/pt.x)+1.0)/2.0));

}} else {{

fragColor = texture(cubeRightImage, vec2(((-pt.z/pt.x)+1.0)/2.0,((pt.y/pt.x)+1.0)/2.0));

}}

}} else if (abs(pt.y) >= abs(pt.z)) {{

if (pt.y <= 0.0) {{

fragColor = texture(cubeBottomImage, vec2(((-pt.x/pt.y)+1.0)/2.0,((-pt.z/pt.y)+1.0)/2.0));

}} else {{

fragColor = texture(cubeTopImage, vec2(((pt.x/pt.y)+1.0)/2.0,((-pt.z/pt.y)+1.0)/2.0));

}}

}} else {{

if (pt.z <= 0.0) {{

fragColor = texture(cubeBackImage, vec2(((pt.x/pt.z)+1.0)/2.0,((-pt.y/pt.z)+1.0)/2.0));

}} else {{

fragColor = texture(cubeFrontImage, vec2(((pt.x/pt.z)+1.0)/2.0,((pt.y/pt.z)+1.0)/2.0));

}}

}}

}}

''',

# Define the fragment shader for the 180-270 degree dome conversion

"DOME_L": '''

#define PI 3.1415926535897932384626

// Input cubemap textures

uniform sampler2D cubeLeftImage;

uniform sampler2D cubeRightImage;

uniform sampler2D cubeBottomImage;

uniform sampler2D cubeTopImage;

uniform sampler2D cubeFrontImage;

in vec2 vTexCoord;

out vec4 fragColor;

void main() {{

float fovd = {0};

float fovfrac = fovd/360.0;

float sidefrac = (fovd-90.0)/180;

vec2 d = vTexCoord.xy;

float r = length(d);

if( r > 1.0 ) {{

fragColor = vec4(0.0, 0.0, 0.0, 1.0);

return;

}}

vec2 dunit = normalize(d);

float phi = fovfrac*r*PI;

vec3 pt;

pt.x = dunit.x*sin(phi);

pt.y = dunit.y*sin(phi);

pt.z = cos(phi);

// Select the correct pixel

if ((abs(pt.x) >= abs(pt.y)) && (abs(pt.x) >= abs(pt.z))) {{

if (pt.x <= 0.0) {{

fragColor = texture(cubeLeftImage, vec2((((-pt.z/pt.x))+(2.0*sidefrac-1.0))/(2.0*sidefrac),((-pt.y/pt.x)+1.0)/2.0));

}} else {{

fragColor = texture(cubeRightImage, vec2(((-pt.z/pt.x)+1.0)/(2.0*sidefrac),((pt.y/pt.x)+1.0)/2.0));

}}

}} else if (abs(pt.y) >= abs(pt.z)) {{

if (pt.y <= 0.0) {{

fragColor = texture(cubeBottomImage, vec2(((-pt.x/pt.y)+1.0)/2.0,((-pt.z/pt.y)+(2.0*sidefrac-1.0))/(2.0*sidefrac)));

}} else {{

fragColor = texture(cubeTopImage, vec2(((pt.x/pt.y)+1.0)/2.0,((-pt.z/pt.y)+1.0)/(2.0*sidefrac)));

}}

}} else {{

fragColor = texture(cubeFrontImage, vec2(((pt.x/pt.z)+1.0)/2.0,((pt.y/pt.z)+1.0)/2.0));

}}

}}

''',

# Define the fragment shader for the 270-360 degree dome conversion

"DOME_H":'''

#define PI 3.1415926535897932384626

// Input cubemap textures

uniform sampler2D cubeLeftImage;

uniform sampler2D cubeRightImage;

uniform sampler2D cubeBottomImage;

uniform sampler2D cubeTopImage;

uniform sampler2D cubeFrontImage;

uniform sampler2D cubeBackImage;

in vec2 vTexCoord;

out vec4 fragColor;

void main() {{

float fovfrac = {0}/360.0;

vec2 d = vTexCoord.xy;

float r = length(d);

if( r > 1.0 ) {{

fragColor = vec4(0.0, 0.0, 0.0, 1.0);

return;

}}

vec2 dunit = normalize(d);

float phi = fovfrac*r*PI;

vec3 pt;

pt.x = dunit.x*sin(phi);

pt.y = dunit.y*sin(phi);

pt.z = cos(phi);

// Select the correct pixel

if ((abs(pt.x) >= abs(pt.y)) && (abs(pt.x) >= abs(pt.z))) {{

if (pt.x <= 0.0) {{

fragColor = texture(cubeLeftImage, vec2(((-pt.z/pt.x)+1.0)/2.0,((-pt.y/pt.x)+1.0)/2.0));

}} else {{

fragColor = texture(cubeRightImage, vec2(((-pt.z/pt.x)+1.0)/2.0,((pt.y/pt.x)+1.0)/2.0));

}}

}} else if (abs(pt.y) >= abs(pt.z)) {{

if (pt.y <= 0.0) {{

fragColor = texture(cubeBottomImage, vec2(((-pt.x/pt.y)+1.0)/2.0,((-pt.z/pt.y)+1.0)/2.0));

}} else {{

fragColor = texture(cubeTopImage, vec2(((pt.x/pt.y)+1.0)/2.0,((-pt.z/pt.y)+1.0)/2.0));

}}

}} else {{

if (pt.z <= 0.0) {{

fragColor = texture(cubeBackImage, vec2(((pt.x/pt.z)+1.0)/2.0,((-pt.y/pt.z)+1.0)/2.0));

}} else {{

fragColor = texture(cubeFrontImage, vec2(((pt.x/pt.z)+1.0)/2.0,((pt.y/pt.z)+1.0)/2.0));

}}

}}

}}

'''

def __init__(self, is_stereo = False, is_animation = False, mode = 'EQUI', FOV = 180):

# Check if the file is saved or not, can cause errors when not saved

if not bpy.data.is_saved:

raise PermissionError("Save file before rendering")

# Set internal variables for the class

self.scene = bpy.context.scene

self.camera = self.scene.camera

self.path = bpy.path.abspath("//")

self.is_stereo = is_stereo

self.is_animation = is_animation

self.FOV = FOV

self.no_back_image = (self.FOV <= 270)

self.no_side_images = (self.FOV <= 90) # TODO - Not implemented yet, probably not needed

self.is_dome = (mode == 'DOME')

self.createdFiles = set()

# Select the correct shader

if self.is_dome:

if self.no_back_image:

self.frag_shader = frag_shaders["DOME_L"]

else:

self.frag_shader = frag_shaders["DOME_H"]

else:

if self.no_back_image:

self.frag_shader = frag_shaders["EQUI_L"]

else:

self.frag_shader = frag_shaders["EQUI_H"]

# Insert the FOV into the shader

self.frag_shader = self.frag_shader.format(self.FOV)

# Set the image/folder name to the current time

self.start_time = datetime.now().strftime('%Y-%m-%d-%H-%M-%S')

self.folder_name = "Render Result {}/".format(self.start_time)

# Get initial camera and output information

self.camera_rotation = list(self.camera.rotation_euler)

self.IPD = self.camera.data.stereo.interocular_distance

self.camera_type = self.camera.data.type

self.camera_angle = self.camera.data.angle

self.stereo_type = self.camera.data.stereo.convergence_mode

self.stereo_pivot = self.camera.data.stereo.pivot

# Create an empty to be used to control the camera

try:

self.camera_empty = bpy.data.objects['eeVR_CAMERA_EMPTY']

except KeyError:

self.camera_empty = bpy.data.objects.new('eeVR_CAMERA_EMPTY', None)

# Create a copy transforms constraint for the camera

self.trans_constraint = self.camera.constraints.new('COPY_TRANSFORMS')

#self.camera.rotation_euler

# Set camera variables for proper result

self.camera.data.type = 'PANO'

self.camera.data.stereo.convergence_mode = 'PARALLEL'

self.camera.data.stereo.pivot = 'CENTER'

self.camera.data.angle = pi/2

self.image_size = [self.scene.render.resolution_x,\

self.scene.render.resolution_y]

self.side_resolution = int(max(self.image_size)+4-max(self.image_size)%4)/2 if max(self.image_size)%4 > 0\

else int(max(self.image_size)/2)

if self.is_stereo:

self.view_format = self.scene.render.image_settings.views_format

self.scene.render.image_settings.views_format = 'STEREO_3D'

self.stereo_mode = self.scene.render.image_settings.stereo_3d_format.display_mode

self.scene.render.image_settings.stereo_3d_format.display_mode = 'TOPBOTTOM'

self.direction_offsets = self.find_direction_offsets()

if self.no_back_image:

fract = (self.FOV-90)/180

self.camera_shift = {'top':[0.0, 0.5*(fract-1), self.side_resolution, fract*self.side_resolution],\

'bottom':[0.0, 0.5*(1-fract), self.side_resolution, fract*self.side_resolution],\

'left':[0.5*(1-fract), 0.0, fract*self.side_resolution, self.side_resolution],\

'right':[0.5*(fract-1), 0.0, fract*self.side_resolution, self.side_resolution],\

'front':[0.0, 0.0, self.side_resolution, self.side_resolution]}

def cubemap_to_equirectangular(self, imageList, outputName):

# Define the vertex shader

vertex_shader = '''

in vec3 aVertexPosition;

in vec2 aVertexTextureCoord;

out vec2 vTexCoord;

void main() {

vTexCoord = aVertexTextureCoord;

gl_Position = vec4(aVertexPosition, 1);

}

'''

# Generate the OpenGL shader

pos = [(-1.0, -1.0, -1.0), # left, bottom, back

(-1.0, 1.0, -1.0), # left, top, back

(1.0, -1.0, -1.0), # right, bottom, back

(1.0, 1.0, -1.0)] # right, top, back

coords = [(-1.0, -1.0), # left, bottom

(-1.0, 1.0), # left, top

(1.0, -1.0), # right, bottom

(1.0, 1.0)] # right, top

vertexIndices = [(0, 3, 1),(3, 0, 2)]

shader = gpu.types.GPUShader(vertex_shader, self.frag_shader)

batch = batch_for_shader(shader, 'TRIS', {"aVertexPosition": pos,\

"aVertexTextureCoord": coords},\

indices=vertexIndices)

# Change the color space of all of the images to Linear

# and load them into OpenGL textures

for image in imageList:

image.colorspace_settings.name='Linear'

image.gl_load()

# set the size of the final image

width = self.image_size[0]

height = self.image_size[1]

# Create an offscreen render buffer and texture

offscreen = gpu.types.GPUOffScreen(width, height)

with offscreen.bind():

bgl.glClear(bgl.GL_COLOR_BUFFER_BIT)

shader.bind()

def bind_and_filter(tex, bindcode, image=None, imageNum=None):

bgl.glActiveTexture(tex)

bgl.glBindTexture(bgl.GL_TEXTURE_2D, bindcode)

bgl.glTexParameterf(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MIN_FILTER, bgl.GL_LINEAR)

bgl.glTexParameterf(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MAG_FILTER, bgl.GL_LINEAR)

bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_WRAP_S, bgl.GL_CLAMP_TO_EDGE)

bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_WRAP_T, bgl.GL_CLAMP_TO_EDGE)

if image!=None and imageNum!=None:

shader.uniform_int(image, imageNum)

# Bind all of the cubemap textures and enable correct filtering and wrapping

# to prevent seams

bind_and_filter(bgl.GL_TEXTURE0, imageList[0].bindcode, "cubeLeftImage", 0)

bind_and_filter(bgl.GL_TEXTURE1, imageList[1].bindcode, "cubeRightImage", 1)

bind_and_filter(bgl.GL_TEXTURE2, imageList[2].bindcode, "cubeBottomImage", 2)

bind_and_filter(bgl.GL_TEXTURE3, imageList[3].bindcode, "cubeTopImage", 3)

bind_and_filter(bgl.GL_TEXTURE4, imageList[4].bindcode, "cubeFrontImage", 4)

if not self.no_back_image:

bind_and_filter(bgl.GL_TEXTURE5, imageList[5].bindcode, "cubeBackImage", 5)

# Bind the resulting texture

bind_and_filter(bgl.GL_TEXTURE6, offscreen.color_texture)

# Render the image

batch.draw(shader)

# Unload the textures

for image in imageList:

image.gl_free()

# Read the resulting pixels into a buffer

buffer = bgl.Buffer(bgl.GL_FLOAT, width * height * 4)

bgl.glGetTexImage(bgl.GL_TEXTURE_2D, 0, bgl.GL_RGBA, bgl.GL_FLOAT, buffer);

# Unload the offscreen texture

offscreen.free()

# Remove the cubemap textures:

for image in imageList:

bpy.data.images.remove(image)

# Copy the pixels from the buffer to an image object

if not outputName in bpy.data.images.keys():

bpy.data.images.new(outputName, width, height)

imageRes = bpy.data.images[outputName]

imageRes.scale(width, height)

imageRes.pixels = buffer

return imageRes

def find_direction_offsets(self):

# Calculate the pointing directions of the camera for each face of the cube

# Using euler.rotate_axis() to handle, notice that rotation should be done on copies

eul = self.camera.rotation_euler.copy()

direction_offsets = {}

#front

direction_offsets['front'] = list(eul)

#back

eul.rotate_axis('Y', pi)

direction_offsets['back'] = list(eul)

#top

eul = self.camera.rotation_euler.copy()

eul.rotate_axis('X', pi/2)

direction_offsets['top'] = list(eul)

#bottom

eul.rotate_axis('X', pi)

direction_offsets['bottom'] = list(eul)

#left

eul = self.camera.rotation_euler.copy()

eul.rotate_axis('Y', pi/2)

direction_offsets['left'] = list(eul)

#right

eul.rotate_axis('Y', pi)

direction_offsets['right'] = list(eul)

return direction_offsets

def set_camera_direction(self, direction):

# Set the camera to the required postion

self.camera_empty.rotation_euler = self.direction_offsets[direction]

if self.no_back_image:

self.camera.data.shift_x = self.camera_shift[direction][0]

self.camera.data.shift_y = self.camera_shift[direction][1]

self.scene.render.resolution_x = self.camera_shift[direction][2]

self.scene.render.resolution_y = self.camera_shift[direction][3]

def clean_up(self):

# Reset all the variables that were changed

self.camera.constraints.remove(self.trans_constraint)

self.camera.data.type = self.camera_type

self.camera.data.stereo.convergence_mode = self.stereo_type

self.camera.data.stereo.pivot = self.stereo_pivot

self.camera.data.angle = self.camera_angle

self.camera.rotation_euler = self.camera_rotation

self.camera.data.shift_x = 0

self.camera.data.shift_y = 0

self.scene.render.resolution_x = self.image_size[0]

self.scene.render.resolution_y = self.image_size[1]

if self.is_stereo:

self.scene.render.image_settings.views_format = self.view_format

self.scene.render.image_settings.stereo_3d_format.display_mode = self.stereo_mode

for filename in self.createdFiles:

os.remove(filename)

def render_image(self, direction):

# Render the image and load it into the script

tmp = self.scene.render.filepath

self.scene.render.filepath = self.path + 'temp_img_store_'+direction+'.png'

# If rendering for VR, render the side images separately to avoid seams

if self.is_stereo and direction in {'right', 'left'}:

imageL = 'temp_img_store_'+direction+'_L.png'

imageR = 'temp_img_store_'+direction+'_R.png'

if imageL in bpy.data.images:

bpy.data.images.remove(bpy.data.images[imageL])

if imageR in bpy.data.images:

bpy.data.images.remove(bpy.data.images[imageR])

self.scene.render.use_multiview = False

tmp_loc = list(self.camera_empty.location)

camera_angle = self.direction_offsets['front'][2]

self.camera_empty.location = [tmp_loc[0]+(0.5*self.IPD*cos(camera_angle)),\

tmp_loc[1]+(0.5*self.IPD*sin(camera_angle)),\

tmp_loc[2]]

self.scene.render.filepath = self.path + imageL

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

renderedImageL = bpy.data.images.load(self.path + imageL)

self.camera_empty.location = [tmp_loc[0]-(0.5*self.IPD*cos(camera_angle)),\

tmp_loc[1]-(0.5*self.IPD*sin(camera_angle)),\

tmp_loc[2]]

self.scene.render.filepath = self.path + imageR

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

renderedImageR = bpy.data.images.load(self.path + imageR)

self.scene.render.use_multiview = True

self.createdFiles.update({self.path+imageR, self.path+imageL})

self.camera_empty.location = tmp_loc

elif self.is_stereo:

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

image_name = 'temp_img_store_'+direction+'.png'

imageL = 'temp_img_store_'+direction+'_L.png'

imageR = 'temp_img_store_'+direction+'_R.png'

if image_name in bpy.data.images:

bpy.data.images.remove(bpy.data.images[image_name])

if imageL in bpy.data.images:

bpy.data.images.remove(bpy.data.images[imageL])

if imageR in bpy.data.images:

bpy.data.images.remove(bpy.data.images[imageR])

renderedImage = bpy.data.images.load(self.path + image_name)

renderedImage.colorspace_settings.name='Linear'

imageLen = len(renderedImage.pixels)

if self.no_back_image and direction in {'top', 'bottom'}:

renderedImageL = bpy.data.images.new(imageL, self.side_resolution,\

int(self.side_resolution/2))

renderedImageR = bpy.data.images.new(imageR, self.side_resolution,\

int(self.side_resolution/2))

else:

renderedImageL = bpy.data.images.new(imageL, self.side_resolution, self.side_resolution)

renderedImageR = bpy.data.images.new(imageR, self.side_resolution, self.side_resolution)

# Split the render into two images

if direction == 'back':

renderedImageL.pixels = renderedImage.pixels[int(imageLen/2):]

renderedImageR.pixels = renderedImage.pixels[0:int(imageLen/2)]

else:

renderedImageR.pixels = renderedImage.pixels[int(imageLen/2):]

renderedImageL.pixels = renderedImage.pixels[0:int(imageLen/2)]

renderedImageL.pack()

renderedImageR.pack()

bpy.data.images.remove(renderedImage)

self.createdFiles.add(self.path + 'temp_img_store_'+direction+'.png')

else:

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

image_name = 'temp_img_store_'+direction+'.png'

if image_name in bpy.data.images:

bpy.data.images.remove(bpy.data.images[image_name])

renderedImageL = bpy.data.images.load(self.path + image_name)

renderedImageR = None

self.createdFiles.add(self.path + 'temp_img_store_'+direction+'.png')

self.scene.render.filepath = tmp

return renderedImageL, renderedImageR

def render_images(self):

# Render the images for every direction

directions = ['left', 'right', 'bottom', 'top', 'front', 'back']

image_list_1 = []

image_list_2 = []

self.direction_offsets = self.find_direction_offsets()

self.camera_empty.location = self.camera.location

self.camera_empty.rotation_euler = self.camera.rotation_euler

self.trans_constraint.target = self.camera_empty

for direction in directions:

if direction == 'back' and self.no_back_image:

continue

else:

self.set_camera_direction(direction)

img1, img2 = self.render_image(direction)

image_list_1.append(img1)

image_list_2.append(img2)

self.set_camera_direction('front')

self.trans_constraint.target = None

return image_list_1, image_list_2

def render_and_save(self):

# Set the render resolution dimensions to the maximum of the two input dimensions

self.scene.render.resolution_x = self.side_resolution

self.scene.render.resolution_y = self.side_resolution

self.camera.data.shift_x = 0

self.camera.data.shift_y = 0

frame_step = self.scene.frame_step

# Render the images and return their names

imageList, imageList2 = self.render_images()

if self.is_animation:

image_name = "frame{:06d}.png".format(self.scene.frame_current)

else:

image_name = "Render Result {}.png".format(self.start_time)

# Convert the rendered images to equirectangular projection image and save it to the disk

if self.is_stereo:

imageResult1 = self.cubemap_to_equirectangular(imageList, "Render Left")

imageResult2 = self.cubemap_to_equirectangular(imageList2, "Render Right")

# If it doesn't already exist, create an image object to store the resulting render

if not image_name in bpy.data.images.keys():

imageResult = bpy.data.images.new(image_name, imageResult1.size[0],\

2*imageResult1.size[1])

imageResult = bpy.data.images[image_name]

if self.stereo_mode == 'SIDEBYSIDE':

imageResult.scale(2*imageResult1.size[0], imageResult1.size[1])

img2arr = np.reshape(np.array(imageResult2.pixels),(imageResult2.size[1], 4*imageResult2.size[0]))

img1arr = np.reshape(np.array(imageResult1.pixels),(imageResult1.size[1], 4*imageResult1.size[0]))

imageResult.pixels = list(np.concatenate((img2arr, img1arr),axis=1).flatten())

else:

imageResult.scale(imageResult1.size[0], 2*imageResult1.size[1])

imageResult.pixels = list(imageResult2.pixels) + list(imageResult1.pixels)

bpy.data.images.remove(imageResult1)

bpy.data.images.remove(imageResult2)

else:

imageResult = self.cubemap_to_equirectangular(imageList, "RenderResult")

if self.is_animation:

imageResult.save_render(self.path+self.folder_name+image_name)

self.scene.frame_set(self.scene.frame_current+frame_step)

else:

imageResult.save_render(self.path+image_name)

"""Render out the animation"""

bl_idname = 'wl.render_cancel'

bl_label = "Cancel the render"

def execute(self, context):

context.scene.cancelVRRenderer = True

"""Render out the animation"""

bl_idname = 'wl.render_image'

bl_label = "Render a single frame"

def execute(self, context):

print("VRRenderer: execute")

mode = bpy.context.scene.renderModeEnum

FOV = bpy.context.scene.renderFOV

renderer = VRRenderer(bpy.context.scene.render.use_multiview, False, mode, FOV)

renderer.render_and_save()

renderer.clean_up()

"""Render out the animation"""

bl_idname = 'wl.render_animation'

bl_label = "Render the animation"

def __del__(self):

print("VRRenderer: end")

def modal(self, context, event):

if event.type in {'ESC'}:

self.cancel(context)

return {'CANCELLED'}

if event.type == 'TIMER':

wm = context.window_manager

wm.event_timer_remove(self._timer)

if context.scene.cancelVRRenderer:

self.cancel(context)

return {'CANCELLED'}

if bpy.context.scene.frame_current <= self.frame_end:

print("VRRenderer: Rendering frame {}".format(bpy.context.scene.frame_current))

self._renderer.render_and_save()

self._timer = wm.event_timer_add(0.1, window=context.window)

else:

self.clean(context)

return {'FINISHED'}

return {'PASS_THROUGH'}

def execute(self, context):

print("VRRenderer: execute")

context.scene.cancelVRRenderer = False

mode = bpy.context.scene.renderModeEnum

FOV = bpy.context.scene.renderFOV

self._renderer = VRRenderer(bpy.context.scene.render.use_multiview, True, mode, FOV)

self.frame_end = bpy.context.scene.frame_end

frame_start = bpy.context.scene.frame_start

bpy.context.scene.frame_set(frame_start)

wm = context.window_manager

self._timer = wm.event_timer_add(5, window=context.window)

wm.modal_handler_add(self)

return {'RUNNING_MODAL'}

def cancel(self, context):

print("VRRenderer: cancel")

self.clean(context)

def clean(self, context):

self._renderer.clean_up()

"""Tools panel for VR rendering"""

bl_idname = "RENDER_TOOLS_PT_eevr_panel"

bl_label = "Render Tools"

bl_category = "eeVR"

bl_space_type = 'VIEW_3D'

bl_region_type = 'UI'

def draw(self, context):

# Draw the buttons for each of the rendering operators

layout = self.layout

col = layout.column()

col.prop(context.scene, 'renderModeEnum')

col.prop(context.scene, 'renderFOV')

col.operator("wl.render_image", text="Render Image")

col.operator("wl.render_animation", text="Render Animation")

if not context.scene.cancelVRRenderer:

col.operator("wl.render_cancel", text="Cancel")

bpy.types.Scene.renderModeEnum = bpy.props.EnumProperty(

items = [('EQUI', 'Equirectangular', 'Renders in equirectangular projection'),

('DOME', 'Full Dome', 'Renders in full dome projection')],

default='EQUI',

name="Mode")

bpy.types.Scene.renderFOV = bpy.props.FloatProperty(180.0,default=180.0, name="FOV", min=180, max=360,

description="Field of view in degrees")

bpy.types.Scene.cancelVRRenderer = bpy.props.BoolProperty(name="Cancel", default=True)

bpy.utils.register_class(RenderImage)

bpy.utils.register_class(RenderAnimation)

bpy.utils.register_class(RenderToolsPanel)

del bpy.types.Scene.renderModeEnum

del bpy.types.Scene.renderFOV

bpy.utils.unregister_class(RenderImage)

bpy.utils.unregister_class(RenderAnimation)

bpy.utils.unregister_class(RenderToolsPanel)

"name": "eeVR",

"description": "Render in different projections using Eevee engine",

"author": "EternalTrail",

"version": (0, 1),

"blender": (2, 82, 7),

"location": "View3D > UI",

"warning": "This addon is still in early alpha, may break your blend file!",

"wiki_url": "https://github.com/EternalTrail/eeVR",

"tracker_url": "https://github.com/EternalTrail/eeVR/issues",

"support": "TESTING",

"category": "Render",