voilà comment on fait communiquer le moteur graphique entre la partie c++ et la partie javascript.

hé oui ça marche comme un vieux émulateur console

---------------------------------------------------------------- punkModule.js:1719:16
CPP MODULE CREATE GRAPHICS BUFFER POINTERS --------------------- punkModule.js:1719:16
---------------------------------------------------------------- punkModule.js:1719:16
---- textures updates bools : punkModule.js:1719:16
addr 0x179c0 : 8 bytes punkModule.js:1719:16
----- textures pointers : punkModule.js:1719:16
addr 0x179c8 : 16384 bytes punkModule.js:1719:16
addr 0x1b9c8 : 16384 bytes punkModule.js:1719:16
addr 0x1f9c8 : 16384 bytes punkModule.js:1719:16
addr 0x239c8 : 16384 bytes punkModule.js:1719:16
addr 0x279c8 : 16384 bytes punkModule.js:1719:16
addr 0x2b9c8 : 16384 bytes punkModule.js:1719:16
addr 0x2f9c8 : 16384 bytes punkModule.js:1719:16
addr 0x339c8 : 16384 bytes punkModule.js:1719:16
---- renderTarget info pointers : punkModule.js:1719:16
addr 0x379c8 : 4 bytes punkModule.js:1719:16
addr 0x379cc : 4 bytes punkModule.js:1719:16
addr 0x379d0 : 4 bytes punkModule.js:1719:16
addr 0x379d4 : 4 bytes punkModule.js:1719:16
---- palette 256 32 bit colors : punkModule.js:1719:16
addr 0x379d8 : 1024 bytes punkModule.js:1719:16
---- tilemap 1 32x32x4 bytes : punkModule.js:1719:16
addr 0x37dd8 : 4096 bytes punkModule.js:1719:16
---- tilemap 2 32x32x4 bytes : punkModule.js:1719:16
addr 0x38dd8 : 4096 bytes punkModule.js:1719:16
---- tilemap 1 X Y : punkModule.js:1719:16
addr 0x39dd8 : 4 bytes punkModule.js:1719:16
---- tilemap 2 X Y : punkModule.js:1719:16
addr 0x39ddc : 4 bytes punkModule.js:1719:16
---- tilemap 1 scanlines : punkModule.js:1719:16
addr 0x39de0 : 1024 bytes punkModule.js:1719:16
---- tilemap 2 scanlines : punkModule.js:1719:16
addr 0x3a1e0 : 1024 bytes punkModule.js:1719:16
---- spriteram 1 xy : punkModule.js:1719:16
addr 0x3a5e0 : 512 bytes punkModule.js:1719:16
---- spriteram 1 info : punkModule.js:1719:16
addr 0x3a7e0 : 512 bytes punkModule.js:1719:16
---- spriteram 2 xy : punkModule.js:1719:16
addr 0x3a9e0 : 1024 bytes punkModule.js:1719:16
---- spriteram 2 info : punkModule.js:1719:16
addr 0x3ade0 : 1024 bytes punkModule.js:1719:16
last address 0x3b1e0 punkModule.js:1719:16
---------------------------------------------------------------- punkModule.js:1719:16
CPP MODULE GRAPHICS BUFFER POINTERS CREATED -------------------- punkModule.js:1719:16
---------------------------------------------------------------- punkModule.js:1719:16
INITIALIZE MODULE TEST punkModule.js:1719:16
Uncompress texture 0 punkModule.js:1719:16
update texture 0 in module ram punkModule.js:1719:16
Module SCREEN DATA BUFFER: punkModule.js:1719:16
INIT PUNK PATTERN punkModule.js:1719:16
IS MODULE INITIALIZED HERE ? main.js:34:13

je vais motiver tout le forum à travailler dans les jeux vidéo

voilà le test d'affichage passionnant que je vais me farcir pendant une semaine

vous pourriez m'encourager bordel

je souffre

maintenant je dois traduire cette classe en cpp


// debug class to test a tilesheet texture display
// colors indexes are displayed with grayscale
// doesn't create any texture
// display with top-left coords logic

// -----------------------------------------------------------------------------
// CLASS DECLARATION
// -----------------------------------------------------------------------------

function PPU_TilesheetTester()
{
this.build();
return this;
}

// -----------------------------------------------------------------------------
// STATIC PROPS
// -----------------------------------------------------------------------------

// context

PPU_TilesheetTester.CONTEXT3D = null;
PPU_TilesheetTester.CRASHED = false;

// static initialized

PPU_TilesheetTester.INITIALIZED = false;

// instance index

