marți, 12 octombrie 2010

PyGame - first interface - part 2

One thing necessary to create an interface and a game is using a "sprite system".
To illustrate this, I'll show you a sequence of source code:

import pygame
def must_quit():
    event = pygame.event.poll()
    return event.type == pygame.QUIT
screen = pygame.display.set_mode((640, 480))
SpriteImage = pygame.image.load('image.jpg')
while not must_quit():
    screen.blit(SpriteImage, (0, 0))
    pygame.display.flip()

It sounds simple but is not.
Why? Because when you work with multiple images when source code is more complicated.
For this we need a system and use the "classes".
Let's see:

class SpriteImage:
    def __init__(self, image_filename):
        self.image = pygame.image.load(image_filename)
    def paint(self):
        screen.blit(self.image, (0, 0))
screen = pygame.display.set_mode((640, 480))
sprite = SpriteImage('image.jpg')

This is more simple way to use it.
Try learning more about pygame.
Good luck.

luni, 2 august 2010

Pygame info about driver and zbuffer.

Sometime is very easy to see some info about pygame.
Just use this code:

>>> import pygame 
>>> from pygame import * 
>>> pygame.init()
(6, 0)
>>> pygame.display.gl_set_attribute(GL_DEPTH_SIZE, 16)
>>> pygame.display.set_mode((640,480), OPENGL|DOUBLEBUF )

>>> print "ZBUFFER is:" ,pygame.display.gl_get_attribute(GL_DEPTH_SIZE)
ZBUFFER is: 24
>>> print "Driver is:", pygame.display.get_driver()
Driver is: x11
NOTE: The OPENGL flags are;

  GL_ALPHA_SIZE, GL_DEPTH_SIZE, GL_STENCIL_SIZE, GL_ACCUM_RED_SIZE,
  GL_ACCUM_GREEN_SIZE,  GL_ACCUM_BLUE_SIZE, GL_ACCUM_ALPHA_SIZE,
  GL_MULTISAMPLEBUFFERS, GL_MULTISAMPLESAMPLES, GL_STEREO
You can see more here.

Binary bitmate with pygame

Is a very simple example.
I use this code :

import pygame
from pygame.locals import *
import random
import Numeric
from math import *
import random
WIDTH = 640     #width of screen
HEIGHT = 480    #height of screen
def main():
    pygame.display.init()
    
    screen = pygame.display.set_mode((WIDTH,HEIGHT),DOUBLEBUF,32)
    pixels = pygame.surfarray.pixels3d(screen)
    
    width = len(pixels)-1
    height = len(pixels[0])-1
    
    for y in xrange(height):
        for x in xrange(width):
   a=random.choice([0,1])
   if a==1 : b=(255,255,255)
   else : b=(0,0,0)
   pixels[x,y] = (b)
    pygame.display.update()
    done = False
    while not done:
        for e in pygame.event.get():
            if e.type == KEYDOWN:
                done = True
if __name__ == "__main__":
    main()
The most important is this line : 
pixels = pygame.surfarray.pixels3d(screen)
I use random function to select "0" or "1" and set the colors .
Next, I fill the screen by update the screen with new values of pixels : pygame.display.update()
See bellow the result :

miercuri, 9 iunie 2010

PyGame - first interface - part 1


This is the first game based on pygame that I tried to use interface.
As shown in the picture below, we have three areas:
  • One at the top where there will be characters
  • One at the bottom where there will be buttons
  • A mini map on bottom left
I do not want to display the source code yet, since it is rough.
I will present in future in a more understandable formula.
Good luck.

joi, 11 martie 2010

PyGame and OpenGL - part 2

Today i will show you how we find stuff about graphic hardware.
We will use two modules: pyopengl and pygame.
Modules can import other modules.
Each module is only imported once per interpreter session.
>>> import pygame 
>>> import OpenGL 

The imports are taken in the local symbol table, so we need to do this:
>>> from pygame import *
>>> from OpenGL import *
>>> from OpenGL.GL import * 
>>> from OpenGL.GLUT import * 

The next thing you must do is call the function glutInit.
>>> glutInit()
['foo']

And now use pygame to create window.
>>> pygame.init()
(6, 0)
>>> pygame.display.set_mode((10,10),OPENGL|DOUBLEBUF)


Note:If we not create the window the next commands will not work.
About the beautiful glGetString function, we know.
This return a string describing the current GL connection.
You can use dir() and help() functions to see more.
But we see bellow, some example:
>>> dir(glGetString)
['__call__', '__class__', '__ctypes_from_outparam__', '__delattr__',
 '__dict__','__doc__', '__format__', '__getattribute__', '__hash__',
 '__init__', '__module__',
 '__name__', '__new__', '__nonzero__', '__reduce__', '__reduce_ex__', 
'__repr__', '__setattr__', '__setstate__', '__sizeof__', '__str__', 
'__subclasshook__',
 '__weakref__', '_b_base_', '_b_needsfree_', '_flags_', '_objects', 
'_restype_', 'argtypes', 'errcheck', 'restype']
>>> dir(glGetString())
['__class__', '__delattr__', '__doc__', '__format__', '__getattribute__', 
'__hash__', '__init__', '__new__', '__reduce__', '__reduce_ex__', 
'__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']

Now, the parameters of this function are :
glGetString(GL_VERSION)
glGetString(GL_VENDOR)
glGetString(GL_RENDERER)
glGetStringi(GL_EXTENSIONS, i) 

Bellow, we see how we use these parameters:
>>> glGetString(GL_VERSION) 
'2.1.2 NVIDIA 173.14.22'
>>> glGetString(GL_VENDOR) 
'NVIDIA Corporation'
>>> glGetString(GL_RENDERER) 
'GeForce FX 5200/AGP/SSE/3DNOW!'

Because the GL_EXTENSIONS is a space-separated list of supported extensions to GL, we can use these commands:
>>> print glGetString(GL_EXTENSIONS)

Or you can format this result, see bellow
>>> print glGetString(GL_EXTENSIONS).split()
['GL_ARB_depth_texture', 'GL_ARB_fragment_program', ...

This is all.