Re: How to draw a cube using indices ?

Maybe you need to use np.uint32 for the dtype of the index array.

Nicolas


> On 27 Nov 2015, at 16:20, Florian NICOLAS <florian.nicolas@ensta-bretagne=
.org> wrote:
> =

> Yes it works (ctypes.c_void_p(0) also works). =

> However, it seems that only half the cube is rendered. It is a bit strang=
e as my vertex and associated indices come from a tutorial.
> =

> =

> =

> -------------------------------------------------------------------------=
-----------------------------------------------
> NICOLAS Florian
> Ing=E9nieur =E9tudes amont - Service Etudes G=E9n=E9rales Sonar
> THALES Underwater Systems
> ENSTA Bretagne (ex-ENSIETA) - Promotion 2014 - Sp=E9cialit=E9 SPID (Syst=
=E8me Perception Information D=E9cision)
> Profil PSO (Perception et Syst=E8mes d'Observation)
> =

> ________________________________________
> De : Nicolas P. Rougier <[email protected]>
> Envoy=E9 : vendredi 27 novembre 2015 16:04
> =C0 : Florian NICOLAS
> Cc : [email protected]
> Objet : Re: [PyOpenGL-Users] How to draw a cube using indices ?
> =

> You've already bound your index buffer so you don't need to give it as ar=
gument.
> In your display function:
> =

> gl.glDrawElements(gl.GL_TRIANGLES, len(index), gl.GL_UNSIGNED_INT, index)
> =

> becomes
> =

> gl.glDrawElements(gl.GL_TRIANGLES, len(index), gl.GL_UNSIGNED_INT, None)
> =

> =

> =

> Nicolas
> =

> =

>> On 27 Nov 2015, at 14:57, Florian NICOLAS <florian.nicolas@ensta-bretagn=
e.org> wrote:
>> =

>> =

>> Hi everybody!
>> =

>> I recently started to learn OpenGL through Python thanks to several tuto=
rial (especially the Nicolas P. Rougier one: http://www.labri.fr/perso/nrou=
gier/teaching/opengl/).
>> =

>> I am now switching to 3D and I am trying to draw a cube.
>> =

>> Thus, I manage to get some triangles which do not render a cube (this se=
ems to be normal as I do not duplicate my vertices and I use the glDrawArra=
ys function).
>> =

>> However, after, I build an index "vector" to further use the glDrawEleme=
nts function to render my cube. As a result, I do not get any error but not=
hing appears on screen.
>> =

>> I hope you could be of some help!
>> =

>> Thanks.
>> =

>> Here is my code:
>> =

>> #! /usr/bin/env python
>> # -*- coding: utf-8 -*-
>> =

>> import sys
>> import ctypes
>> import numpy as np
>> import OpenGL.GL as gl
>> import OpenGL.GLUT as glut
>> =

>> vertex_code =3D """
>> =

>>    uniform float scale;
>>    uniform mat4 matCam;
>>    attribute vec4 color;
>>    attribute vec3 position;
>>    varying vec4 v_color;
>>    void main()
>>    {
>>        gl_Position =3D matCam*vec4(scale*position, 1.0);
>>        v_color =3D color;
>>    } """
>> =

>> fragment_code =3D """
>>    varying vec4 v_color;
>>    void main()
>>    {
>>        gl_FragColor =3D v_color;
>>    } """
>> =

>> def display():
>>    gl.glClear(gl.GL_COLOR_BUFFER_BIT)
>>    #gl.glDrawArrays(gl.GL_TRIANGLES, 0, 12)
>>    gl.glDrawElements(gl.GL_TRIANGLES, len(index), gl.GL_UNSIGNED_INT, in=
dex) # render nothing (i.e. only the background color)
>>    glut.glutSwapBuffers()
>> =

>> def reshape(width,height):
>>    gl.glViewport(0, 0, width, height)
>> =

>> def keyboard( key, x, y ):
>>    if key =3D=3D '\033':
>>        sys.exit( )
>> =

>> def timer(fps):
>>    global clock
>>    clock +=3D 0.0005*1000.0/fps
>>    print(clock)
>> #    eye =3D np.array([0,0,1])
>> #    center =3D np.array([0,clock,0])
>> #    up =3D np.array([0,1,0])
>> #    mat =3D computeLookAtMatrix(eye, center, up)
>>    theta =3D clock;
>>    mat =3D np.array([[np.cos(theta), 0, np.sin(theta), 0],
>>                [0, 1, 0, 0],
>>                [-np.sin(theta), 0, np.cos(theta), 0],
>>                [0, 0, 0, 1]])
>>    loc =3D gl.glGetUniformLocation(program, "matCam")
>>    gl.glUniformMatrix4fv(loc, 1, False, mat)
>> =

>> =

>> =

>>    glut.glutTimerFunc(1000/fps, timer, fps)
>>    glut.glutPostRedisplay()
>> =

>> =

>> # GLUT init
>> # --------------------------------------
>> glut.glutInit()
>> glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGBA)
>> glut.glutCreateWindow('Hello world!')
>> glut.glutReshapeWindow(512,512)
>> glut.glutReshapeFunc(reshape)
>> glut.glutDisplayFunc(display)
>> glut.glutKeyboardFunc(keyboard)
>> glut.glutTimerFunc(1000/60, timer, 60)
>> =

