def reset(self):
tangent = math.tan(self.FIELD_OF_VIEW_IN_DEGREES / 2.0 / 180.0 *
math.pi)
distanceFromTarget = self.sceneRadius / tangent
self.position = Point3D(0, 0, distanceFromTarget)
# print(self.position)
self.target = Point3D(0, 0, 0)
# print(self.target)
self.up = self.ground.returnCopy()
t2p = self.position - self.target
M1 = Matrix4x4.rotationAroundOrigin(np.pi / 3, Vector3D(1, 0, 0))
# print('M1',M1)
# M2 = Matrix4x4.rotationAroundOrigin( np.pi/2, Vector3D(1,0,0) )
# print(M2)
M3 = Matrix4x4.rotationAroundOrigin(-np.pi / 6, Vector3D(0, 1, 0))
# print('M3',M3)
# t2p = M2 * t2p
# t2p = M1 * t2p
# M_temp = Matrix4x4()
# M_temp.m = [ 0.0, 0.0, -1.0, 0.0,
# -1.0, 0.0, 0.0, 0.0,
# 0.0, 1.0, 0.0, 0.0,
# 0.0, 0.0, 0.0, 1.0 ]
t2p = M1 * t2p
t2p = M3 * t2p
self.position = self.target + t2p
self.ground = Vector3D(0, 0, 1)
def reset(self):
tangent = math.tan(self.FIELD_OF_VIEW_IN_DEGREES / 2.0 / 180.0 *
math.pi)
distanceFromTarget = self.sceneRadius / tangent
self.position = Point3D(0, 0, distanceFromTarget)
self.target = Point3D(0, 0, 0)
self.up = self.ground.returnCopy()
def __init__(self):
self.FIELD_OF_VIEW_IN_DEGREES = 10.0
self.ORBITING_SPEED_IN_DEGREES_PER_RADIUS_OF_VIEWPORT = 300.0
# These are in world-space units.
self.nearPlane = 1.0
self.farPlane = 10000.0
# Perspective parameters
self.aspectratio = 1.0
# Those are the direction fo the three axis of the camera in
# world coordinates, used to compute the rotations necessary
self.a = Vector3D(1.0, 0.0, 0.0)
self.b = Vector3D(0.0, 1.0, 0.0)
self.c = Vector3D(0.0, 0.0, 1.0)
# During dollying (i.e. when the camera is translating into
# the scene), if the camera gets too close to the target
# point, we push the target point away.
# The threshold distance at which such "pushing" of the
# target point begins is this fraction of nearPlane.
# To prevent the target point from ever being clipped,
# this fraction should be chosen to be greater than 1.0.
self.PUSH_THRESHOLD = 1.3
# We give these some initial values just as a safeguard
# against division by zero when computing their ratio.
self.viewportWidthInPixels = 10
self.viewportHeightInPixels = 10
self.viewportRadiusInPixels = 5
self.sceneRadius = 10
# point of view, or center of camera; the ego-center; the eye-point
self.position = Point3D()
# point of interest; what the camera is looking at; the exo-center
self.target = Point3D()
# This is the up vector for the (local) camera space
self.up = Vector3D()
self.mouse_zoom(0)
# This is the up vector for the (global) world space;
# it is perpendicular to the horizontal (x,z)-plane
self.ground = Vector3D(0, 1, 0)
self.reset()
def paintGL(self):
def paintProjectorImage(proj, offset, size, alpha):
glColor(1.0, 1.0, 1.0, alpha)
ar = 1.0 / proj.aspectRatio * 4.0
className = str(self.canvasModel.__class__)
projShader = self.shaders[className + "_proj"]
# if self.selTexture in self.textures:
glActiveTexture(GL_TEXTURE0)
# use first texturing unit
projShader.use()
projShader.set(proj_texture=("1i", [0]),
alpha_value=("1f", [alpha]))
self.canvasModel.shaderSettings(projShader)
self.projectors.shaderSettings(projShader)
self.textures[self.selTexture].setup()
glBegin(GL_QUADS)
glTexCoord2f(0.0, 0.0)
glVertex2fv(offset)
glTexCoord2f(1.0, 0.0)
glVertex2f(offset[0] + ar * size, offset[1])
glTexCoord2f(1.0, 1.0)
glVertex2f(offset[0] + ar * size, offset[1] + size)
glTexCoord2f(0.0, 1.0)
glVertex2f(offset[0], offset[1] + size)
glEnd()
projShader.unuse()
if self.edgeBlending:
edgeBlendShader = self.shaders[className + "_edgeblend"]
edgeBlendShader.use()
# edgeBlendShader.set(proj_texture = ("1i",[0]),
# alpha_value = ("1f",[alpha]))
self.canvasModel.shaderSettings(edgeBlendShader)
self.projectors.shaderSettings(edgeBlendShader)
self.projectors.edgeBlendShaderSettings(edgeBlendShader)
glBegin(GL_QUADS)
glTexCoord2f(0.0, 0.0)
glVertex2fv(offset)
glTexCoord2f(1.0, 0.0)
glVertex2f(offset[0] + ar * size, offset[1])
glTexCoord2f(1.0, 1.0)
glVertex2f(offset[0] + ar * size, offset[1] + size)
glTexCoord2f(0.0, 1.0)
glVertex2f(offset[0], offset[1] + size)
glEnd()
edgeBlendShader.unuse()
def drawProjectorImage():
glLoadIdentity()
glMatrixMode(GL_PROJECTION)
glLoadIdentity()
gluOrtho2D(0, 1 / float(self.height()) * self.width(), 0, 1)
glMatrixMode(GL_MODELVIEW)
glLoadIdentity()
glDisable(GL_DEPTH_TEST)
glDisable(GL_CULL_FACE)
if self.projImagesFullscreen and self.selectedProj != -1:
paintProjectorImage(self.projectors[self.selectedProj],
[0.0, 0.0], 1.0, 0.5)
else:
bottom = 0.05
size = 0.2
xOffset = 0.05
proj = self.projectors
paintProjectorImage(proj, [xOffset, bottom], size, 1.0)
xOffset += size / proj.aspectRatio + 0.05
glDisable(GL_TEXTURE_2D)
light0 = Light(GL_LIGHT0, Point3D(0.0, -20.0, -20.0))
light1 = Light(GL_LIGHT1, Point3D(0.0, 20.0, 20.0))
glMatrixMode(GL_PROJECTION)
glLoadIdentity()
self.camera.transform()
glMatrixMode(GL_MODELVIEW)
glLoadIdentity()
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
glDepthFunc(GL_LEQUAL)
glEnable(GL_DEPTH_TEST)
colors = {
"projA": [1, 0, 0],
"projB": [0, 1, 0],
"projC": [0, 0, 1],
"projC": [1, 1, 0]
}
glPushMatrix()
glLoadIdentity()
#self.projectors.drawA(self.canvasModel,colors["projA"])
#self.projectors.drawB(self.canvasModel,colors["projB"])
#self.projectors.drawC(self.canvasModel,colors["projC"])
#self.projectors.drawD(self.canvasModel,colors["projD"])
glPopMatrix()
if self.showCanvas:
mode = GLU_FILL
texture = None
if self.selTexture in self.textures:
texture = self.textures[self.selTexture]
shader = self.shaders[str(self.canvasModel.__class__) +
"_inv_proj"]
shader.use()
self.canvasModel.shaderSettings(shader)
self.projectors.shaderSettings(shader)
shader.set(proj_multi=("4f", [[1.0, 1.0, 1.0, 1.0]]))
self.canvasModel.draw(mode, texture, colors, None,
self.selectedProj)
shader.unuse()
drawProjectorImage()
glFlush()