[JumpJack_]

Esistono?
Voglio dire, c'e' modo di disegnare un cubo rotante sullo schermo, senza dover riscrivere da zero l'algoritmo di cancellazione delle linee nascoste?!?

[madhacker]

cercavi qualcosa del genere??

#
# simplecube.py
#
# Copyright (c) 2006-2007 Nokia Corporation
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#	 http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#

import appuifw, sys, e32
from glcanvas import *
from gles import *
from key_codes import *

class SimpleCube:
  vertices = array(GL_BYTE, 3, (
	 [-1,  1,  1.0],
	 [ 1,  1,  1],
	 [ 1, -1,  1],
	 [-1, -1,  1],

	 [-1,  1, -1],
	 [ 1,  1, -1],
	 [ 1, -1, -1],
	 [-1, -1, -1]
	)
  )
  
  triangles = array(GL_UNSIGNED_BYTE, 3, (
	# front
	[1,0,3],
	[1,3,2],
	
	# right
	[2,6,5],
	[2,5,1],
	
	# back
	[7,4,5],
	[7,5,6],
	
	# left
	[0,4,7],
	[0,7,3],
	
	# top
	[5,4,0],
	[5,0,1],
	
	# bottom
	[3,7,6],
	[3,6,2]
	)
  )
  
  fanOne = array(GL_UNSIGNED_BYTE, 3, (
	[1,0,3],
	[1,3,2],
	[1,2,6],
	[1,6,5],
	[1,5,4],
	[1,4,0]
	)
  )
  fanTwo = array(GL_UNSIGNED_BYTE, 3, (
	[7,4,5],
	[7,5,6],
	[7,6,2],
	[7,2,3],
	[7,3,0],
	[7,0,4]
	)
  )
  
  colors = array(GL_UNSIGNED_BYTE, 4, (
	[0  ,255,  0,255],
	[0  ,  0,255,255],
	[0  ,255,  0,255],
	[255,  0,  0,255],

	[0  ,  0,255,255],
	[255,  0,  0,255],
	[0  ,  0,255,255],
	[0  ,255,  0,255]
  ))
  
  ETriangles=0
  ETriangleFans=1
  
  def __init__(self):
	"""Initializes OpenGL ES, sets the vertex and color arrays and pointers, 
and selects the shading mode."""
	
	# It's best to set these before creating the GL Canvas
	self.iDrawingMode=self.ETriangles
	self.iFrame=0
	self.exitflag = False
	self.render=0
	self.canvas = None
	
	self.old_body=appuifw.app.body
	try:
	  self.canvas=GLCanvas(redraw_callback=self.redraw, event_callback=self.event, resize_callback=self.resize)
	  appuifw.app.body=self.canvas
	except Exception,e:
	  appuifw.note(u"Exception: %s" % (e))
	  self.set_exit()
	  return
	
	# binds are exactly same as with normal Canvas objects
	self.canvas.bind(EKey1,lambda:self.FullScreen(0))
	self.canvas.bind(EKey2,lambda:self.FullScreen(1))
	self.canvas.bind(EKey3,lambda:self.FullScreen(2))
	
	appuifw.app.menu = [
	  (
		u"Shading mode",
		(
		  (u"Flat", self.FlatShading),
		  (u"Smooth", self.SmoothShading)
		)
	  ),
	  (
		u"Drawing mode",
		(
		  (u"Triangles", self.TriangleMode),
		  (u"Triangle fans", self.TriangleFanMode)
		)
	  ),
	  (
		u"Screen",
		(
		  (u"Normal", lambda:self.FullScreen(0)),
		  (u"Large", lambda:self.FullScreen(1)),
		  (u"Full", lambda:self.FullScreen(2)),
		)
	  ),
	  (u"Exit", self.set_exit)
	]
	
	try:
	  self.initgl()
	except Exception,e:
	  appuifw.note(u"Exception: %s" % (e))
	  self.set_exit()
	
  def event(self, ev):
	"""Event handler"""
	pass
  
  def resize(self):
	"""Resize handler"""
	# This may get called before the canvas is created, so check that the canvas exists
	if self.canvas:
	  glViewport(0, 0, self.canvas.size[0], self.canvas.size[1])
	  aspect = float(self.canvas.size[1]) / float(self.canvas.size[0])
	  glMatrixMode( GL_PROJECTION )
	  glLoadIdentity()
	  glFrustumf( -1.0, 1.0, -1.0*aspect, 1.0*aspect, 3.0, 1000.0 )
	
  def initgl(self):
	"""Initializes OpenGL and sets up the rendering environment"""
	# Set the screen background color. 
	glClearColor( 0.0, 0.0, 0.0, 1.0 )
	
	# Enable back face culling. 
	glEnable( GL_CULL_FACE  )
	
	# Initialize viewport and projection. 
	self.resize()
	
	glMatrixMode( GL_MODELVIEW )
	
	# Enable vertex arrays. 
	glEnableClientState( GL_VERTEX_ARRAY )
	
	# Set array pointers. 
	glVertexPointerb(self.vertices)
	
	# Enable color arrays.
	glEnableClientState( GL_COLOR_ARRAY )
	
	# Set color pointers. 
	glColorPointerub(self.colors )
	
	# Set the initial shading mode 
	glShadeModel( GL_FLAT )
	
	# Do not use perspective correction 
	glHint( GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST )
	self.render=1
	
  def FlatShading(self):
	"""Sets the GL shading model to flat."""
	glShadeModel( GL_FLAT )
	
  def SmoothShading(self):
	"""Sets the GL shading model to smooth."""
	glShadeModel( GL_SMOOTH )
	
  def TriangleMode(self):
	"""Sets the rendering mode to triangles."""
	self.iDrawingMode = self.ETriangles
	
  def TriangleFanMode(self):
	"""Sets the rendering mode to triangle fans."""
	self.iDrawingMode = self.ETriangleFans
	
  def FullScreen(self,mode):
	if mode == 0:
	  appuifw.app.screen = 'normal'
	elif mode == 1:
	  appuifw.app.screen = 'large'
	elif mode == 2:
	  appuifw.app.screen = 'full'
	
  def drawbox(self, aSizeX, aSizeY, aSizeZ):
	"""Draws a box with triangles or triangle fans depending on the current rendering mode.
Scales the box to the given size using glScalef."""
	glScalef( aSizeX, aSizeY, aSizeZ )
	
	if self.iDrawingMode == self.ETriangles:
	  glDrawElementsub( GL_TRIANGLES, self.triangles )
	elif self.iDrawingMode == self.ETriangleFans:
	  glDrawElementsub( GL_TRIANGLE_FAN, self.fanOne )
	  glDrawElementsub( GL_TRIANGLE_FAN, self.fanTwo )
  
  def redraw(self,frame):
	"""Draws and animates the objects.
The frame number determines the amount of rotation."""
	self.iFrame = frame
	
	if self.render == 0:
	  return
	glMatrixMode( GL_MODELVIEW )
	
	cameraDistance = 100
	glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT )
	
	# Animate and draw box
	glLoadIdentity()
	glTranslatex( 0 , 0 , -cameraDistance << 16 )
	glRotatex( self.iFrame << 16, 1 << 16,	0   ,	0	)
	glRotatex( self.iFrame << 15,	0   , 1 << 16,	0	)
	glRotatex( self.iFrame << 14,	0   ,	0   , 1 << 16 )
	self.drawbox( 15.0, 15.0, 15.0 )
	
  def close_canvas(self): # break reference cycles
	appuifw.app.body=self.old_body
	self.canvas=None
	self.draw=None
	appuifw.app.exit_key_handler=None
  
  def set_exit(self):
	self.exitflag = True
	
  def run(self):
	appuifw.app.exit_key_handler=self.set_exit
	while not self.exitflag:
	  self.canvas.drawNow()
	  e32.ao_sleep(0.0001)
	self.close_canvas()
	
appuifw.app.screen='full'
try:
  app=SimpleCube()
except Exception,e:
  appuifw.note(u'Exception: %s' % (e))
else:
  app.run()
  del app
#sys.exit(0)

questo è un'esempio che viene installato con l'installazione della scriptshell di python. spero faccia al caso tuo

[Il.Socio]

C'e' uno sviluppatore su Symbian-Freak che ha realizzato una libreria per la gestione delle OpenGL in python.
Afaik, al momento la libreria non e' ancora disponibile al pubblico, magari puoi provare a contattare aloy per richiedere l'accesso all'area developers...

Qui puoi vedere un video...

Per visualizzare questo link registrati o esegui il log in.

[JumpJack_]

grazie.
io ho trovato questo:

Per visualizzare questo link registrati o esegui il log in.