I've had my Asrock ION-330-HT-BD for over a month now

First, the history. Ever since the first modchips for the original XBox appeared (and shortly thereafter, XBMC - or whatever it was first called), I've been watching all of my digital content on the television. We'd even cancelled my cable subscription: all of the "good" stuff (i.e. the things we wanted to watch, on our time) could be found on DVD or the internet anyway.

HD content came along, the old SD TV died, and so I had to look out for a way to display HD content on my new Sony Bravia.

The feedback on the first Asrock nettops was OK, so I was very eager to get me the new HT models (with Blu-Ray drive). The minute the machines were launched (here in Belgium), I scoured the online shops and found a great deal at a local computer shop for an ASrock ION-330-HT-BD.

The dealer, who wasn't very knowledgeable about these new nettops, was as surprised as I was when I found out there was no memory and no harddisk in the machine. I had bought the barebones version (at the barebones price), thinking I had the full version.

Things ended well however, as the PC dealer proposed to sell me the memory and HD at half their prices. So, I installed a 32Gb SSD drive and 3Gb of RAM.

Coming up next: getting it all running...

pyqt4 designer failed to start because application configuration is incorrect

When you try and install the latest snapshot of PyQt4 and try and run the designer, you might get this error message: "The application failed to start because application configuration is incorrect."

It took me a long time to find out, but you might be helped by installing the MS Visual C++ 2008 Redistributable Package, from Microsoft.

Example 3-2 : Using Modeling Transformations

I'm tired.

I scratched my head over the Z-axis stuff; be sure to read the paragraph called "Troubleshooting Transformations" in chapter 3. It'll help prevent a lot of scratch-marks.

In this case, the following phrase made me realise the mistake I made:

Remember that with the projection commands, the near and far coordinates measure distance from the viewpoint and that (by default) you're looking down the negative z axis. Thus, if the near value is 1.0 and the far 3.0, objects must have z coordinates between -1.0 and -3.0 in order to be visible.

The vertices I drew were all on the positive side of the z-axis, while I had to give them negative z-coordinates ofcourse.

(Note to self: first read the whole chapter before trying out all the examples in the book).

The code:

# Example 3-2 : Using Modeling Transformations

from pyglet.gl import *
from pyglet import window
from OpenGL.GLUT import *

win = window.Window()

def init():
    glClearColor (0.0, 0.0, 0.0, 0.0)
    glShadeModel (GL_FLAT)    

def draw_triangle():
    glBegin(GL_LINES)
    glVertex3f(50.0, 50.0, -2.0)
    glVertex3f(150.0, 50.0, -2.0)
    glVertex3f(150.0, 50.0, -2.0)
    glVertex3f(150.0, 150.0, -2.0)
    glVertex3f(150.0, 150.0, -2.0)
    glVertex3f(50.0, 50.0, -2.0)
    glEnd() 

def reshape (w, h):
    glViewport (0, 0, w, h)
    print w, h
    glMatrixMode (GL_PROJECTION)
    glLoadIdentity ()
    glFrustum (-150.0, 150.0, -150.0, 150.0, 1.0, 20.0)
    glMatrixMode (GL_MODELVIEW)

def display():
    glClear (GL_COLOR_BUFFER_BIT)
    glLoadIdentity()

    glColor3f(1.0, 1.0, 1.0)
    draw_triangle()                   # solid lines 
    glEnable(GL_LINE_STIPPLE)         # dashed lines 
    glLineStipple(1, 0xF0F0) 
    glLoadIdentity()
    glTranslatef(-20.0, 0.0, 0.0)
    draw_triangle()
    
    glLineStipple(1, 0xF00F)          #long dashed lines 
    glLoadIdentity()
    glScalef(1.5, 0.5, 1.0)
    draw_triangle()
    
    glLineStipple(1, 0x8888)          # dotted lines 
    glLoadIdentity()
    glRotatef (90.0, 0.0, 0.0, 1.0)
    draw_triangle ()
    glDisable (GL_LINE_STIPPLE);
    glFlush ()
 
init()

win.on_resize = reshape

while not win.has_exit:
    win.dispatch_events()
    win.clear()   
    display()      
    win.flip()

(As a side-note, I've used GL_LINES instead of GL_TRIANGLES to draw the triangles, so that the original glEnable(GL_LINE_STIPPLE) would remain unaltered).

Example 3-1 : Transformed Cube

I've made a small jump ahead and went on to chapter 3, "Viewing". Some code from chapter 2 will be posted here at a later date (it's just that that code resides on another system now).

This is the code that sets off Chapter 3:

# Example 3-1 : Transformed Cube

from pyglet.gl import *
from pyglet import window
from OpenGL.GLUT import *

win = window.Window()

def init():
    glClearColor (0.0, 0.0, 0.0, 0.0)
    glShadeModel (GL_FLAT)    

def reshape (w, h):
    glViewport (0, 0, w, h)
    glMatrixMode (GL_PROJECTION)
    glLoadIdentity ()
    glFrustum (-1.0, 1.0, -1.0, 1.0, 1.5, 20.0)
    glMatrixMode (GL_MODELVIEW)

def display():
    glClear (GL_COLOR_BUFFER_BIT)
    glColor3f (1.0, 1.0, 1.0)
    glLoadIdentity ()   # clear the matrix 
    # viewing transformation  
    gluLookAt (0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0)
    glScalef (1.0, 2.0, 1.0)      # modeling transformation  
    glutWireCube (1.0)
    glFlush ()

init()

win.on_resize = reshape

while not win.has_exit:
    win.dispatch_events()
    win.clear()
    display()
    win.flip()

