Archive for the ‘Developpement Jeux Videos’ Category


The Qt Web Runtime journey begins…

l y a peu, dès Qt 4.4 en réalité, Qt dispose de son wrapper autour de WebKit : Qt WebKit. Depuis, ce module est devenu l’un des plus utilisés de Qt ; en effet, utiliser du contenu Web est extrêmement demandé par le marché actuel. Dans les télévisions, les netbooks, les téléphones mobiles et bien d’autres périphériques domestiques, l’utilisation de l’Internet est absolument irremplaçable, l’application étant hébergée sur le Web. Il était donc temps de fournir une couche supplémentaire pour faciliter et sécuriser le développement d’applications basées sur le Web. D’où un nouveau projet pour les équipes de développement de Qt : le Qt Web Runtime, basé sur Qt et sur Qt WebKit, grâce auquel les applications Web deviendront plus facilement plus fonctionnelles.

L’un des objectifs de ce framework est de fournir un runtime Web basé sur les standards du W3C. Ainsi, vous pourrez facilement développer et déployer des applications Web sur des smartphones ou d’autres plateformes de la même manière qu’une application plus traditionnelle.

La fonctionnalité-clé ? Vous pouvez accéder au matériel (appareil photo ou accéléromètre, par exemple) et aux autres ressources de l’appareil (liste de contacts, messages…) via des API JavaScript.

En code, voici ce que donne l’accès à l’accéléromètre du périphérique :

var wrtSensors = nokia.device.load("sensors");
wrtSensors.startChannel(callback, "AccelerometerAxis", errorCallback);

function callback(data) {
       console.log("x-axis: " + data.axisX + " y-axis: " + data.axisY + " z-axis: " + data.axisZ);
}      

function errorCallback(err) {
       console.log("Ouch, " + err.message + "error code:" + err.code);
}

Il suffit de s’enregistrer aux notifications concernant l’accélération (soit le canal AccelerometerAxis) grâce à la méthode startChannel. Ensuite, vos fonctions de rappel sont utilisées chaque fois que le capteur reçoit un signal d’accélération.

Qt fonctionnant sur toute une série de plateformes, QWR fera de même et supportera toute une variété de plateformes. En tant que partie intégrante de Qt, cette technologie sera disponible ainsi que ses sources, selon le nouveau modèle de gouvernance (qui a notamment ouvert les repository de Qt sur Gitorious).

Ce framework est actuellement assez jeune et ne dispose pas encore de toutes les fonctionnalités qu’il devrait posséder à terme ni du support de nombreuses plateformes. Cependant, selon le modèle de contribution, chaque utilisateur pourra construire ce framework, grâce notamment à des retours dessus – vous aurez une place active dans son développement.

source FR : http://www.developpez.net/forums/d958542/c-cpp/bibliotheques/qt/voyage-qt-web-runtime-debute/

source EN :  http://labs.trolltech.com/blogs/2010/07/19/the-qt-web-runtime-journey-begins/




Scene papervision

Cet article portera sur la création d’une Scène Papervision 3D, l’ajout dans cette scène d’une camera , d’une sphère et des différents mouvements apportés à ces objets.
Tout d’abord il convient d’importer les principales classe de Papervision

import org.papervision3d.cameras.Camera3D;
import org.papervision3d.core.proto.MaterialObject3D;
import org.papervision3d.events.InteractiveScene3DEvent;
import org.papervision3d.materials.BitmapFileMaterial;
import org.papervision3d.materials.ColorMaterial;
import org.papervision3d.materials.utils.MaterialsList;
import org.papervision3d.objects.primitives.Cube;
import org.papervision3d.objects.primitives.Plane;
import org.papervision3d.objects.primitives.Sphere;
import org.papervision3d.render.BasicRenderEngine;
import org.papervision3d.scenes.Scene3D;
import org.papervision3d.view.Viewport3D;

puis on declarera : une vue (Viewport3D) , une camera (Camera3D) , un renderer (BasicRenderEngine), une sphere et un bitmapFileMaterial qui nous servira a texture la sphere.

public var scene:Scene3D;
public var vue:Viewport3D;
public var camera:Camera3D;
public var rendu:BasicRenderEngine;

private var s:Sphere;

private var Bmat1:BitmapFileMaterial;

