Something went wrong. Try again.
the game where you go into mines and start crafting! but for consoles (forked directly from smartcmd's github)
Something went wrong. Try again.
32 kB · 1080 lines
C++
at main
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080#include "stdafx.h"#include "Tesselator.h"#include "..\Minecraft.World\BasicTypeContainers.h"#include "..\Minecraft.World\FloatBuffer.h"#include "..\Minecraft.World\IntBuffer.h"#include "..\Minecraft.World\ByteBuffer.h"
bool Tesselator::TRIANGLE_MODE = false;bool Tesselator::USE_VBO = false;
/* Things to check we are intialising in the constructor...
double u, v;int col;int mode;double xo, yo, zo;int normal;
*/DWORD Tesselator::tlsIdx = TlsAlloc();
Tesselator *Tesselator::getInstance(){ return (Tesselator *)TlsGetValue(tlsIdx);}
void Tesselator::CreateNewThreadStorage(int bytes){ Tesselator *instance = new Tesselator(bytes/4); TlsSetValue(tlsIdx, instance);}
Tesselator::Tesselator(int size){ // 4J - this block of things moved to constructor from general initialisations round Java class vertices = 0; hasColor = false; hasTexture = false; hasTexture2 = false; hasNormal = false; p = 0; count = 0; _noColor = false; tesselating = false; vboMode = false; vboId = 0; vboCounts = 10;
// 4J - adding these things to constructor just to be sure that they are initialised with something u = v = 0; col = 0; mode = 0; xo = yo = zo = 0; xoo = yoo = zoo = 0; // 4J added _normal = 0;
useCompactFormat360 = false; // 4J added mipmapEnable = true; // 4J added useProjectedTexturePixelShader = false; // 4J added
this->size = size;
_array = new intArray(size);
vboMode = USE_VBO; // 4J removed - && GLContext.getCapabilities().GL_ARB_vertex_buffer_object; if (vboMode) { vboIds = MemoryTracker::createIntBuffer(vboCounts); ARBVertexBufferObject::glGenBuffersARB(vboIds); }
#ifdef __PSVITA__ // AP - alpha cut out is expensive on vita. Use this to defer primitives that use icons with alpha alphaCutOutEnabled = false;
// this is the cut out enabled vertex array _array2 = new intArray(size); vertices2 = 0; p2 = 0;#endif}
Tesselator *Tesselator::getUniqueInstance(int size){ return new Tesselator(size);}
void Tesselator::end(){// if (!tesselating) throw new IllegalStateException("Not tesselating!"); // 4J - removed tesselating = false;#ifdef __PSVITA__ // AP - alpha cut out is expensive on vita. Check both counts for valid vertices if( vertices > 0 || vertices2 > 0 )#else if (vertices > 0)#endif { // 4J - a lot of stuff taken out here for fiddling round with enable client states etc. // that don't matter for our renderer if (!hasColor) { // 4J - TEMP put in fixed vertex colors if we don't have any, until we have a shader that can cope without them unsigned int *pColData = (unsigned int *)_array->data; pColData += 5; for( int i = 0; i < vertices; i++ ) { *pColData = 0xffffffff; pColData += 8; }#ifdef __PSVITA__ // AP - alpha cut out is expensive on vita. Check both counts for valid vertices pColData = (unsigned int *)_array2->data; pColData += 5; for( int i = 0; i < vertices2; i++ ) { *pColData = 0xffffffff; pColData += 8; }#endif } if (mode == GL_QUADS && TRIANGLE_MODE) { // glDrawArrays(GL_TRIANGLES, 0, vertices); // 4J - changed for xbox#ifdef _XBOX RenderManager.DrawVertices(D3DPT_TRIANGLELIST,vertices,_array->data, useCompactFormat360?C4JRender::VERTEX_TYPE_PS3_TS2_CS1:C4JRender::VERTEX_TYPE_PF3_TF2_CB4_NB4_XW1, useProjectedTexturePixelShader?C4JRender::PIXEL_SHADER_TYPE_PROJECTION:C4JRender::PIXEL_SHADER_TYPE_STANDARD);#else RenderManager.DrawVertices(C4JRender::PRIMITIVE_TYPE_TRIANGLE_LIST,vertices,_array->data, useCompactFormat360?C4JRender::VERTEX_TYPE_COMPRESSED:C4JRender::VERTEX_TYPE_PF3_TF2_CB4_NB4_XW1, useProjectedTexturePixelShader?C4JRender::PIXEL_SHADER_TYPE_PROJECTION:C4JRender::PIXEL_SHADER_TYPE_STANDARD);#endif } else {// glDrawArrays(mode, 0, vertices); // 4J - changed for xbox // For compact vertices, the vertexCount has to be calculated from the amount of data written, as // we insert extra fake vertices to encode supplementary data for more awkward quads that have non // axis aligned UVs (eg flowing lava/water)#ifdef _XBOX int vertexCount = vertices; if( useCompactFormat360 ) { vertexCount = p / 2; RenderManager.DrawVertices((D3DPRIMITIVETYPE)mode,vertexCount,_array->data,C4JRender::VERTEX_TYPE_PS3_TS2_CS1, C4JRender::PIXEL_SHADER_TYPE_STANDARD); } else { if( useProjectedTexturePixelShader ) { RenderManager.DrawVertices((D3DPRIMITIVETYPE)mode,vertexCount,_array->data,C4JRender::VERTEX_TYPE_PF3_TF2_CB4_NB4_XW1_TEXGEN, C4JRender::PIXEL_SHADER_TYPE_PROJECTION); } else { RenderManager.DrawVertices((D3DPRIMITIVETYPE)mode,vertexCount,_array->data,C4JRender::VERTEX_TYPE_PF3_TF2_CB4_NB4_XW1, C4JRender::PIXEL_SHADER_TYPE_STANDARD); } }#else int vertexCount = vertices; if( useCompactFormat360 ) {#ifdef __PSVITA__ // AP - alpha cut out is expensive on vita. Render non-cut out stuff first then send the cut out stuff if( vertexCount ) { RenderManager.DrawVertices((C4JRender::ePrimitiveType)mode,vertexCount,_array->data,C4JRender::VERTEX_TYPE_COMPRESSED, C4JRender::PIXEL_SHADER_TYPE_STANDARD); } if( vertices2 ) { RenderManager.DrawVerticesCutOut((C4JRender::ePrimitiveType)mode,vertices2,_array2->data,C4JRender::VERTEX_TYPE_COMPRESSED, C4JRender::PIXEL_SHADER_TYPE_STANDARD); }#else
RenderManager.DrawVertices((C4JRender::ePrimitiveType)mode,vertexCount,_array->data,C4JRender::VERTEX_TYPE_COMPRESSED, C4JRender::PIXEL_SHADER_TYPE_STANDARD);#endif } else { if( useProjectedTexturePixelShader ) { RenderManager.DrawVertices((C4JRender::ePrimitiveType)mode,vertexCount,_array->data,C4JRender::VERTEX_TYPE_PF3_TF2_CB4_NB4_XW1_TEXGEN, C4JRender::PIXEL_SHADER_TYPE_PROJECTION); } else { RenderManager.DrawVertices((C4JRender::ePrimitiveType)mode,vertexCount,_array->data,C4JRender::VERTEX_TYPE_PF3_TF2_CB4_NB4_XW1, C4JRender::PIXEL_SHADER_TYPE_STANDARD); } }#endif } glDisableClientState(GL_VERTEX_ARRAY); if (hasTexture) glDisableClientState(GL_TEXTURE_COORD_ARRAY); if (hasColor) glDisableClientState(GL_COLOR_ARRAY); if (hasNormal) glDisableClientState(GL_NORMAL_ARRAY); }
clear();}
void Tesselator::clear(){ vertices = 0;
p = 0; count = 0;
#ifdef __PSVITA__ // AP - alpha cut out is expensive on vita. Clear the cut out variables vertices2 = 0; p2 = 0;#endif}
void Tesselator::begin(){ begin(GL_QUADS); bounds.reset(); // 4J MGH - added} void Tesselator::useProjectedTexture(bool enable){ useProjectedTexturePixelShader = enable;}
void Tesselator::useCompactVertices(bool enable){ useCompactFormat360 = enable;}
bool Tesselator::getCompactVertices(){ return useCompactFormat360;}
bool Tesselator::setMipmapEnable(bool enable){ bool prev = mipmapEnable; mipmapEnable = enable; return prev;}
#ifdef __PSVITA__// AP - alpha cut out is expensive on vita. Use this to defer primitives that use icons with alphavoid Tesselator::setAlphaCutOut(bool enable){ alphaCutOutEnabled = enable;}
// AP - was any cut out geometry added since the last call to Clearbool Tesselator::getCutOutFound(){ if( vertices2 ) return true;
return false;}#endif
void Tesselator::begin(int mode){ /* // 4J - removed if (tesselating) { throw new IllegalStateException("Already tesselating!"); } */ tesselating = true;
clear(); this->mode = mode; hasNormal = false; hasColor = false; hasTexture = false; hasTexture2 = false; _noColor = false;}
void Tesselator::tex(float u, float v){ hasTexture = true; this->u = u; this->v = v;}
void Tesselator::tex2(int tex2){ hasTexture2 = true; this->_tex2 = tex2;}
void Tesselator::color(float r, float g, float b){ color((int) (r * 255), (int) (g * 255), (int) (b * 255));}
void Tesselator::color(float r, float g, float b, float a){ color((int) (r * 255), (int) (g * 255), (int) (b * 255), (int) (a * 255));}
void Tesselator::color(int r, int g, int b){ color(r, g, b, 255);}
void Tesselator::color(int r, int g, int b, int a){ if (_noColor) return;
if (r > 255) r = 255; if (g > 255) g = 255; if (b > 255) b = 255; if (a > 255) a = 255; if (r < 0) r = 0; if (g < 0) g = 0; if (b < 0) b = 0; if (a < 0) a = 0;
hasColor = true; // 4J - removed little-endian option col = (r << 24) | (g << 16) | (b << 8) | (a);}
void Tesselator::color(byte r, byte g, byte b){ color(r & 0xff, g & 0xff, b & 0xff);}
void Tesselator::vertexUV(float x, float y, float z, float u, float v){ tex(u, v); vertex(x, y, z);}
// Pack the 4 vertices of a quad up into a compact format. This is structured as 8 bytes per vertex,// arranged in blocks of 4 vertices per quad. Currently this is (one letter per nyblle)://// cccc xxyy zzll rgbi (vertex 0)// umin xxyy zzll rgbi (vertex 1)// vmin xxyy zzll rgbi (vertex 2)// udvd xxyy zzll rgbi (vertex 3)//// where: cccc is a 15-bit (5 bits per x/y/z) origin position / offset for the whole quad. Each// component is unsigned, and offset by 16 so has a range 0 to 31 actually representing -16 to 15// xx,yy,zz are 8-bit deltas from this origin to each vertex. These are unsigned 1.7 fixed point, ie// representing a range of 0 to 1.9921875// rgb is 4:4:4 RGB// umin, vmin are 3:13 unsigned fixed point UVs reprenting the min u and v required by the quad// ud,vd are 8-bit unsigned fixed pont UV deltas, which can be added to umin/vmin to get umax, vmax// and therefore define the 4 corners of an axis aligned UV mapping// i is a code per vertex that indicates which of umin/umax should be used for u, and which// of vmin/vmax should be used for v for this vertex. The coding is:// 0 - u = umin, v = vmin// 1 - u = umin, v = vmax// 2 - u = umax, v = vmin// 3 - u = umax, v = vmax// 4 - not axis aligned, use uv stored in the vertex data 4 on from this one// ll is an 8-bit (4 bit per u/v) index into the current lighting texture//// For quads that don't have axis aligned UVs (ie have a code for 4 in i as described above) the 8 byte vertex// is followed by a further 8 bytes which have explicit UVs defined for each vertex://// 0000 0000 uuuu vvvv (vertex 0)// 0000 0000 uuuu vvvv (vertex 1)// 0000 0000 uuuu vvvv (vertex 2)// 0000 0000 uuuu vvvv (vertex 3)//
void Tesselator::packCompactQuad(){ // Offset x/y/z by 16 so that we can deal with a -16 -> 16 range for( int i = 0; i < 4; i++ ) { m_ix[i] += 16 * 128; m_iy[i] += 16 * 128; m_iz[i] += 16 * 128; } // Find min x/y/z unsigned int minx = m_ix[0]; unsigned int miny = m_iy[0]; unsigned int minz = m_iz[0]; for( int i = 1; i < 4; i++ ) { if( m_ix[i] < minx ) minx = m_ix[i]; if( m_iy[i] < miny ) miny = m_iy[i]; if( m_iz[i] < minz ) minz = m_iz[i]; } // Everything has been scaled by a factor of 128 to get it into an int, and so // the minimum now should be in the range of (0->32) * 128. Get the base x/y/z // that our quad will be referenced from now, which can be stored in 5 bits unsigned int basex = ( minx >> 7 ); unsigned int basey = ( miny >> 7 ); unsigned int basez = ( minz >> 7 ); // If the min is 32, then this whole quad must be in that plane - make the min 15 instead so // we can still offset from that with our delta to get to the exact edge if( basex == 32 ) basex = 31; if( basey == 32 ) basey = 31; if( basez == 32 ) basez = 31; // Now get deltas to each vertex - these have an 8-bit range so they can span a // full unit range from the base position for( int i = 0; i < 4; i++ ) { m_ix[i] -= basex << 7; m_iy[i] -= basey << 7; m_iz[i] -= basez << 7; } // Now write the data out unsigned int *data = (unsigned int *)&_array->data[p]; for( int i = 0; i < 4; i++ ) { data[i * 2 + 0] = ( m_ix[i] << 8 ) | ( m_iy[i] ); data[i * 2 + 1] = ( m_iz[i] << 24 ) | ( m_clr[i] ); } data[0] |= ( basex << 26 ) | ( basey << 21 )| ( basez << 16 );
// Now process UVs. First find min & max U & V unsigned int minu = m_u[0]; unsigned int minv = m_v[0]; unsigned int maxu = m_u[0]; unsigned int maxv = m_v[0];
for( int i = 1; i < 4; i++ ) { if( m_u[i] < minu ) minu = m_u[i]; if( m_v[i] < minv ) minv = m_v[i]; if( m_u[i] > maxu ) maxu = m_u[i]; if( m_v[i] > maxv ) maxv = m_v[i]; } // In nearly all cases, all our UVs should be axis aligned for this quad. So the only values they should // have in each dimension should be the min/max. We're going to store: // (1) minu/maxu (16 bits each, only actuall needs to store 14 bits to get a 0 to 2 range for each // (2) du/dv ( ie maxu-minu, maxv-minv) - 8 bits each, to store a range of 0 to 15.9375 texels. This // should be enough to map the full UV range of a single 16x16 region of the terrain texture, since // we always pull UVs in by 1/16th of their range at the sides unsigned int du = maxu - minu; unsigned int dv = maxv - minv; if( du > 255 ) du = 255; if( dv > 255 ) dv = 255; // Check if this quad has UVs that can be referenced this way. This should only happen for flowing water // and lava, where the texture coordinates are rotated for the top surface of the tile. bool axisAligned = true; for( int i = 0; i < 4; i++ ) { if(! ( ( ( m_u[i] == minu ) || ( m_u[i] == maxu ) ) && ( ( m_v[i] == minv ) || ( m_v[i] == maxv ) ) ) ) { axisAligned = false; } }
if( axisAligned ) { // Now go through each vertex, and work out which of the min/max should be used for each dimension, // and store for( int i = 0; i < 4; i++ ) { unsigned int code = 0; if( m_u[i] == maxu ) code |= 2; if( m_v[i] == maxv ) code |= 1; data[i * 2 + 1] |= code; data[i * 2 + 1] |= m_t2[i] << 16; } // Finally, store the minu/minv/du/dv data[1 * 2 + 0] |= minu << 16; data[2 * 2 + 0] |= minv << 16; data[3 * 2 + 0] |= ( du << 24 | dv << 16 );
p += 4 * 2; } else { // The UVs aren't axis aligned - store them in the next 4 vertices. These will be indexed from // our base vertices because we'll set a special code (4) for the UVs. They won't be drawn as actual // verts when these extra vertices go through the vertex shader, because we'll make sure that // they get interpreted as a zero area quad and so they'll be quickly eliminated from rendering post-tranform
for( int i = 0; i < 4; i++ ) { data[i * 2 + 1] |= ( 4 ); // The special code to indicate they need further data to be fetched data[i * 2 + 1] |= m_t2[i] << 16; data[8 + i * 2] = 0; // This includes x/y coordinate of each vert as (0,0) so they will be interpreted as a zero area quad data[9 + i * 2] = m_u[i] << 16 | m_v[i]; }
// Extra 8 bytes required p += 8 * 2; }}
#ifdef __PSVITA__void Tesselator::tileQuad(float x1, float y1, float z1, float u1, float v1, float r1, float g1, float b1, int tex1, float x2, float y2, float z2, float u2, float v2, float r2, float g2, float b2, int tex2, float x3, float y3, float z3, float u3, float v3, float r3, float g3, float b3, int tex3, float x4, float y4, float z4, float u4, float v4, float r4, float g4, float b4, int tex4 ){ hasTexture = true; hasTexture2 = true; hasColor = true;
count+=4;
// AP - alpha cut out is expensive on vita. This will choose the correct data buffer depending on cut out enabled int16_t* pShortData; if( !alphaCutOutEnabled ) { pShortData = (int16_t*)&_array->data[p]; p += 16; vertices+=4; } else { pShortData = (int16_t*)&_array2->data[p2]; p2 += 16; vertices2+=4; }
int r = ((int) (r1 * 31)) << 11; int g = ((int) (g1 * 63)) << 5; int b = ((int) (b1 * 31)); int ipackedcol = r | g | b; ipackedcol -= 32768; // -32768 to 32767 range ipackedcol &= 0xffff;
bounds.addVert(x1+xo, y1+yo, z1+zo); // 4J MGH - added pShortData[0] = (((int)((x1 + xo ) * 1024.0f))&0xffff); pShortData[1] = (((int)((y1 + yo ) * 1024.0f))&0xffff); pShortData[2] = (((int)((z1 + zo ) * 1024.0f))&0xffff); pShortData[3] = ipackedcol; pShortData[4] = (((int)(u1 * 8192.0f))&0xffff); pShortData[5] = (((int)(v1 * 8192.0f))&0xffff); ((int *)pShortData)[3] = tex1; pShortData += 8;
r = ((int) (r2 * 31)) << 11; g = ((int) (g2 * 63)) << 5; b = ((int) (b2 * 31)); ipackedcol = r | g | b; ipackedcol -= 32768; // -32768 to 32767 range ipackedcol &= 0xffff;
bounds.addVert(x2+xo, y2+yo, z2+zo); // 4J MGH - added pShortData[0] = (((int)((x2 + xo ) * 1024.0f))&0xffff); pShortData[1] = (((int)((y2 + yo ) * 1024.0f))&0xffff); pShortData[2] = (((int)((z2 + zo ) * 1024.0f))&0xffff); pShortData[3] = ipackedcol; pShortData[4] = (((int)(u2 * 8192.0f))&0xffff); pShortData[5] = (((int)(v2 * 8192.0f))&0xffff); ((int *)pShortData)[3] = tex2; pShortData += 8;
r = ((int) (r3 * 31)) << 11; g = ((int) (g3 * 63)) << 5; b = ((int) (b3 * 31)); ipackedcol = r | g | b; ipackedcol -= 32768; // -32768 to 32767 range ipackedcol &= 0xffff;
bounds.addVert(x3+xo, y3+yo, z3+zo); // 4J MGH - added pShortData[0] = (((int)((x3 + xo ) * 1024.0f))&0xffff); pShortData[1] = (((int)((y3 + yo ) * 1024.0f))&0xffff); pShortData[2] = (((int)((z3 + zo ) * 1024.0f))&0xffff); pShortData[3] = ipackedcol; pShortData[4] = (((int)(u3 * 8192.0f))&0xffff); pShortData[5] = (((int)(v3 * 8192.0f))&0xffff); ((int *)pShortData)[3] = tex3; pShortData += 8;
r = ((int) (r4 * 31)) << 11; g = ((int) (g4 * 63)) << 5; b = ((int) (b4 * 31)); ipackedcol = r | g | b; ipackedcol -= 32768; // -32768 to 32767 range ipackedcol &= 0xffff;
bounds.addVert(x4+xo, y4+yo, z4+zo); // 4J MGH - added pShortData[0] = (((int)((x4 + xo ) * 1024.0f))&0xffff); pShortData[1] = (((int)((y4 + yo ) * 1024.0f))&0xffff); pShortData[2] = (((int)((z4 + zo ) * 1024.0f))&0xffff); pShortData[3] = ipackedcol; pShortData[4] = (((int)(u4 * 8192.0f))&0xffff); pShortData[5] = (((int)(v4 * 8192.0f))&0xffff); ((int *)pShortData)[3] = tex4;
// Max 65535 verts in D3D, so 65532 is the last point at the end of a quad to catch it if ( (!alphaCutOutEnabled && vertices % 4 == 0 && ( ( p >= size - 4 * 4 ) || ( ( p / 4 ) >= 65532 ) )) || (alphaCutOutEnabled && vertices2 % 4 == 0 && ( ( p2 >= size - 4 * 4 ) || ( ( p2 / 4 ) >= 65532 ) )) ) { end(); tesselating = true; }}
void Tesselator::tileRainQuad(float x1, float y1, float z1, float u1, float v1, float x2, float y2, float z2, float u2, float v2, float x3, float y3, float z3, float u3, float v3, float x4, float y4, float z4, float u4, float v4, float r1, float g1, float b1, float a1, float r2, float g2, float b2, float a2, int tex1 ){ hasTexture = true; hasTexture2 = true; hasColor = true;
float* pfData = (float*)&_array->data[p];
count+=4; p += 4 * 8; vertices+=4;
unsigned int col1 = ((int)(r1*255) << 24) | ((int)(g1*255) << 16) | ((int)(b1*255) << 8) | (int)(a1*255);
bounds.addVert(x1+xo, y1+yo, z1+zo); pfData[0] = (x1 + xo); pfData[1] = (y1 + yo); pfData[2] = (z1 + zo); pfData[3] = u1; pfData[4] = v1; ((int*)pfData)[5] = col1; ((int*)pfData)[7] = tex1; pfData += 8;
bounds.addVert(x2+xo, y2+yo, z2+zo); pfData[0] = (x2 + xo); pfData[1] = (y2 + yo); pfData[2] = (z2 + zo); pfData[3] = u2; pfData[4] = v2; ((int*)pfData)[5] = col1; ((int*)pfData)[7] = tex1; pfData += 8;
col1 = ((int)(r2*255) << 24) | ((int)(g2*255) << 16) | ((int)(b2*255) << 8) | (int)(a2*255);
bounds.addVert(x3+xo, y3+yo, z3+zo); pfData[0] = (x3 + xo); pfData[1] = (y3 + yo); pfData[2] = (z3 + zo); pfData[3] = u3; pfData[4] = v3; ((int*)pfData)[5] = col1; ((int*)pfData)[7] = tex1; pfData += 8;
bounds.addVert(x4+xo, y4+yo, z4+zo); pfData[0] = (x4 + xo); pfData[1] = (y4 + yo); pfData[2] = (z4 + zo); pfData[3] = u4; pfData[4] = v4; ((int*)pfData)[5] = col1; ((int*)pfData)[7] = tex1; pfData += 8;
if (vertices % 4 == 0 && p >= size - 8 * 4) { end(); tesselating = true; }}
void Tesselator::tileParticleQuad(float x1, float y1, float z1, float u1, float v1, float x2, float y2, float z2, float u2, float v2, float x3, float y3, float z3, float u3, float v3, float x4, float y4, float z4, float u4, float v4, float r1, float g1, float b1, float a1){ hasTexture = true; hasTexture2 = true; hasColor = true;
float* pfData = (float*)&_array->data[p];
count+=4; p += 4 * 8; vertices+=4;
unsigned int col1 = ((int)(r1*255) << 24) | ((int)(g1*255) << 16) | ((int)(b1*255) << 8) | (int)(a1*255);
bounds.addVert(x1+xo, y1+yo, z1+zo); pfData[0] = (x1 + xo); pfData[1] = (y1 + yo); pfData[2] = (z1 + zo); pfData[3] = u1; pfData[4] = v1; ((int*)pfData)[5] = col1; ((int*)pfData)[7] = _tex2; pfData += 8;
bounds.addVert(x2+xo, y2+yo, z2+zo); pfData[0] = (x2 + xo); pfData[1] = (y2 + yo); pfData[2] = (z2 + zo); pfData[3] = u2; pfData[4] = v2; ((int*)pfData)[5] = col1; ((int*)pfData)[7] = _tex2; pfData += 8;
bounds.addVert(x3+xo, y3+yo, z3+zo); pfData[0] = (x3 + xo); pfData[1] = (y3 + yo); pfData[2] = (z3 + zo); pfData[3] = u3; pfData[4] = v3; ((int*)pfData)[5] = col1; ((int*)pfData)[7] = _tex2; pfData += 8;
bounds.addVert(x4+xo, y4+yo, z4+zo); pfData[0] = (x4 + xo); pfData[1] = (y4 + yo); pfData[2] = (z4 + zo); pfData[3] = u4; pfData[4] = v4; ((int*)pfData)[5] = col1; ((int*)pfData)[7] = _tex2; pfData += 8;
if (vertices % 4 == 0 && p >= size - 8 * 4) { end(); tesselating = true; }}#endif
typedef unsigned short hfloat;extern hfloat convertFloatToHFloat(float f);extern float convertHFloatToFloat(hfloat hf);
void Tesselator::vertex(float x, float y, float z){ bounds.addVert(x+xo, y+yo, z+zo); // 4J MGH - added count++;
// Signal to pixel shader whether to use mipmapping or not, by putting u into > 1 range if it is to be disabled float uu = mipmapEnable ? u : (u + 1.0f);
// 4J - this format added for 360 to keep memory size of tesselated tiles down - // see comments in packCompactQuad() for exact format if( useCompactFormat360 ) { unsigned int ucol = (unsigned int)col;
#ifdef _XBOX // Pack as 4:4:4 RGB_ unsigned short packedcol = (((col & 0xf0000000 ) >> 16 ) | ((col & 0x00f00000 ) >> 12 ) | ((col & 0x0000f000 ) >> 8 )); int ipackedcol = ((int)packedcol) & 0xffff; // 0 to 65535 range
int quadIdx = vertices % 4; m_ix[ quadIdx ] = (unsigned int)((x + xo) * 128.0f); m_iy[ quadIdx ] = (unsigned int)((y + yo) * 128.0f); m_iz[ quadIdx ] = (unsigned int)((z + zo) * 128.0f); m_clr[ quadIdx ] = (unsigned int)ipackedcol; m_u[ quadIdx ] = (int)(uu * 4096.0f); m_v[ quadIdx ] = (int)(v * 4096.0f); m_t2[ quadIdx ] = ( ( _tex2 & 0x00f00000 ) >> 20 ) | ( _tex2 & 0x000000f0 ); if( quadIdx == 3 ) { packCompactQuad(); }#else unsigned short packedcol = ((col & 0xf8000000 ) >> 16 ) | ((col & 0x00fc0000 ) >> 13 ) | ((col & 0x0000f800 ) >> 11 ); int ipackedcol = ((int)packedcol) & 0xffff; // 0 to 65535 range
ipackedcol -= 32768; // -32768 to 32767 range ipackedcol &= 0xffff;
#ifdef __PSVITA__ // AP - alpha cut out is expensive on vita. This will choose the correct data buffer depending on cut out enabled int16_t* pShortData; if( !alphaCutOutEnabled ) { pShortData = (int16_t*)&_array->data[p]; } else { pShortData = (int16_t*)&_array2->data[p2]; }#else int16_t* pShortData = (int16_t*)&_array->data[p];
#endif
#ifdef __PS3__ float tex2U = ((int16_t*)&_tex2)[1] + 8; float tex2V = ((int16_t*)&_tex2)[0] + 8; float colVal1 = ((col&0xff000000)>>24)/256.0f; float colVal2 = ((col&0x00ff0000)>>16)/256.0f; float colVal3 = ((col&0x0000ff00)>>8)/256.0f;
// pShortData[0] = convertFloatToHFloat(x + xo);// pShortData[1] = convertFloatToHFloat(y + yo);// pShortData[2] = convertFloatToHFloat(z + zo);// pShortData[3] = convertFloatToHFloat(uu);// pShortData[4] = convertFloatToHFloat(tex2U + colVal1);// pShortData[5] = convertFloatToHFloat(tex2V + colVal2);// pShortData[6] = convertFloatToHFloat(colVal3);// pShortData[7] = convertFloatToHFloat(v);
pShortData[0] = (((int)((x + xo ) * 1024.0f))&0xffff); pShortData[1] = (((int)((y + yo ) * 1024.0f))&0xffff); pShortData[2] = (((int)((z + zo ) * 1024.0f))&0xffff); pShortData[3] = ipackedcol; pShortData[4] = (((int)(uu * 8192.0f))&0xffff); pShortData[5] = (((int)(v * 8192.0f))&0xffff); pShortData[6] = (((int)(tex2U * (8192.0f/256.0f)))&0xffff); pShortData[7] = (((int)(tex2V * (8192.0f/256.0f)))&0xffff);
p += 4;#else pShortData[0] = (((int)((x + xo ) * 1024.0f))&0xffff); pShortData[1] = (((int)((y + yo ) * 1024.0f))&0xffff); pShortData[2] = (((int)((z + zo ) * 1024.0f))&0xffff); pShortData[3] = ipackedcol; pShortData[4] = (((int)(uu * 8192.0f))&0xffff); pShortData[5] = (((int)(v * 8192.0f))&0xffff); int16_t u2 = ((int16_t*)&_tex2)[0]; int16_t v2 = ((int16_t*)&_tex2)[1];#if defined _XBOX_ONE || defined __ORBIS__ // Optimisation - pack the second UVs into a single short (they could actually go in a byte), which frees up a short to store the x offset for this chunk in the vertex itself. // This means that when rendering chunks, we don't need to update the vertex constants that specify the location for a chunk, when only the x offset has changed. pShortData[6] = ( u2 << 8 ) | v2; pShortData[7] = -xoo;#else pShortData[6] = u2; pShortData[7] = v2;#endif
#ifdef __PSVITA__ // AP - alpha cut out is expensive on vita. This will choose the correct data buffer depending on cut out enabled if( !alphaCutOutEnabled ) { p += 4; } else { p2 += 4; }#else p += 4;#endif
#endif
#endif
#ifdef __PSVITA__ // AP - alpha cut out is expensive on vita. Increase the correct vertices depending on cut out enabled if( !alphaCutOutEnabled ) { vertices++; } else { vertices2++; }#else
vertices++;#endif
#ifdef _XBOX if (vertices % 4 == 0 && ( ( p >= size - 8 * 2 ) || ( ( p / 2 ) >= 65532 ) ) ) // Max 65535 verts in D3D, so 65532 is the last point at the end of a quad to catch it#else
#ifdef __PSVITA__ // Max 65535 verts in D3D, so 65532 is the last point at the end of a quad to catch it if ( (!alphaCutOutEnabled && vertices % 4 == 0 && ( ( p >= size - 4 * 4 ) || ( ( p / 4 ) >= 65532 ) )) || (alphaCutOutEnabled && vertices2 % 4 == 0 && ( ( p2 >= size - 4 * 4 ) || ( ( p2 / 4 ) >= 65532 ) )) )#else
if (vertices % 4 == 0 && ( ( p >= size - 4 * 4 ) || ( ( p / 4 ) >= 65532 ) ) ) // Max 65535 verts in D3D, so 65532 is the last point at the end of a quad to catch it#endif
#endif { end(); tesselating = true; } } else { if (mode == GL_QUADS && TRIANGLE_MODE && count % 4 == 0) { for (int i = 0; i < 2; i++) { int offs = 8 * (3 - i); if (hasTexture) { _array->data[p + 3] = _array->data[p - offs + 3]; _array->data[p + 4] = _array->data[p - offs + 4]; } if (hasColor) { _array->data[p + 5] = _array->data[p - offs + 5]; }
_array->data[p + 0] = _array->data[p - offs + 0]; _array->data[p + 1] = _array->data[p - offs + 1]; _array->data[p + 2] = _array->data[p - offs + 2];
vertices++; p += 8; } }
if (hasTexture) { float *fdata = (float *)(_array->data + p + 3); *fdata++ = uu; *fdata++ = v; } if (hasColor) { _array->data[p + 5] = col; } if (hasNormal) { _array->data[p + 6] = _normal; } if (hasTexture2) {#ifdef _XBOX _array->data[p + 7] = ( ( _tex2 >> 16 ) & 0xffff ) | ( _tex2 << 16 );#else #ifdef __PS3__ int16_t tex2U = ((int16_t*)&_tex2)[1] + 8; int16_t tex2V = ((int16_t*)&_tex2)[0] + 8; int16_t* pShortArray = (int16_t*)&_array->data[p + 7]; pShortArray[0] = tex2U; pShortArray[1] = tex2V; #else _array->data[p + 7] = _tex2; #endif#endif } else { // -512 each for u/v will mean that the renderer will use global settings (set via // RenderManager.StateSetVertexTextureUV) rather than these local ones *(unsigned int *)(&_array->data[p + 7]) = 0xfe00fe00; }
float *fdata = (float *)(_array->data + p); *fdata++ = (x + xo); *fdata++ = (y + yo); *fdata++ = (z + zo); p += 8;
vertices++; if (vertices % 4 == 0 && p >= size - 8 * 4) { end(); tesselating = true; } }}
void Tesselator::color(int c){ int r = ((c >> 16) & 255); int g = ((c >> 8) & 255); int b = ((c) & 255); color(r, g, b);}
void Tesselator::color(int c, int alpha){ int r = ((c >> 16) & 255); int g = ((c >> 8) & 255); int b = ((c) & 255); color(r, g, b, alpha);}
void Tesselator::noColor(){ _noColor = true;}
#ifdef __PS3__uint32_t _ConvertF32toX11Y11Z10N(float x, float y, float z){ // 11111111111 X 0x000007FF // 1111111111100000000000 Y 0x003FF800 // 11111111110000000000000000000000 Z 0xFFC00000 // ZZZZZZZZZZYYYYYYYYYYYXXXXXXXXXXX // #defines for X11Y11Z10N format#define X11Y11Z10N_X_MASK 0x000007FF#define X11Y11Z10N_X_BITS 11#define X11Y11Z10N_X_SHIFT 0
#define X11Y11Z10N_Y_MASK 0x003FF800#define X11Y11Z10N_Y_BITS 11#define X11Y11Z10N_Y_SHIFT 11
#define X11Y11Z10N_Z_MASK 0xFFC00000#define X11Y11Z10N_Z_BITS 10#define X11Y11Z10N_Z_SHIFT 22
#ifndef _CONTENT_PACKAGE if (x<-1.0f || x>1.0f) { printf("Value (%5.3f) should be in range [-1..1]. Conversion will clamp to X11Y11Z10N.\n", x); } if (y<-1.0f || y>1.0f) { printf("Value (%5.3f) should be in range [-1..1]. Conversion will clamp to X11Y11Z10N.\n", y); } if (z<-1.0f || z>1.0f) { printf("Value (%5.3f) should be in range [-1..1]. Conversion will clamp to X11Y11Z10N.\n", z); }#endif
const uint32_t uX = ((int32_t(max(min(((x)*2047.f - 1.f)*0.5f, 1023.f), -1024.f)) & (X11Y11Z10N_X_MASK >> X11Y11Z10N_X_SHIFT)) << X11Y11Z10N_X_SHIFT); const uint32_t uY = ((int32_t(max(min(((y)*2047.f - 1.f)*0.5f, 1023.f), -1024.f)) & (X11Y11Z10N_Y_MASK >> X11Y11Z10N_Y_SHIFT)) << X11Y11Z10N_Y_SHIFT); const uint32_t uZ = ((int32_t(max(min(((z)*1023.f - 1.f)*0.5f, 511.f), -512.f )) & (X11Y11Z10N_Z_MASK >> X11Y11Z10N_Z_SHIFT)) << X11Y11Z10N_Z_SHIFT); const uint32_t xyz = uX | uY | uZ; return xyz;}#endif // __PS3__
void Tesselator::normal(float x, float y, float z){ hasNormal = true;
#ifdef __PS3__ _normal = _ConvertF32toX11Y11Z10N(x,y,z);#elif __PSVITA__ // AP - casting a negative value to 'byte' on Vita results in zero. changed to a signed 8 value int8_t xx = (int8_t) (x * 127); int8_t yy = (int8_t) (y * 127); int8_t zz = (int8_t) (z * 127); _normal = (xx & 0xff) | ((yy & 0xff) << 8) | ((zz & 0xff) << 16);#else byte xx = (byte) (x * 127); byte yy = (byte) (y * 127); byte zz = (byte) (z * 127); _normal = (xx & 0xff) | ((yy & 0xff) << 8) | ((zz & 0xff) << 16);#endif}
void Tesselator::offset(float xo, float yo, float zo){ this->xo = xo; this->yo = yo; this->zo = zo;
// 4J added this->xoo = xo; this->yoo = yo; this->zoo = zo;}
void Tesselator::addOffset(float x, float y, float z){ xo += x; yo += y; zo += z;}
bool Tesselator::hasMaxVertices(){#ifdef __ORBIS__ // On PS4, the way we push data to the command buffer has a maximum size of a single command packet of 2^16 bytes, // and the effective maximum size will be slightly less than that due to packet headers and padding. int bytes = vertices * (useCompactFormat360?16:32);
return bytes > 60 * 1024;#else return false;#endif}