>> # Build data
>> # --------------------------------------
>> data =3D np.zeros(8, [("position", np.float32, 3),
>>                    ("color",    np.float32, 4)])
>> =

>> data['color']    =3D [ (1,0,0,1), (0,1,0,1), (0,0,1,1), (1,1,0,1),
>>                    (1,0,0,1), (0,1,0,1), (0,0,1,1), (1,1,0,1) ]
>> =

>> data['position'] =3D [ (-1,-1,1),
>>                     (1,-1,1),
>>                        (1,1,1),
>>                        (-1,1,1),
>>                        (-1,-1,-1),
>>                        (1,-1,-1),
>>                        (1,1,-1),
>>                        (-1,1,-1)]
>> =

>> index =3D np.array([0,1,2,
>>                2,3,0,
>>                1,5,6,
>>                6,2,1,
>>                7,6,5,
>>                5,4,7,
>>                4,0,3,
>>                3,7,4,
>>                4,5,1,
>>                1,0,4,
>>                3,2,6,
>>                6,7,3])
>> =

>> # Build & activate program
>> # --------------------------------------
>> =

>> # Request a program and shader slots from GPU
>> program  =3D gl.glCreateProgram()
>> vertex   =3D gl.glCreateShader(gl.GL_VERTEX_SHADER)
>> fragment =3D gl.glCreateShader(gl.GL_FRAGMENT_SHADER)
>> =

>> # Set shaders source
>> gl.glShaderSource(vertex, vertex_code)
>> gl.glShaderSource(fragment, fragment_code)
>> =

>> # Compile shaders
>> gl.glCompileShader(vertex)
>> gl.glCompileShader(fragment)
>> =

>> # Attach shader objects to the program
>> gl.glAttachShader(program, vertex)
>> gl.glAttachShader(program, fragment)
>> =

>> # Build program
>> gl.glLinkProgram(program)
>> =

>> # Get rid of shaders (no more needed)
>> gl.glDetachShader(program, vertex)
>> gl.glDetachShader(program, fragment)
>> =

>> # Make program the default program
>> gl.glUseProgram(program)
>> =

>> =

>> # Build buffer
>> # --------------------------------------
>> =

>> # Request a buffer slot from GPU
>> buffer =3D gl.glGenBuffers(1)
>> =

>> # Make this buffer the default one
>> gl.glBindBuffer(gl.GL_ARRAY_BUFFER, buffer)
>> =

>> # Upload data
>> gl.glBufferData(gl.GL_ARRAY_BUFFER, data.nbytes, data, gl.GL_DYNAMIC_DRA=
W)
>> =

>> # same for index buffer
>> buffer_index=3D gl.glGenBuffers(1)
>> gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, buffer_index)
>> gl.glBufferData(gl.GL_ELEMENT_ARRAY_BUFFER, index.nbytes, index, gl.GL_S=
TATIC_DRAW)
>> =

>> =

>> # Bind attributes
>> # --------------------------------------
>> stride =3D data.strides[0]
>> offset =3D ctypes.c_void_p(0)
>> loc =3D gl.glGetAttribLocation(program, "position")
>> gl.glEnableVertexAttribArray(loc)
>> gl.glBindBuffer(gl.GL_ARRAY_BUFFER, buffer)
>> gl.glVertexAttribPointer(loc, 3, gl.GL_FLOAT, False, stride, offset)
>> =

>> offset =3D ctypes.c_void_p(data.dtype["position"].itemsize)
>> loc =3D gl.glGetAttribLocation(program, "color")
>> gl.glEnableVertexAttribArray(loc)
>> gl.glBindBuffer(gl.GL_ARRAY_BUFFER, buffer)
>> gl.glVertexAttribPointer(loc, 4, gl.GL_FLOAT, False, stride, offset)
>> =

>> gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, buffer_index)
>> =

>> # Bind uniforms
>> # --------------------------------------
>> loc =3D gl.glGetUniformLocation(program, "scale")
>> gl.glUniform1f(loc, 0.5)
>> clock =3D 0
>> =

>> loc =3D gl.glGetUniformLocation(program, "matCam")
>> print(loc)
>> gl.glUniformMatrix4fv(loc, 1, False, np.eye(4))
>> =

>> # Enter mainloop
>> # --------------------------------------
>> glut.glutMainLoop()
>> ------------------------------------------------------------------------=
------
>> _______________________________________________
>> PyOpenGL Homepage
>> http://pyopengl.sourceforge.net
>> _______________________________________________
>> PyOpenGL-Users mailing list
>> [email protected]
>> https://lists.sourceforge.net/lists/listinfo/pyopengl-users
> =

> =

> -------------------------------------------------------------------------=
-----
> _______________________________________________
> PyOpenGL Homepage
> http://pyopengl.sourceforge.net
> _______________________________________________
> PyOpenGL-Users mailing list
> [email protected]
> https://lists.sourceforge.net/lists/listinfo/pyopengl-users


---------------------------------------------------------------------------=
---
_______________________________________________
PyOpenGL Homepage
http://pyopengl.sourceforge.net