Home
Blogs
Forums
News
Portfolios
Projects
Tutorials
23 users logged in
New? Learn about game development.
Before posting, review our community guidelines.
Follow Us
Chat in the GameDev.net Discord!
Mastodon
Back to Graphics and GPU Programming

What am I doing wrong with camera-following-object code?

Started by
1 comment, last by 3TATUK2 10 years, 8 months ago

My camera won't follow my object. Or maybe my object is not appearing where it should (meaning my camera is correctly oriented according to the cubes matrix, but I am drawing the cube with incorrect order of commands?).

Is my math wrong, or am I handling the drawing pipeline incorrectly?



SCREEN_SIZE = (1200, 900)

import sys
from math import radians
from math import cos

from OpenGL.GL import *
from OpenGL.GLU import *

import pygame
from pygame.locals import *

from gameobjects.matrix44 import *
from gameobjects.vector3 import *

from random import *

class Cube_Projectile(object):


    def __init__(self, position):

        self.abs_position = (0.0, 0.0, 0.0)
        self.abs_rotation = [0.0, 0.0, 0.0]

        self.abs_rot_matrix = [[1.0,0.0,0.0,0.0],
                               [0.0,1.0,0.0,0.0],
                               [0.0,0.0,1.0,0.0],
                               [0.0,0.0,0.0,1.0]]

        self.color = (uniform(0.0, 1.0), 1.0, 2.0, uniform(0.0, 1.0))
        self.life = 1000
        self.name = ""
        self.mass = 1
        self.velocity = 0
        self.momentum = self.mass*self.velocity
        self.matrix = Matrix44()

    def render(self, rotation, rot_matrix):

        if self.life > 0:

            glPushMatrix()
            glLineWidth(10)
            glBegin(GL_LINES)
            glColor(3,0,0)
            glVertex(0.0, 0.0, 0.0)
            glVertex(0.0, 0.0, 25.0)
            glColor(0,3,0)
            glVertex(0.0, 0.0, 0.0)
            glVertex(0.0, 25.0, 0.0)
            glColor(0,0,3)
            glVertex(0.0, 0.0, 0.0)
            glVertex(25.0, 0.0, 0.0)
            glEnd()
            glPopMatrix()

            glPushMatrix()
            #glTranslate(self.abs_position[0], self.abs_position[1], self.abs_position[2])

            rot_matrix.translate = self.abs_position
            glLoadMatrixd(rot_matrix.to_opengl())
            glScale(.5,.5,.5)
            print "self.abs_rot_matrix: \n",self.abs_rot_matrix[0], "\n",self.abs_rot_matrix[1], "\n",self.abs_rot_matrix[2],"\n\n","Internal Matrix: \n",glGetDoublev(GL_MODELVIEW_MATRIX),"\n\n\n\n\n"

            glColor(self.color)

            glBegin(GL_QUADS)

            glNormal3f(-1.0, -1.0, 1.0)
            glVertex3f(-2.000000, -2.000000, -2.000000)
            glNormal3f(-1.0, -1.0, 1.0)
            glVertex3f(-2.000000, -2.000000, 2.000000)
            glNormal3f(-1.0, 1.0, 1.0)
            glVertex3f(-2.000000, 2.000000, 2.000000)
            glNormal3f(-1.0, 1.0, -1.0)
            glVertex3f(-2.000000, 2.000000, -2.000000)

            glNormal3f(-1.0, 1.0, 1.0)
            glVertex3f(-2.000000, 2.000000, -2.000000)
            glNormal3f(1.0, 1.0, -1.0)
            glVertex3f(2.000000, 2.000000, -2.000000)
            glNormal3f(1.0, -1.0, -1.0)
            glVertex3f(2.000000, -2.000000, -2.000000)
            glNormal3f(-1.0, -1.0, -1.0)
            glVertex3f(-2.000000, -2.000000, -2.000000)

            glNormal3f(1.0, 1.0, -1.0)
            glVertex3f(2.000000, 2.000000, -2.000000)
            glNormal3f(-1.0, 1.0, 1.0)
            glVertex3f(2.000000, 2.000000, 2.000000)
            glNormal3f(1.0, -1.0, 1.0)
            glVertex3f(2.000000, -2.000000, 2.000000)
            glNormal3f(1.0, -1.0, -1.0)
            glVertex3f(2.000000, -2.000000, -2.000000)


            glNormal3f(-1.0, -1.0, 1.0)
            glVertex3f(-2.000000, -2.000000, 2.000000)
            glNormal3f(1.0, -1.0, 1.0)
            glVertex3f(2.000000, -2.000000, 2.000000)
            glNormal3f(1.0, 1.0, 1.0)
            glVertex3f(2.000000, 2.000000, 2.000000)
            glNormal3f(-1.0, 1.0, 1.0)
            glVertex3f(-2.000000, 2.000000, 2.000000)


            glNormal3f(-1.0, -1.0, 1.0)#---
            glVertex3f(-2.000000, -2.000000, 2.000000)
            glNormal3f(-1.0, -1.0, -1.0)
            glVertex3f(-2.000000, -2.000000, -2.000000)
            glNormal3f(1.0, -1.0, -1.0)
            glVertex3f(2.000000, -2.000000, -2.000000)
            glNormal3f(1.0, -1.0, 1.0)
            glVertex3f(2.000000, -2.000000, 2.000000)

            glNormal3f(1.0, 1.0, 1.0)
            glVertex3f(2.000000, 2.000000, 2.000000)
            glNormal3f(1.0, 1.0, -1.0)
            glVertex3f(2.000000, 2.000000, -2.000000)
            glNormal3f(-1.0, 1.0, -1.0)
            glVertex3f(-2.000000, 2.000000, -2.000000)
            glNormal3f(-1.0, 1.0, 1.0)
            glVertex3f(-2.000000, 2.000000, 2.000000)

            glEnd()

            glPopMatrix()


