backups/4jcraft
1
0
Fork 0
mirror of https://github.com/4jcraft/4jcraft.git synced 2026-04-24 11:23:36 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
4jcraft/targets/minecraft/client/renderer/Tesselator.cpp
Tropical 32aaafeb7e remove GL/gl.h includes
2026-04-07 16:29:27 -05:00

604 lines
20 KiB
C++
Raw Permalink Blame History

#include "minecraft/util/Log.h"
#include "Tesselator.h"
#include <vector>
#include "platform/renderer/renderer.h"
#include "app/linux/LinuxGame.h"
#include "platform/stubs.h"
#include "minecraft/client/MemoryTracker.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;
*/
thread_local Tesselator* Tesselator::m_tlsInstance = nullptr;
Tesselator* Tesselator::getInstance() { return m_tlsInstance; }
void Tesselator::CreateNewThreadStorage(int bytes) {
Tesselator::m_tlsInstance = new Tesselator(bytes / 4);
}
// she tessalate my vertices till i render
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 std::vector<int>(size);
vboMode =
USE_VBO; // 4J removed - &&
// GLContext.getCapabilities().GL_ARB_vertex_buffer_object;
if (vboMode) {
vboIds = MemoryTracker::createIntBuffer(vboCounts);
ARBVertexBufferObject::glGenBuffersARB(vboIds);
}
}
Tesselator* Tesselator::getUniqueInstance(int size) {
return new Tesselator(size);
}
void Tesselator::end() {
// if (!tesselating) throw new IllegalStateException("Not tesselating!");
// // 4J - removed
tesselating = false;
if (vertices > 0) {
// 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 Use 0x00000000 (not
// 0xffffffff) so DrawVertices skips glColor for these vertices,
// letting any caller-set GL colour (e.g. sky colour) pass through
// unmodified.
unsigned int* pColData = (unsigned int*)_array->data();
pColData += 5;
for (int i = 0; i < vertices; i++) {
*pColData = 0x00000000;
pColData += 8;
}
}
if (mode == GL_QUADS && TRIANGLE_MODE) {
// glDrawArrays(GL_TRIANGLES, 0, vertices); // 4J - changed for xbox
PlatformRenderer.DrawVertices(
IPlatformRenderer::PRIMITIVE_TYPE_TRIANGLE_LIST, vertices,
_array->data(),
useCompactFormat360
? IPlatformRenderer::VERTEX_TYPE_COMPRESSED
: IPlatformRenderer::VERTEX_TYPE_PF3_TF2_CB4_NB4_XW1,
useProjectedTexturePixelShader
? IPlatformRenderer::PIXEL_SHADER_TYPE_PROJECTION
: IPlatformRenderer::PIXEL_SHADER_TYPE_STANDARD);
} 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)
int vertexCount = vertices;
if (useCompactFormat360) {
PlatformRenderer.DrawVertices(
(IPlatformRenderer::ePrimitiveType)mode, vertexCount,
_array->data(), IPlatformRenderer::VERTEX_TYPE_COMPRESSED,
IPlatformRenderer::PIXEL_SHADER_TYPE_STANDARD);
} else {
if (useProjectedTexturePixelShader) {
PlatformRenderer.DrawVertices(
(IPlatformRenderer::ePrimitiveType)mode, vertexCount,
_array->data(),
IPlatformRenderer::VERTEX_TYPE_PF3_TF2_CB4_NB4_XW1_TEXGEN,
IPlatformRenderer::PIXEL_SHADER_TYPE_PROJECTION);
} else {
PlatformRenderer.DrawVertices(
(IPlatformRenderer::ePrimitiveType)mode, vertexCount,
_array->data(),
IPlatformRenderer::VERTEX_TYPE_PF3_TF2_CB4_NB4_XW1,
IPlatformRenderer::PIXEL_SHADER_TYPE_STANDARD);
}
}
}
// 4jcraft: gldisableclientstate breaks gl compat, commenting those lead
// to some weird glitches with input but.. somehow stopped one day so..
// just keep an eye on these incase mouse locking stops working outta
// nowhere (i blame opengl not me)
//
// 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;
}
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;
}
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(std::uint8_t r, std::uint8_t g, std::uint8_t 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;
}
}
typedef unsigned short hfloat;
extern hfloat convertFloatToHFloat(float f);
extern float convertHFloatToFloat(hfloat hf);
#if defined(__linux__)
namespace {
void packLinuxLightmapCoords(int tex2, std::int16_t& u, std::int16_t& v) {
u = static_cast<std::int16_t>(tex2 & 0xffff);
v = static_cast<std::int16_t>((tex2 >> 16) & 0xffff);
// Linux 4jlibs consumes packed UV2 values by dividing them by 256 directly
// for chunk and other non-scaleLight draws, so offset to texel centers
// here.
u += 8;
v += 8;
}
void logLinuxPackedLightmapCoords(const char* path, int tex2, std::int16_t u,
std::int16_t v) {
static int logCount = 0;
if (logCount >= 16) return;
++logCount;
Log::info(
"[linux-lightmap] %s raw=0x%08x packed=(%d,%d) sampled=(%.4f,%.4f)\n",
path, tex2, (int)u, (int)v, u / 256.0f, v / 256.0f);
}
} // namespace
#endif
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;
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;
std::int16_t* pShortData = (std::int16_t*)&_array->data()[p];
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);
std::int16_t u2 = static_cast<std::int16_t>(_tex2 & 0xffff);
std::int16_t v2 = static_cast<std::int16_t>((_tex2 >> 16) & 0xffff);
#if defined(__linux__)
packLinuxLightmapCoords(_tex2, u2, v2);
logLinuxPackedLightmapCoords("compact", _tex2, u2, v2);
#endif
pShortData[6] = u2;
pShortData[7] = v2;
p += 4;
vertices++;
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
{
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) {
// 4jcraft: we will be lighting the blocks right in here
#if defined(__linux__)
std::int16_t tex2U;
std::int16_t tex2V;
packLinuxLightmapCoords(_tex2, tex2U, tex2V);
logLinuxPackedLightmapCoords("standard", _tex2, tex2U, tex2V);
std::int16_t* pShortArray = (std::int16_t*)&_array->data()[p + 7];
pShortArray[0] = tex2U;
pShortArray[1] = tex2V;
#else
_array->data()[p + 7] = _tex2;
#endif
} else {
// -512 each for u/v will mean that the renderer will use global
// settings (set via PlatformRenderer.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; }
void Tesselator::normal(float x, float y, float z) {
hasNormal = true;
// 4jcraft copied the PSVITA branch, read comment above
std::int8_t xx = (std::int8_t)(x * 127);
std::int8_t yy = (std::int8_t)(y * 127);
std::int8_t zz = (std::int8_t)(z * 127);
_normal = (xx & 0xff) | ((yy & 0xff) << 8) | ((zz & 0xff) << 16);
}
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() { return false; }
Reference in a new issue View git blame Copy permalink