Dans la scene , nous allons ajouter notre vue qui prend comme parametre la largeur et la hauteur de la vue , les deux autres parametres étant autoScaleToStage (la vue est redimensionnée pour être de la taille de la scène) et si elle est interactive

vue = new Viewport3D(900, 700,true, true);
addChild(vue);
vue.buttonMode = true;

scene = new Scene3D();
camera = new Camera3D();
rendu = new BasicRenderEngine();

ensuite nous allons créer la sphere et la texturer


// bitmap material
Bmat1 = new BitmapFileMaterial("terre-mars.jpg");
Bmat1.doubleSided = true;
Bmat1.interactive = true;

s = new Sphere(Bmat1,500,30,30);
scene.addChild(s);

s.x = 0;

// ici la camera est centrée sur la sphere
camera.lookAt(s);

camera.zoom = 1;
camera.focus = 10;

addEventListener(MouseEvent.MOUSE_WHEEL,onZoom,false,0,true);
s.addEventListener(InteractiveScene3DEvent.OBJECT_OVER,move1,false,0,true);

Enfin, nous devons initialiser le rendu final de la scene :

rendu.renderScene(scene, camera, vue);

puis dans un enter frame , nous pourrons faire tourner la sphere , et la camera zoomera sur la sphère

protected function renduScene():void
{

s.yaw(1);

if(camera.zoom <= 25)
{
camera.zoom = camera.zoom+0.1;

}
else
{

}

c.yaw(10);

}





OpenGL sur IPhone

Pour ce projet j’ai affiché un cube 3D en OpenGL et ajouté un évènement pour le faire tourner avec le doigt

tout d’abord nous allons déclarer la vue (taille de l’écran , couleur du fond…), la fonction sera setupView

const GLfloat zNear = 0.1, zFar = 1000.0, fieldOfView = 60.0;
GLfloat size;

glEnable(GL_DEPTH_TEST);
glMatrixMode(GL_PROJECTION);
size = zNear * tanf(DEGREES_TO_RADIANS(fieldOfView) / 2.0);

// Nous donne la taille de l'écran de l'iPhone
CGRect rect = self.bounds;
glFrustumf(-size, size, -size / (rect.size.width / rect.size.height), size / (rect.size.width / rect.size.height), zNear, zFar);
glViewport(0, 0, rect.size.width, rect.size.height);

glClearColor(0.0f, 0.0f, 0.0f, 1.0f);

a L’intiatlisation du programme on chargera la texture avec :

[self chargerTextures]; 

Chargement de la texture :

CGImageRef textureImage = [UIImage imageNamed:@"plaque.png"].CGImage;
if (textureImage == nil) {
NSLog(@"L'image n'a pas été chargée");
return;
}

Taille de la texture

NSInteger textureWidth = CGImageGetWidth(textureImage);
NSInteger textureHeight = CGImageGetHeight(textureImage);

Allocation de la mémoire


// allocation de la memoire
GLubyte *textureData = (GLubyte *)malloc(textureWidth * textureHeight * 4); // 4 car RVBA

Affichage avec OpenGL

CGContextRef textureContext = CGBitmapContextCreate(
textureData,
textureWidth,
textureHeight,
8, textureWidth * 4,
CGImageGetColorSpace(textureImage),
kCGImageAlphaPremultipliedLast);

CGContextDrawImage(textureContext,
CGRectMake(0.0, 0.0, (float)textureWidth, (float)textureHeight),
textureImage);

CGContextRelease(textureContext);

// Retour à OpenGL
glGenTextures(1, &textures[0]);
glBindTexture(GL_TEXTURE_2D, textures[0]);

glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, textureWidth, textureHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, textureData);

free(textureData);

glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glEnable(GL_TEXTURE_2D);

Nous allons ensuite afficher la vue , dans la méthode DrawView , nous aurons les cooredonnées des differetns vertices du cube :

const GLfloat cubeVertices[] = {

// face de devant
-1.0, 1.0, 1.0,
-1.0, -1.0, 1.0,
1.0, -1.0, 1.0,
1.0, 1.0, 1.0,

// haut
-1.0, 1.0, -1.0,
-1.0, 1.0, 1.0,
1.0, 1.0, 1.0,
1.0, 1.0, -1.0,

// arrière
1.0, 1.0, -1.