def resize(width, height):

    glViewport(0, 0, width, height)
    glMatrixMode(GL_PROJECTION)
    glLoadIdentity()
    gluPerspective(60.0, float(width)/height, .1, 1000.)
    glMatrixMode(GL_MODELVIEW)
    glLoadIdentity()


def init():

    glEnable(GL_DEPTH_TEST)
    glShadeModel(GL_FLAT)
    glClearColor(0.0, 0.0, 0.0, 1.0)
    glEnable(GL_COLOR_MATERIAL)
    glEnable(GL_LIGHTING)
    glEnable(GL_LIGHT0)
    glLight(GL_LIGHT0, GL_POSITION,  (10, 10, 10, 0))

def run():

    pygame.init()
    screen = pygame.display.set_mode(SCREEN_SIZE, HWSURFACE|OPENGL|DOUBLEBUF)

    resize(*SCREEN_SIZE)

    init()

    PAUSED = "False"

    clock = pygame.time.Clock()

    glMaterial(GL_FRONT, GL_AMBIENT, (0.1, 0.1, 0.1, 1.0))
    glMaterial(GL_FRONT, GL_DIFFUSE, (1.0, 2.0, 1.0, 1.0))

    camera_matrix = Matrix44()

    camera_matrix.translate = (0.0, 0.0, 0.0)

    # Initialize speeds and directions
    rotation_direction = Vector3()
    rotation_speed = radians(90.0)
    movement_direction = Vector3()
    movement_speed = 5.0

    obj_1 = Cube_Projectile((0, 0, 0))
    obj_1.name = "obj 1"
    obj_1.color = (4.0, 0.0, 0.0, 0)

    objects_Render = []

    objects_Render.append(obj_1)

    while True:
        for event in pygame.event.get():
            if event.type == QUIT:
                pygame.quit()
                sys.exit()
            if event.type == KEYUP and event.key == K_ESCAPE:
                pygame.quit()
                sys.exit()


        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        time_passed = clock.tick()
        time_passed_seconds = time_passed / 1000.0
        pressed = pygame.key.get_pressed()
        rotation_direction.set(0.0, 0.0, 0.0)
        movement_direction.set(0.0, 0.0, 0.0)


        if pressed[K_a]:
            rotation_direction.y = +1.0
        elif pressed[K_d]:
            rotation_direction.y = -+1.0
        if pressed[K_DOWN]:
            rotation_direction.x = +1.0
        elif pressed[K_UP]:
            rotation_direction.x = -1.0
        if pressed[K_RIGHT]:
            rotation_direction.z = +1.0
        elif pressed[K_LEFT]:
            rotation_direction.z = -1.0
        if pressed[K_s]:
            movement_direction.z = -10.0
        elif pressed[K_w]:
            movement_direction.z = +10.0
        elif pressed[K_n]:
            objects_Render.append(Cube_Projectile((uniform(-2, 2), uniform(-2, 2), uniform(-2, 2))))

        rotation = rotation_direction * rotation_speed * time_passed_seconds
        rotation_matrix = Matrix44.xyz_rotation(*rotation)
        camera_matrix *= rotation_matrix
        heading = Vector3(camera_matrix.forward)
        movement = heading * movement_direction.z * movement_speed
        objects_Render[0].abs_position += movement * time_passed_seconds
        print "Absolute Position: ", objects_Render[0].abs_position, "\n\n"
        glLight(GL_LIGHT0, GL_POSITION,  (0, 2, 1, 7))

        for obj in objects_Render:
            if objects_Render.index(obj) == 0:
                obj.render(tuple([rotation[0], rotation[1], rotation[2], 0.0]), camera_matrix)
            else:
                obj.render(tuple([rotation[0], rotation[1], rotation[2], 0.0]), camera_matrix)

        if len(objects_Render) != 0:
            glLoadIdentity()
            gluLookAt(camera_matrix.translate[0] - (10*heading[0]),
                      camera_matrix.translate[1] - (10*heading[1]),
                      camera_matrix.translate[2] - (10*heading[2]),
                      camera_matrix.translate[0],
                      camera_matrix.translate[1],
                      camera_matrix.translate[2],
                      camera_matrix.up[0],
                      camera_matrix.up[1],
                      camera_matrix.up[2])

        else:
            glLoadIdentity()
            gluLookAt(0.0, 0.0, -1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0)
        pygame.display.flip()