PPU_TilesheetTester.NUM_INSTANCES = 0;

// vertex shader

PPU_TilesheetTester.VERTEX_SHADER_SOURCE = `

attribute vec4 aVertXY;
attribute vec2 aVertUV;

varying highp vec2 vUV;

void main(void)
{
vUV = aVertUV;
gl_Position = aVertXY;
}

`;
PPU_TilesheetTester.VERTEX_SHADER_ID = 0;

// fragment shader

PPU_TilesheetTester.FRAGMENT_SHADER_SOURCE = `

varying highp vec2 vUV;

uniform sampler2D uTexture;

highp float a;

void main()
{
a = texture2D( uTexture, vUV ).a;
gl_FragColor = vec4(a,a,a,1) ;
}
`;
PPU_TilesheetTester.FRAGMENT_SHADER_ID = 0;

// shader program

PPU_TilesheetTester.SHADER_PROGRAM_ID = 0;

// locations

PPU_TilesheetTester.XY_ATTRIB_LOCATION = 0;
PPU_TilesheetTester.UV_ATTRIB_LOCATION = 0;
PPU_TilesheetTester.TEXTURE_UNIFORM_LOCATION = 0;


// -----------------------------------------------------------------------------
// STATIC METHODS
// -----------------------------------------------------------------------------

PPU_TilesheetTester.Init = function ( gl )
{
PPU_TilesheetTester.CONTEXT3D = gl;

console.log('PPU_TilesheetTester static shader compilation -----------------');

// compile vertex shader

PPU_TilesheetTester.VERTEX_SHADER_ID = gl.createShader(gl.VERTEX_SHADER);
gl.shaderSource(PPU_TilesheetTester.VERTEX_SHADER_ID,PPU_TilesheetTester.VERTEX_SHADER_SOURCE);
gl.compileShader(PPU_TilesheetTester.VERTEX_SHADER_ID);

// compile error
if (!gl.getShaderParameter(PPU_TilesheetTester.VERTEX_SHADER_ID, gl.COMPILE_STATUS)) {
alert('PPU_TilesheetTester compile vertex shader error: ' + gl.getShaderInfoLog(PPU_TilesheetTester.VERTEX_SHADER_ID));
gl.deleteShader(PPU_TilesheetTester.VERTEX_SHADER_ID); // AJOUTER CA DANS LE CPP !!!
PPU_TilesheetTester.CRASHED = true;
return false;
}
else
{
console.log("PPU_TilesheetTester vertex shader compiled.");
}

// compile fragment shader

PPU_TilesheetTester.FRAGMENT_SHADER_ID = gl.createShader(gl.FRAGMENT_SHADER);
gl.shaderSource(PPU_TilesheetTester.FRAGMENT_SHADER_ID,PPU_TilesheetTester.FRAGMENT_SHADER_SOURCE);
gl.compileShader(PPU_TilesheetTester.FRAGMENT_SHADER_ID);

// compile error
if (!gl.getShaderParameter(PPU_TilesheetTester.FRAGMENT_SHADER_ID, gl.COMPILE_STATUS)) {
alert('PPU_TilesheetTester compile fragment shader error: ' + gl.getShaderInfoLog(PPU_TilesheetTester.FRAGMENT_SHADER_ID));
gl.deleteShader(PPU_TilesheetTester.FRAGMENT_SHADER_ID); // AJOUTER CA DANS LE CPP !!!
PPU_TilesheetTester.CRASHED = true;
return false;
}
else
{
console.log("PPU_TilesheetTester fragment shader compiled");
}

// link the program shader

PPU_TilesheetTester.SHADER_PROGRAM_ID = gl.createProgram();
gl.attachShader(PPU_TilesheetTester.SHADER_PROGRAM_ID,PPU_TilesheetTester.VERTEX_SHADER_ID);
gl.attachShader(PPU_TilesheetTester.SHADER_PROGRAM_ID,PPU_TilesheetTester.FRAGMENT_SHADER_ID);
gl.linkProgram(PPU_TilesheetTester.SHADER_PROGRAM_ID);

// compile error
if (!gl.getProgramParameter(PPU_TilesheetTester.SHADER_PROGRAM_ID, gl.LINK_STATUS)) {
alert('PPU_TilesheetTester link shaders program error: ' + gl.getProgramInfoLog(PPU_TilesheetTester.SHADER_PROGRAM_ID));
gl.deleteShader(PPU_TilesheetTester.VERTEX_SHADER_ID); // AJOUTER CA DANS LE CPP !!!
gl.deleteShader(PPU_TilesheetTester.FRAGMENT_SHADER_ID); // AJOUTER CA DANS LE CPP !!!
PPU_TilesheetTester.CRASHED = true;
return false;
}
else
{
console.log("PPU_TilesheetTester shader programs linked");
}

// get locations

PPU_TilesheetTester.XY_ATTRIB_LOCATION = gl.getAttribLocation(PPU_TilesheetTester.SHADER_PROGRAM_ID,"aVertXY");
PPU_TilesheetTester.UV_ATTRIB_LOCATION = gl.getAttribLocation(PPU_TilesheetTester.SHADER_PROGRAM_ID,"aVertUV");
PPU_TilesheetTester.TEXTURE_UNIFORM_LOCATION = gl.getUniformLocation(PPU_TilesheetTester.SHADER_PROGRAM_ID,"uTexture");

// bool

PPU_TilesheetTester.INITIALIZED = true;
};