As the GLUT library is not being wrapped in pyglet, we'll have to import it from within OpenGL (get it here). Mind that GLUT are but helper libraries (such as the famous teapot), and the pyglet people have good reasons not to include it in their module.

Also, with what has been learned in chapter 2 of the red book, a WireCube() function shouldn't be too hard to write.

Example 2-10 using Stride: another way to draw Elements

Instead of defining the vertex and colour arrays one by one, you can also define one large array holding (in this case) vertex and colour data. The data is then referenced by pointing to the different "starting points" within the array.
The parts in bold are changed from the previous 2-10 example.

Have a look at the code:

# Example 2-10 : Using glArrayElement() to Define Colors and Vertices

from pyglet.gl import *
from pyglet import window

win = window.Window()
    
def display():
    
    intertwined = [
        1.0, 0.2, 1.0, 100.0, 100.0, 0.0,
        1.0, 0.2, 0.2, 0.0, 200.0, 0.0,
        1.0, 1.0, 0.2, 100.0, 300.0, 0.0,
        0.2, 1.0, 0.2, 200.0, 300.0, 0.0,
        0.2, 1.0, 1.0, 300.0, 200.0, 0.0,
        0.2, 0.2, 1.0, 200.0, 100.0, 0.0]
    
    glEnableClientState (GL_COLOR_ARRAY)
    glEnableClientState (GL_VERTEX_ARRAY)
    
    glColorPointer (3, GL_FLOAT, 6 * sizeof(GLfloat), (GLfloat * len(intertwined))(*intertwined))
    glVertexPointer (3, GL_FLOAT, 6 * sizeof(GLfloat), (GLfloat * len(intertwined[3:]))(*intertwined[3:]))

    glBegin(GL_TRIANGLES)
    glArrayElement (2)
    glArrayElement (3)
    glArrayElement (5)
    glEnd()
    
def init():
    glClearColor (0.0, 0.0, 0.0, 0.0)
    glShadeModel (GL_FLAT)

while not win.has_exit:
    win.dispatch_events()
    win.clear()
    display()
    win.flip()

glVertexPointer() is being told that

• each vertex is composed of 3 coordinates
  
• the coordinates are of the type GL_FLOAT
  
• the next vertex is to be found at 6 * the size of a GL_FLOAT variable further on in the array
  
• the vertex data starts at the 4th element of the intertwined array.
  

Example 2-10 : Using glArrayElement() to Define Colors and Vertices

Vertex arrays! Huzzah, now I finally know what they mean.

The code goes like this:

# Example 2-10 : Using glArrayElement() to Define Colors and Vertices
# (Using vertices & colors variables defined in Example 2-9)

from pyglet.gl import *
from pyglet import window

win = window.Window()
    
def display():
    
    vertices = [25, 25,
                100, 325,
                175, 25,
                175, 325,
                250, 25,
                325, 325]
    colors =   [1.0, 0.2, 0.2,
                0.2, 0.2, 1.0,
                0.8, 1.0, 0.2,
                0.75, 0.75, 0.75,
                0.35, 0.35, 0.35,
                0.5, 0.5, 0.5]
    
    glEnableClientState (GL_COLOR_ARRAY)
    glEnableClientState (GL_VERTEX_ARRAY)
    
    glColorPointer (3, GL_FLOAT, 0, (GLfloat * len(colors))(*colors));
    glVertexPointer (2, GL_INT, 0, (GLint * len(vertices))(*vertices));

    glBegin(GL_TRIANGLES)
    glArrayElement (2)
    glArrayElement (3)
    glArrayElement (5)
    glEnd()
    
def init():
    glClearColor (0.0, 0.0, 0.0, 0.0)
    glShadeModel (GL_FLAT)

while not win.has_exit:
    win.dispatch_events()
    win.clear()
    display()
    win.flip()

glArrayElement() allows you to use a vertex predefined in an array via glVertexPointer(). An easy example, but it an important one, as vertex arrays allow us to drastically optimise our code by reducing the number of function calls.

Example 2-7: Marking Polygon Boundary Edges

An easy one this, especially since I now have learned how to create and pass suitable arrays to the gl*() functions.

Here's the code:

# Example 2-7 : Marking Polygon Boundary Edges

from pyglet.gl import *
from pyglet import window

# The OpenGL context is created only when you create a window. Any calls
# to OpenGL before a window is created will fail.
win = window.Window()
    
def display():
    # vertices undefined in example
    # adding a Z value of 1.0 (simply to remain in sync with the example, 
    # where glVertex3fv is called, 
    # i.e. 3 variables are required by the function
    
    v0 = [0.0, 0.0, 1.0]
    v1 = [100.0, 100.0, 1.0]
    v2 = [150.0, 50.0, 1.0]
    
    glPolygonMode(GL_FRONT_AND_BACK, GL_LINE)
    glBegin(GL_POLYGON)
    glEdgeFlag(GL_TRUE)
    glVertex3fv((GLfloat * len(v0))(*v0))
    glEdgeFlag(GL_FALSE)
    glVertex2fv((GLfloat * len(v1))(*v1))
    glEdgeFlag(GL_TRUE)  
    glVertex2fv((GLfloat * len(v2))(*v2))
    glEnd()
    
def init():
    glClearColor (0.0, 0.0, 0.0, 0.0)
    glShadeModel (GL_FLAT)

while not win.has_exit:
    win.dispatch_events()
    win.clear()
    display()
    win.flip()

One thing to note perhaps is that instead of passing the values directly, we have used a pointer to an array this time.