# PyEPL: vr/__init__.py
#
# Copyright (C) 2003-2005 Michael J. Kahana
# Authors: Ian Schleifer, Per Sederberg, Aaron Geller, Josh Jacobs
# URL: http://memory.psych.upenn.edu/programming/pyepl
#
# Distributed under the terms of the GNU Lesser General Public License
# (LGPL). See the license.txt that came with this file.

"""
This package provides the virtual reality features of PyEPL.
"""

import pyepl.hardware.vr
import pyepl.display
from pyepl.display import ActiveShowable
from pyepl.textlog import LogTrack
import pyepl.mechinput
import weakref
import randomposition
import geometry

class NoSkyboxImageError(Exception):
    pass

class VEye(ActiveShowable):
    """
    A VEye represents a virtual camera.  It can be controlled
    independently, or attached to an avatar.
    """
    def __init__(self, eye, name, track, avatar = None):
        """
        Construct a VEye object from a LowVEye (low-level
        implementation), a name, a VRTrack, and possibily an avatar to
        which the eye is attached.
        """
        ActiveShowable.__init__(self)
        self.eye = eye
        self.name = name
        self.track = track
        self.avatar = avatar
        if avatar:
            self.lookat = None
        else:
            self.lookat = (self.name, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
    def reposition(self, x, y, z, yaw, pitch, roll):
        """
        Position the camera.
        """
        self.eye.reposition(x, y, z, yaw, pitch, roll)
        self.lookat = (self.name, pos[0], pos[1], pos[2], target[0], target[1], target[2], up[0], up[1], up[2], None)
    def setFOV(self, fov):
        """
        Set the field of view, in radians, without moving the camera.
        """
        self.eye.setFOV(fov)
        self.lookat = (self.name, 0, 0, 0, 0, 0, 0, 0, 0, 0, fov)
    def show(self, x, y):
        """
        Render the scene to the screen.
        """
        if self.avatar:
            self.avatar.drawNotify(self)
        self.eye.draw(x, y)
        if self.lookat:
            self.track.eyeLookAtLog(*self.lookat)
            self.lookat = None
    def getSize(self):
        """
        """
        return self.eye.getSize()
    def logLine(self):
        """
        Uniquely represent this object for the display log.
        """
        return "VEYE\t%s\t%d\t%d" % ((self.name,) + self.eye.getSize())

class VAvatar:
    """
    A VAvatar object represents a user's position, orientation, and
    body shape in the virtual environment.
    """
    def __init__(self, avatar, name, track):
        """
        Construct a VAvatar from a LowVAvatar (low-level
        implementation), a name, and a VRTrack.
        """
        self.avatar = avatar
        self.name = name
        self.track = track
        self.eyes = []
        self.controls = {}
    def newEye(self, name, xsize = None, ysize = None):
        """
        Create a VEye attached to this avatar with the dimensions
        provided.
        """
        if xsize == None or ysize == None:
            xsize, ysize = self.track.videotrack.getResolution()
        eye = VEye(pyepl.hardware.vr.LowVEye(self.track.env, xsize, ysize), name, self.track, self)
        self.avatar.attachEye(eye.eye)
        self.track.eyeAttachLog(name, self.name)
        self.eyes.append(weakref.ref(eye, self.expireEye))
        return eye
    def expireEye(self, eyeref):
        """
        This fuction is used for housekeeping when an attached eye is
        destroyed.
        """
        if eyeref():
            self.avatar.dettachEye(eyeref().eye)  # will this ever happen? :-(
            self.eyes.remove(eyeref)
    def drawNotify(self, eye):
        """
        When one of our attached eyes is about to render itself to the
        screen, we want to know so that we can make sure that the
        camera positions are up-to-date.
        """
        if eye == self.eyes[0]():
            self.avatar.travel(**dict(map(lambda item: (item[0], item[1].getPosition()), self.controls.iteritems())))
            self.track.avatarMoveLog(self.name, *self.avatar.positionOrientation())
    def positionOrientation(self):
        """
        """
        return self.avatar.positionOrientation()
    def setControls(self, **controls):
        """
        Set mechanical input abstraction objects to control this
        avatar's movement.
        """
        self.controls = controls

class VRTrack(LogTrack):
    """
    This class is the starting point for access to all VR features.
    It can keep a log of all VR activity.
    """
    logExtension = ".vrlog"
    def __init__(self, basename, archive = None, autoStart = True):
        """
        Create the VRTrack.
        """
        self.env = None
        LogTrack.__init__(self, basename, archive, autoStart)
        self.archive = archive
        self.logqueue = []
    def startService(self):
        self.videotrack = pyepl.display.VideoTrack.lastInstance()
        self.cb = self.markScreenUpdate
        self.videotrack.addUpdateCallback(self.cb)
        self.env = pyepl.hardware.vr.LowVEnvironment()
    def stopService(self):
        try:
            self.videotrack.removeUpdateCallback(self.cb)
        except AttributeError:
            pass
        self.env = None
    def resetEnvironment(self):
        """
        """
        self.logMessage("RESET")
	self.env.__del__()
        self.env = pyepl.hardware.vr.LowVEnvironment()
    def newEye(self, name, xsize = None, ysize = None):
        """
        Create a VEye for the loaded environment.
        """
        if xsize == None or ysize == None:
            xsize, ysize = track.videotrack.getResolution()
        return VEye(pyepl.hardware.vr.LowVEye(self.env, xsize, ysize), name, self)
    def newAvatar(self, name, *targs, **dargs):
        """
        Create a VAvatar for the loaded environment.
        """
        return VAvatar(pyepl.hardware.vr.LowVAvatarSpeedBubble(self.env, *targs, **dargs), name, self)
    def addSphereGeom(self, x, y, z, radius, **surf):
        """
        """
        r = self.env.addEntity(pyepl.hardware.vr.SphereGeom(x, y, z, radius, **surf))
        self.logMessage("I\tSPHEREGEOM\t%s\t%s\t%d" % ((x, y, z, radius), repr(surf), id(r)))
        return r
    def addBoxGeom(self, x, y, z, xsize, ysize, zsize, **surf):
        """
        """
        r = self.env.addEntity(pyepl.hardware.vr.BoxGeom(x, y, z, xsize, ysize, zsize, **surf))
        self.logMessage("I\tBOXGEOM\t%s\t%s\t%d" % ((x, y, z, xsize, ysize, zsize), repr(surf), id(r)))
        return r
    def addPlaneGeom(self, a, b, c, d, **surf):
        """
        """
        r = self.env.addEntity(pyepl.hardware.vr.PlaneGeom(a, b, c, d, **surf))
        self.logMessage("I\tPLANEGEOM\t%s\t%s\t%d" % ((a, b, c, d), repr(surf), id(r)))
        return r
    def addBuildingBox(self, x, y, z, image, width, height, roofimage = None, rooftexlen = None, texlen = None):
        """
        """
        if roofimage:
            roofimg = roofimage.getLowUnscaled()
            rfn = roofimage.filename
        else:
            rfn = None
            roofimg = None
        r = self.env.addEntity(pyepl.hardware.vr.BuildingBox(x, y, z, image.getLowUnscaled(), width, height, roofimg, rooftexlen, texlen))
        self.logMessage("I\tBUILDINGBOX\t%s\t%d" % ((x, y, z, image.filename, width, height, rfn, rooftexlen, texlen), id(r)))
        return r
    def addSphere(self, x, y, z, image, radius, slices = 16, stacks = 16):
        """
        """
        r = self.env.addEntity(pyepl.hardware.vr.Sphere(x, y, z, image.getLowUnscaled(), radius, slices, stacks))  #inefficient for sky!
        self.logMessage("I\tSPHERE\t%s\t%d" % ((x, y, z, image.filename, radius, slices, stacks), id(r)))
        return r
    def addFloorBox(self, x, y, z, xsize, ysize, zsize, floorimage, floortexlen = None, wallimage = None, walltexlen = None, wallFrontImage = None, wallFrontTexlen = None, wallRearImage = None, wallRearTexlen = None, wallLeftImage = None, wallLeftTexlen = None, wallRightImage = None, wallRightTexlen = None):
        if wallimage:
            wallimgFront = wallimage.getLowUnscaled()
            wFrontFn = wallimage.filename
            wallimgRear = wallimage.getLowUnscaled()
            wRearFn = wallimage.filename
            wallimgLeft = wallimage.getLowUnscaled()
            wLeftFn = wallimage.filename
            wallimgRight = wallimage.getLowUnscaled()
            wRightFn = wallimage.filename
            wtxlnFront = walltexlen
            wtxlnRear = walltexlen
            wtxlnLeft = walltexlen
            wtxlnRight = walltexlen
        else:
            wallimgFront = None
            wFrontFn = None
            wallimgRear = None
            wRearFn = None
            wallimgLeft = None
            wLeftFn = None
            wallimgRight = None
            wRightFn = None
            wtxlnFront = walltexlen
            wtxlnRear = walltexlen
            wtxlnLeft = walltexlen
            wtxlnRight = walltexlen
        if wallFrontImage:
            wallimgFront = wallFrontImage.getLowUnscaled()
            wFrontFn = wallFrontImage.filename
            wtxlnFront = wallFrontTexlen
        if wallRearImage:
            wallimgRear = wallRearImage.getLowUnscaled()
            wRearFn = wallRearImage.filename
            wtxlnRear = wallRearTexlen
        if wallLeftImage:
            wallimgLeft = wallLeftImage.getLowUnscaled()
            wLeftFn = wallLeftImage.filename
            wtxlnLeft = wallLeftTexlen
        if wallRightImage:
            wallimgRight = wallRightImage.getLowUnscaled()
            wRightFn = wallRightImage.filename
            wtxlnRight = wallRightTexlen
            
        r = self.env.addEntity(pyepl.hardware.vr.FloorBox(x, y, z, xsize, ysize, zsize, floorimage.getLowUnscaled(), floortexlen, wallimgFront, wtxlnFront, wallimgRear, wtxlnRear, wallimgLeft, wtxlnLeft, wallimgRight, wtxlnRight))
        self.logMessage("I\tFLOORBOX\t%s\t%d" % ((x, y, z, xsize, ysize, zsize, floorimage.filename, floortexlen, wFrontFn, wtxlnFront, wRearFn, wtxlnRear, wLeftFn, wtxlnLeft, wRightFn, wtxlnRight), id(r)))
        return r
    def addSkyBox(self, image=None, imageFront=None, imageRear=None, imageLeft=None, imageRight=None, x = 0.0, y = 0.0, z = 0.0, xsize = 500.0, ysize = 500.0, zsize = 500.0, texlen = 500.0, texlenFront = 500.0, texlenRear = 500.0, texlenLeft = 500.0, texlenRight = 500.0, xTileFactorFront = 1, xTileFactorRear = 1, xTileFactorLeft = 1, xTileFactorRight = 1, yTileFactorFront = 1, yTileFactorRear = 1, yTileFactorLeft = 1, yTileFactorRight = 1):
        if image:
            imgFront = image.getLowUnscaled()
            imgRear = image.getLowUnscaled()
            imgLeft = image.getLowUnscaled()
            imgRight = image.getLowUnscaled()
            txlnFront = texlen
            txlnRear = texlen
            txlnLeft = texlen
            txlnRight = texlen
            imgFrontFn = image.filename
            imgRearFn = image.filename
            imgLeftFn = image.filename
            imgRightFn = image.filename
            
        if imageFront:
            imgFront = imageFront.getLowUnscaled()
            txlnFront = texlenFront
            imgFrontFn = imageFront.filename           
        if imageRear:
            imgRear = imageRear.getLowUnscaled()
            txlnRear = texlenRear
            imgRearFn = imageFront.filename
        if imageLeft:
            imgLeft = imageLeft.getLowUnscaled()
            txlnLeft = texlenLeft
            imgLeftFn = imageLeft.filename
        if imageRight:
            imgRight = imageRight.getLowUnscaled()
            txlnRight = texlenRight
            imgRightFn = imageRight.filename
            
        if not image and not (imageFront and imageRear and imageLeft and imageRight):
            raise NoSkyBoxImageError()
        
        r = self.env.addEntity(pyepl.hardware.vr.SkyBox(imgFront,imgRear,imgLeft,imgRight, x, y, z, xsize, ysize, zsize, txlnFront, txlnRear, txlnLeft, txlnRight, xTileFactorFront, xTileFactorRear, xTileFactorLeft, xTileFactorRight, yTileFactorFront, yTileFactorRear, yTileFactorLeft, yTileFactorRight))
        self.logMessage("I\tSKYBOX\t%s\t%d" % ((x, y, z, xsize, ysize, zsize, imgFrontFn, txlnFront, imgRearFn, txlnRear, imgLeftFn, txlnLeft, imgRightFn, txlnRight, xTileFactorFront, xTileFactorRear, xTileFactorLeft, xTileFactorRight, yTileFactorFront, yTileFactorRear, yTileFactorLeft, yTileFactorRight), id(r)))
        return r
    def addSprite(self, x, y, z, image, xsize, ysize):
        """
        """
        r = self.env.addEntity(pyepl.hardware.vr.Sprite(x, y, z, image.getLowUnscaled(), xsize, ysize))
        self.logMessage("I\tSPRITE\t%s\t%d" % ((x, y, z, image.filename, xsize, ysize), id(r)))
        return r
    def setGravity(self, x, y, z):
        """
        """
        self.env.setGravity(x, y, z)
        self.logMessage("G\t%f\t%f\t%f" % (x, y, z))
    def setFog(self, mode = None, color = (0.5, 0.5, 0.5), far = 1.0, near = 0.0, density = 1.0):
        """
        """
        self.env.setFog(mode, color, far, near, density)
        self.logMessage("F\t%s\t%r\t%f\t%f\t%f" % (mode, color, far, near, density))
    def removeEntity(self, *entities):
        """
        """
        for entity in entities:
            self.env.removeEntity(entity)
            self.logMessage("D\t%d" % id(entity))
    def markScreenUpdate(self, timestamp):
        """
        We want to know when the screen is actually updated so that
        our log entries have correct timestamps.
        """
        if self.logall:
            for m in self.logqueue:
                self.logMessage(m, timestamp)
        self.logqueue = []
    def eyeLookAtLog(self, eyename, px, py, pz, tx, ty, tz, ux, uy, uz, fov):
        """
        Log a "look at" eye positioning event.
        """
        self.logqueue.append("L\t%s\t%f\t%f\t%f\t%f\t%f\t%f\t%f\t%f\t%f\t%f" % (eyename, px, py, pz, tx, ty, tz, ux, uy, uz, fov))
    def eyeAttachLog(self, eyename, avatarname):
        """
        Log the attachment of an eye to an avatar.
        """
        self.logqueue.append("A\t%s\t%s" % (eyename, avatarname))
    def avatarMoveLog(self, avatarname, x, y, z, yaw, pitch, roll):
        """
        Log the movement of an avatar.
        """
        self.logqueue.append("M\t%s\t%f\t%f\t%f\t%f\t%f\t%f" % (avatarname, x, y, z, yaw, pitch, roll))