PPU_TilesheetTester.ShutDown = function ()
{
if (!PPU_TilesheetTester.CRASHED && PPU_TilesheetTester.INITIALIZED)
{
const gl = PPU_TilesheetTester.CONTEXT3D;
gl.detachShader(PPU_TilesheetTester.SHADER_PROGRAM_ID,PPU_TilesheetTester.VERTEX_SHADER_ID);
gl.detachShader(PPU_TilesheetTester.SHADER_PROGRAM_ID,PPU_TilesheetTester.FRAGMENT_SHADER_ID);
gl.deleteShader(PPU_TilesheetTester.VERTEX_SHADER_ID);
gl.deleteShader(PPU_TilesheetTester.FRAGMENT_SHADER_ID);
console.log("PPU_TilesheetTester shaders deleted");
}

// bool

PPU_TilesheetTester.INITIALIZED = false;
};

// -----------------------------------------------------------------------------
// INSTANCE PROPS
// -----------------------------------------------------------------------------

PPU_TilesheetTester.m_instanceIndex = 0;

// vertexbuffer arrays

PPU_TilesheetTester.prototype.m_SheetXY = new Float32Array([ -1,-1, 1,-1, 1, 1, -1, 1 ]);
PPU_TilesheetTester.prototype.m_SheetXY_buffer_id = 0;

PPU_TilesheetTester.prototype.m_SheetUV = new Float32Array([ 0, 1, 1, 1, 1, 0, 0, 0 ]);
PPU_TilesheetTester.prototype.m_SheetUV_buffer_id = 0;

PPU_TilesheetTester.prototype.m_SheetIDS = new Uint16Array([0,1,2,2,3,0]);
PPU_TilesheetTester.prototype.m_SheetIDS_buffer_id = 0;

// -----------------------------------------------------------------------------
// INSTANCE METHODS
// -----------------------------------------------------------------------------

PPU_TilesheetTester.prototype.build = function()
{
// do nothing if not init

if (!PPU_TilesheetTester.INITIALIZED)
{
return;
}

// instance index

this.m_instanceIndex = PPU_TilesheetTester.NUM_INSTANCES;
PPU_TilesheetTester.NUM_INSTANCES++;

// cache context

const gl = PPU_TilesheetTester.CONTEXT3D;

// vertex buffers allocation (take habit to make it instance, not static)

this.m_SheetXY_buffer_id = gl.createBuffer();
gl.bindBuffer(gl.ARRAY_BUFFER, this.m_SheetXY_buffer_id);
gl.bufferData(gl.ARRAY_BUFFER, this.m_SheetXY, gl.STATIC_DRAW);

this.m_SheetUV_buffer_id = gl.createBuffer();
gl.bindBuffer(gl.ARRAY_BUFFER, this.m_SheetUV_buffer_id);
gl.bufferData(gl.ARRAY_BUFFER, this.m_SheetUV, gl.STATIC_DRAW);

this.m_SheetIDS_buffer_id = gl.createBuffer();
gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, this.m_SheetIDS_buffer_id);
gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, this.m_SheetIDS, gl.STATIC_DRAW);

console.log(" PPU_TilesheetTester instance "+this.m_instanceIndex+" vertices buffers created");
};

PPU_TilesheetTester.prototype.delete = function()
{
// do nothing if not init

if (!PPU_TilesheetTester.INITIALIZED)
{
console.log('TilesheetTester not initialized');
return;
}

// cache context

const gl = PPU_TilesheetTester.CONTEXT3D;

// delete verts buffers

gl.deleteBuffer(this.m_SheetXY_buffer_id);
gl.deleteBuffer(this.m_SheetUV_buffer_id);
gl.deleteBuffer(this.m_SheetIDS_buffer_id);

console.log(" PPU_TilesheetTester instance "+this.m_instanceIndex+" vertices buffers deleted");

};

