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