my_camera.py

from __future__ import division
import math
from math import pi , tan, radians, sqrt, sin, cos
import pyglet
from pyglet.gl import *
from pyglet.window import key, mouse, Window

class camera_move_target(object):
    def __init__(self, camera):
        self.x = camera.x
        self.y = camera.y
        self.scale = camera.scale

class camera(object):
    def __init__(self,x, y, w, h):
        self.x = x
        self.y = y
        self.h = h
        self.w = w
        self.page_w = self.w
        self.near = 1
        self.far = -1
        self.speed = 0.1
        self.scale = 1.0
        self.angle = 0
        self.max_world_x = self.w
        self.target = camera_move_target(self)

    def pan(self, x, y):
        self.target.x -= x
        self.target.y -= y

    def pan_lr(self, length):
        self.target.x += length

    def goto_x(self, x_location):
        self.target.x = x_location

    def pan_ud(self, length):
        self.target.y += length

    def zoom(self, scale):
        self.target.scale += scale

    def update(self):
        #print self.x, self.target.x

        if self.x > self.max_world_x - self.w/2 :
            self.x = self.x - 1
            self.target.x = self.max_world_x - self.w/2
        elif self.x < 0 + self.w/2:
            self.target.x = 0 + self.w/2
            self.x = self.x + 1.0
        else:
            self.x += (self.target.x - self.x) * self.speed

        self.y += (self.target.y - self.y) * self.speed
        self.scale += int(self.target.scale - self.scale) * self.speed

    def update_no_delay(self):
        print "no_delay"
        #self.target.x = 0
        #self.target.y = 0
        print self.x, self.target.x
        if self.x > self.max_world_x - self.w/2 :
            self.x = self.x - 1
            self.target.x = self.max_world_x - self.w/2
        elif self.x < 0 + self.w/2:
            self.target.x = 0 + self.w/2
            self.x = self.x + 1.0
        else:
            self.x = int(self.target.x - self.x)

        self.y = int(self.target.y - self.y)
        self.scale += int(self.target.scale - self.scale)

    def project(self, w, h):
        glMatrixMode(GL_PROJECTION)
        #gluPerspective(45, 1.0 * w/h, 0.1, 100.0)
        glLoadIdentity()
        glOrtho( self.x - self.w /2 , self.x + self.w /2, self.y - self.h/2 , self.y + self.h/2 ,  -10, 10);
        #gluOrtho2D( self.x - self.w /2 , self.x + self.w /2, self.y - self.h/2 , self.y + self.h/2 );
        glMatrixMode(GL_MODELVIEW)
        glLoadIdentity()


    def headsup(self, width, height):
        glMatrixMode(GL_PROJECTION)
        glLoadIdentity()
        glOrtho(0, self.w ,  0, self.h, -10, 10)
        glMatrixMode(GL_MODELVIEW)
        glLoadIdentity()

    def hud_mode(self, width, height):
        glMatrixMode(GL_PROJECTION)
        glLoadIdentity()
        gluOrtho2D(0, width, 0, height)
        glMatrixMode(GL_MODELVIEW)
        glLoadIdentity()

    def calc_pos(self, mx, my):
        rx = ( mx + self.x - self.w/2 )
        ry = ( my +self.y - self.h/2 )
        return rx, ry