PPU_TilesheetTester.prototype.drawCall = function ( texture, x, y )
{
// do nothing if not init

if (!PPU_TilesheetTester.INITIALIZED)
{
return;
}

// cache context

const gl = PPU_TilesheetTester.CONTEXT3D;

// update XY coords in function of x y sW sH

const tW = PPU.TILESHEET_WIDTH;
const tH = PPU.TILESHEET_HEIGHT;
const sW = PPU.SCREEN_WIDTH;
const sH = PPU.SCREEN_HEIGHT;

const w = 2 * tW / sW;
const h = 2 * tH / sH;
x = w-1 + 2*x/sW; // 2d coords system (y to down)
y = h-1 + 2*y/sH;

this.m_SheetXY[0]=-w + x;
this.m_SheetXY[1]= 0 - y;

this.m_SheetXY[2]= 0 + x;
this.m_SheetXY[3]= 0 - y;

this.m_SheetXY[4]= 0 + x;
this.m_SheetXY[5]= h - y;

this.m_SheetXY[6]=-w + x;
this.m_SheetXY[7]= h - y;

gl.bindBuffer(gl.ARRAY_BUFFER, this.m_SheetXY_buffer_id);
gl.bufferData(gl.ARRAY_BUFFER, this.m_SheetXY, gl.STATIC_DRAW);

// NOW DRAW ON SCREEN ------------------------------------------------------

gl.bindFramebuffer(gl.FRAMEBUFFER, null);
gl.viewport(0, 0, PPU.SCREEN_WIDTH, PPU.SCREEN_HEIGHT);

// select shader program

gl.useProgram(PPU_TilesheetTester.SHADER_PROGRAM_ID);

// bind textures

gl.activeTexture(gl.TEXTURE0);
gl.bindTexture(gl.TEXTURE_2D,texture);
gl.uniform1i(PPU_TilesheetTester.TEXTURE_UNIFORM_LOCATION,0);

// bind vertices

gl.bindBuffer(gl.ARRAY_BUFFER, this.m_SheetXY_buffer_id );
gl.vertexAttribPointer(PPU_TilesheetTester.XY_ATTRIB_LOCATION, 2, gl.FLOAT, false, 0, 0);
gl.enableVertexAttribArray(PPU_TilesheetTester.XY_ATTRIB_LOCATION);

gl.bindBuffer(gl.ARRAY_BUFFER, this.m_SheetUV_buffer_id );
gl.vertexAttribPointer(PPU_TilesheetTester.UV_ATTRIB_LOCATION, 2, gl.FLOAT, false, 0, 0);
gl.enableVertexAttribArray(PPU_TilesheetTester.UV_ATTRIB_LOCATION);

gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER,this.m_SheetIDS_buffer_id);

// draw

gl.disable(gl.BLEND);
gl.drawElements(gl.TRIANGLES, 6, gl.UNSIGNED_SHORT, 0);

// free attrib arrays (i don't know if it's usefule here but this should be added to other classes)

gl.disableVertexAttribArray(PPU_TilesheetTester.XY_ATTRIB_LOCATION);
gl.disableVertexAttribArray(PPU_TilesheetTester.UV_ATTRIB_LOCATION);

};

Auto-édit :
ça vous intéresse tous ces maths ?

moi non plus

je m'éclate grave



#ifndef PPU_TILESHEETTESTER_H
#define PPU_TILESHEETTESTER_H

#include "PPU.h"
#include <GL/glew.h>

class PPU_TilesheetTester
{
public:

// -----------------------------------------------------------------------------
// STATIC PROPS
// -----------------------------------------------------------------------------


// -----------------------------------------------------------------------------
// STATIC METHODS
// -----------------------------------------------------------------------------


// -----------------------------------------------------------------------------
// INSTANCE PROPS
// -----------------------------------------------------------------------------


// -----------------------------------------------------------------------------
// INSTANCE METHODS
// -----------------------------------------------------------------------------


PPU_TilesheetTester();
virtual ~PPU_TilesheetTester();

protected:

private:
};

#endif // PPU_TILESHEETTESTER_H

Putain je suis pressé de finir ce moteur graphique de merde.

Y'a un moment j'aimerais bien coder du gameplay.

putain ce job c'est le supplice de Sisyphe

Pourquoi reprogrammer un moteur graphique éco+ alors qu'il y a déjà tout ce qu'il faut de disponible ? Tu as déjà des idées de jeux qui ne vont pas bider ?

putain j'en ai marre