run()
Advertisement

I will eventually get rid of the gluLookAt code. It is deprecated, and I am even upload a version of the same matrix, and altering it a little to replace LookAt won't be to diff...

but I just haven't messed with it yet. :P

[deleted]

This topic is closed to new replies.

Advertisement

Popular Topics

Calin
Avoiding other units without using pathfinding General and Gameplay Programming
black4
Quake 1 source code triangle rasterization General and Gameplay Programming
coulomb
D3D12 Alpha blending not working both ways Graphics and GPU Programming
pbivens67
AABB collision For Beginners
taby
Post-Newtonian general relativity Math and Physics
gjl
ARM64 Native Calling Convention Return Issue on Apple Silicon AngelCode
Advertisement

Recommended Tutorials

GameDev.net
How Scavengers is launching across multiple platforms and stores with cross-play Networking and Multiplayer
Myopic Rhino
Gaining Entry to Game Development Career Development
Code_Analysis
Wade Not In Unknown Waters: Part Three General and Gameplay Programming
Myopic Rhino
Evolutionary Design: A practical process for creating great game designs Game Design and Theory
Myopic Rhino
XGDX 2004 Report Event Coverage

Reticulating splines

About GameDev.net
Community Guidelines
Terms of Service
Privacy Policy
Contact Us
Copyright (c) 1999-2024 GameDev.net, LLC
Back to Top