mirror of
https://github.com/4jcraft/4jcraft.git
synced 2026-04-26 16:23:36 +00:00
942 lines
30 KiB
C++
942 lines
30 KiB
C++
#include "4J_Render.h"
|
|
#include <cstring>
|
|
#include <cstdlib> // getenv
|
|
|
|
#include <GL/gl.h>
|
|
#include <GL/glu.h>
|
|
#include <GL/glext.h>
|
|
#include <SDL2/SDL.h>
|
|
#include <cstdio>
|
|
#include <cmath>
|
|
#include <pthread.h>
|
|
|
|
#define STB_IMAGE_IMPLEMENTATION
|
|
#include "stb_image.h"
|
|
|
|
C4JRender RenderManager;
|
|
|
|
// Hello SDL!
|
|
static SDL_Window* s_window = nullptr;
|
|
static SDL_GLContext s_glContext = nullptr;
|
|
static bool s_shouldClose = false;
|
|
static int s_textureLevels = 1;
|
|
static int s_windowWidth = 1920;
|
|
static int s_windowHeight = 1080;
|
|
|
|
// We set Window size with the monitor's res, so that I can get rid of ugly
|
|
// values.
|
|
static void SetInitialWindowSize() {
|
|
int w = 0, h = 0;
|
|
if (SDL_Init(SDL_INIT_VIDEO) == 0) {
|
|
SDL_DisplayMode mode;
|
|
if (SDL_GetCurrentDisplayMode(0, &mode) == 0) {
|
|
w = (int)(mode.w * 0.4f);
|
|
h = (int)(mode.h * 0.4f);
|
|
}
|
|
}
|
|
if (w > 0 && h > 0) {
|
|
s_windowWidth = w;
|
|
s_windowHeight = h;
|
|
} else {
|
|
s_windowWidth = 1920;
|
|
s_windowHeight = 1080;
|
|
}
|
|
}
|
|
// (can't believe i had to rewrite this, i literally did it TODAY.)
|
|
static int s_reqWidth = 1920;
|
|
static int s_reqHeight = 1080;
|
|
// When we'll have a settings system in order, we'll set bool to that value,
|
|
// right now it's hardcoded.
|
|
static bool s_fullscreen = false;
|
|
|
|
static pthread_key_t s_glCtxKey;
|
|
static pthread_once_t s_glCtxKeyOnce = PTHREAD_ONCE_INIT;
|
|
static void makeGLCtxKey() { pthread_key_create(&s_glCtxKey, nullptr); }
|
|
// Do not touch exactly this number |
|
|
static const int MAX_SHARED_CONTEXTS = 6; // <- this one, do not touch
|
|
static SDL_Window* s_sharedContextWindows[MAX_SHARED_CONTEXTS] = {};
|
|
static SDL_GLContext s_sharedContexts[MAX_SHARED_CONTEXTS] = {};
|
|
static int s_sharedContextCount = 0;
|
|
static int s_nextSharedContext = 0;
|
|
static pthread_mutex_t s_sharedCtxMutex = PTHREAD_MUTEX_INITIALIZER;
|
|
// Tells thread to do Direct GL calls, just don't touch.
|
|
static pthread_mutex_t s_glCallMutex = PTHREAD_MUTEX_INITIALIZER;
|
|
|
|
// Track which thread is the main (rendering) thread
|
|
static pthread_t s_mainThread;
|
|
static bool s_mainThreadSet = false;
|
|
|
|
// viewport go brr
|
|
static void onFramebufferResize(int w, int h) {
|
|
if (w < 1) w = 1;
|
|
if (h < 1) h = 1;
|
|
s_windowWidth = w;
|
|
s_windowHeight = h;
|
|
::glViewport(0, 0, w, h);
|
|
}
|
|
|
|
// V-Sync
|
|
|
|
// Initialize OpenGL & The SDL window.
|
|
void C4JRender::Initialise() {
|
|
if (SDL_Init(SDL_INIT_VIDEO) != 0) {
|
|
fprintf(stderr, "[4J_Render] Failed to initialise SDL: %s\n",
|
|
SDL_GetError());
|
|
return;
|
|
}
|
|
SDL_DisplayMode mode;
|
|
int haveMode = (SDL_GetCurrentDisplayMode(0, &mode) == 0);
|
|
|
|
if (s_reqWidth > 0 && s_reqHeight > 0) {
|
|
s_windowWidth = s_reqWidth;
|
|
s_windowHeight = s_reqHeight;
|
|
} else if (haveMode) {
|
|
s_windowWidth = mode.w;
|
|
s_windowHeight = mode.h;
|
|
}
|
|
fprintf(stderr, "[4J_Render] Window %dx%d fullscreen=%s\n", s_windowWidth,
|
|
s_windowHeight, s_fullscreen ? "yes" : "no");
|
|
fflush(stderr);
|
|
|
|
// Setting the sdl_gl ver. Change in future incase we want to use shaders
|
|
// Yes i'm still using fixed functions, get mad at me
|
|
// I don't care.
|
|
// Im not gonna be rewriting the whole renderer.. AGAIN. ;w;
|
|
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 2);
|
|
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 1);
|
|
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
|
|
SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 8);
|
|
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
|
|
|
|
Uint32 winFlags = SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE;
|
|
if (s_fullscreen) winFlags |= SDL_WINDOW_FULLSCREEN_DESKTOP;
|
|
|
|
s_window = SDL_CreateWindow("Minecraft Console Edition",
|
|
SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
|
|
s_windowWidth, s_windowHeight, winFlags);
|
|
if (!s_window) {
|
|
fprintf(stderr, "[4J_Render] Failed to create SDL window: %s\n",
|
|
SDL_GetError());
|
|
SDL_Quit();
|
|
return;
|
|
}
|
|
|
|
s_glContext = SDL_GL_CreateContext(s_window);
|
|
if (!s_glContext) {
|
|
fprintf(stderr, "[4J_Render] Failed to create GL context: %s\n",
|
|
SDL_GetError());
|
|
SDL_DestroyWindow(s_window);
|
|
s_window = nullptr;
|
|
SDL_Quit();
|
|
return;
|
|
}
|
|
|
|
int w, h, channels;
|
|
unsigned char* data = stbi_load("Common/Media/Graphics/MinecraftIcon.png",
|
|
&w, &h, &channels, 4);
|
|
if (!data) {
|
|
SDL_Log("Failed to load icon: %s", SDL_GetError());
|
|
} else {
|
|
SDL_Surface* icon =
|
|
SDL_CreateRGBSurfaceFrom(data, w, h, 32, w * 4, 0x000000FF,
|
|
0x0000FF00, 0x00FF0000, 0xFF000000);
|
|
if (!icon) {
|
|
SDL_Log("Failed to load icon: %s", SDL_GetError());
|
|
} else {
|
|
SDL_SetWindowIcon(s_window, icon);
|
|
SDL_FreeSurface(icon);
|
|
}
|
|
}
|
|
|
|
// 4JCraft VSync/V-Sync
|
|
#ifdef ENABLE_VSYNC
|
|
SDL_GL_SetSwapInterval(1); // V-Sync On Please.
|
|
#else
|
|
SDL_GL_SetSwapInterval(0); // V-Sync Off Please.
|
|
#endif
|
|
|
|
int fw, fh;
|
|
SDL_GetWindowSize(s_window, &fw, &fh);
|
|
onFramebufferResize(fw, fh);
|
|
|
|
// We initialize the OpenGL states. Touching those values makes some funny
|
|
// artifacts appear.
|
|
::glEnable(GL_TEXTURE_2D);
|
|
::glEnable(GL_DEPTH_TEST);
|
|
::glDepthFunc(GL_LEQUAL);
|
|
::glClearDepth(1.0);
|
|
::glEnable(GL_ALPHA_TEST);
|
|
::glAlphaFunc(GL_GREATER, 0.1f);
|
|
::glEnable(GL_BLEND);
|
|
::glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
|
|
::glEnable(GL_CULL_FACE);
|
|
::glCullFace(GL_BACK);
|
|
::glShadeModel(GL_SMOOTH);
|
|
::glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
|
|
::glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
|
|
::glViewport(0, 0, s_windowWidth, s_windowHeight);
|
|
::glEnable(GL_COLOR_MATERIAL);
|
|
::glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
|
|
// Print the renderer's version incase we change it in the future.
|
|
printf("[4J_Render] OpenGL %s | %s\n",
|
|
(const char*)::glGetString(GL_VERSION),
|
|
(const char*)::glGetString(GL_RENDERER));
|
|
fflush(stdout);
|
|
|
|
// Tag this as the main rendering thread
|
|
pthread_once(&s_glCtxKeyOnce, makeGLCtxKey);
|
|
s_mainThread = pthread_self();
|
|
s_mainThreadSet = true;
|
|
pthread_setspecific(s_glCtxKey, (void*)s_window);
|
|
|
|
// Pre-create shared GL contexts for worker threads (chunk builders etc.)
|
|
// Ensure they are invisible so they don't interfere with the window
|
|
// manager.
|
|
|
|
// Pre-create shared GL contexts for worker threads (chunk builders & other
|
|
// shit etc.) SDL_GL_SHARE_WITH_CURRENT_CONTEXT my saviour.
|
|
for (int i = 0; i < MAX_SHARED_CONTEXTS; i++) {
|
|
SDL_Window* w = SDL_CreateWindow("", SDL_WINDOWPOS_UNDEFINED,
|
|
SDL_WINDOWPOS_UNDEFINED, 1, 1,
|
|
SDL_WINDOW_HIDDEN | SDL_WINDOW_OPENGL);
|
|
if (!w) break;
|
|
// Ensure sharing
|
|
// I've been stuck on this for a while. Im stupid..
|
|
SDL_GL_MakeCurrent(s_window, s_glContext);
|
|
SDL_GL_SetAttribute(SDL_GL_SHARE_WITH_CURRENT_CONTEXT, 1);
|
|
SDL_GLContext ctx = SDL_GL_CreateContext(w);
|
|
if (!ctx) {
|
|
SDL_DestroyWindow(w);
|
|
break;
|
|
}
|
|
s_sharedContextWindows[s_sharedContextCount] = w;
|
|
s_sharedContexts[s_sharedContextCount] = ctx;
|
|
s_sharedContextCount++;
|
|
}
|
|
|
|
// Ensure main thread still has the context
|
|
SDL_GL_MakeCurrent(s_window, s_glContext);
|
|
fprintf(stderr,
|
|
"[4J_Render] Created %d shared GL contexts for worker threads\n",
|
|
s_sharedContextCount);
|
|
fflush(stderr);
|
|
}
|
|
|
|
void C4JRender::InitialiseContext() {
|
|
if (!s_window) return;
|
|
pthread_once(&s_glCtxKeyOnce, makeGLCtxKey);
|
|
|
|
// Main thread reclaiming context (e.g. after startup thread finishes)
|
|
if (s_mainThreadSet && pthread_equal(pthread_self(), s_mainThread)) {
|
|
SDL_GL_MakeCurrent(s_window, s_glContext);
|
|
pthread_setspecific(s_glCtxKey, (void*)s_window);
|
|
return;
|
|
}
|
|
|
|
// Worker thread checks if there's a context, we don't want to have multiple
|
|
// contexts.
|
|
void* ctxPtr = pthread_getspecific(s_glCtxKey);
|
|
if (ctxPtr) {
|
|
// ctxPtr -> SDL_GLContext pointer
|
|
SDL_GLContext ctx = (SDL_GLContext)ctxPtr;
|
|
int idx = -1;
|
|
for (int i = 0; i < s_sharedContextCount; ++i)
|
|
if (s_sharedContexts[i] == ctx) {
|
|
idx = i;
|
|
break;
|
|
}
|
|
if (idx >= 0 && s_sharedContextWindows[idx])
|
|
SDL_GL_MakeCurrent(s_sharedContextWindows[idx], ctx);
|
|
return;
|
|
}
|
|
|
|
// Grab a pre-created shared context from the pool
|
|
pthread_mutex_lock(&s_sharedCtxMutex);
|
|
SDL_GLContext shared = nullptr;
|
|
if (s_nextSharedContext < s_sharedContextCount) {
|
|
shared = s_sharedContexts[s_nextSharedContext++];
|
|
}
|
|
pthread_mutex_unlock(&s_sharedCtxMutex);
|
|
|
|
if (!shared) {
|
|
fprintf(stderr,
|
|
"[4J_Render] ERROR: no shared GL contexts left for worker "
|
|
"thread %lu!\n",
|
|
(unsigned long)pthread_self());
|
|
fflush(stderr);
|
|
return;
|
|
}
|
|
// ewww..... look at line 201-203, we gotta make a function for that....
|
|
int idx = -1;
|
|
for (int i = 0; i < s_sharedContextCount; ++i)
|
|
if (s_sharedContexts[i] == shared) {
|
|
idx = i;
|
|
break;
|
|
}
|
|
if (idx >= 0 && s_sharedContextWindows[idx])
|
|
SDL_GL_MakeCurrent(s_sharedContextWindows[idx], shared);
|
|
|
|
// Initialize some basic state for this context to ensure consistent display
|
|
// list recording
|
|
::glEnable(GL_TEXTURE_2D);
|
|
::glEnable(GL_DEPTH_TEST);
|
|
::glDepthFunc(GL_LEQUAL);
|
|
::glAlphaFunc(GL_GREATER, 0.1f);
|
|
::glEnable(GL_BLEND);
|
|
::glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
|
|
::glShadeModel(GL_SMOOTH);
|
|
::glEnable(GL_COLOR_MATERIAL);
|
|
::glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
|
|
|
|
pthread_setspecific(s_glCtxKey, (void*)shared);
|
|
fprintf(stderr,
|
|
"[4J_Render] Assigned shared GL context %p to worker thread %lu\n",
|
|
(void*)shared, (unsigned long)pthread_self());
|
|
fflush(stderr);
|
|
}
|
|
|
|
void C4JRender::StartFrame() {
|
|
if (!s_window) return;
|
|
int w, h;
|
|
SDL_GetWindowSize(s_window, &w, &h);
|
|
s_windowWidth = w > 0 ? w : 1;
|
|
s_windowHeight = h > 0 ? h : 1;
|
|
::glViewport(0, 0, s_windowWidth, s_windowHeight);
|
|
}
|
|
|
|
void C4JRender::Present() {
|
|
if (!s_window) return;
|
|
SDL_Event ev;
|
|
while (SDL_PollEvent(&ev)) {
|
|
if (ev.type == SDL_QUIT)
|
|
s_shouldClose = true;
|
|
else if (ev.type == SDL_WINDOWEVENT) {
|
|
if (ev.window.event == SDL_WINDOWEVENT_CLOSE)
|
|
s_shouldClose = true;
|
|
else if (ev.window.event == SDL_WINDOWEVENT_RESIZED)
|
|
onFramebufferResize(ev.window.data1, ev.window.data2);
|
|
}
|
|
}
|
|
// Present the rendered frame after processing input/events to avoid input
|
|
// timing issues
|
|
::glFlush();
|
|
// debug log to help diagnose mouse issues
|
|
// printf("[4J_Render] Presenting frame (mouse lock=%d)\n", s_mouseLocked);
|
|
// fflush(stdout);
|
|
SDL_GL_SwapWindow(s_window);
|
|
}
|
|
|
|
void C4JRender::SetWindowSize(int w, int h) {
|
|
s_reqWidth = (w > 0) ? w : 0;
|
|
s_reqHeight = (h > 0) ? h : 0;
|
|
}
|
|
|
|
void C4JRender::SetFullscreen(bool fs) { s_fullscreen = fs; }
|
|
|
|
bool C4JRender::ShouldClose() { return !s_window || s_shouldClose; }
|
|
|
|
void C4JRender::Close() { s_window = nullptr; }
|
|
|
|
void C4JRender::Shutdown() {
|
|
// Destroy the main window and clean up SDL resources so that
|
|
// destructors running after the game loop don't touch a dead context.
|
|
if (s_window) {
|
|
if (s_glContext) {
|
|
SDL_GL_DeleteContext(s_glContext);
|
|
s_glContext = nullptr;
|
|
}
|
|
SDL_DestroyWindow(s_window);
|
|
s_window = nullptr;
|
|
}
|
|
|
|
for (int i = 0; i < s_sharedContextCount; ++i) {
|
|
if (s_sharedContexts[i]) {
|
|
SDL_GL_DeleteContext(s_sharedContexts[i]);
|
|
s_sharedContexts[i] = 0;
|
|
}
|
|
if (s_sharedContextWindows[i]) {
|
|
SDL_DestroyWindow(s_sharedContextWindows[i]);
|
|
s_sharedContextWindows[i] = nullptr;
|
|
}
|
|
}
|
|
s_sharedContextCount = 0;
|
|
SDL_Quit();
|
|
}
|
|
|
|
// rip glfw. you won't be missed. (i hope)
|
|
void C4JRender::DoScreenGrabOnNextPresent() {}
|
|
|
|
void C4JRender::Clear(int flags) { ::glClear(flags); }
|
|
|
|
void C4JRender::SetClearColour(const float colourRGBA[4]) {
|
|
::glClearColor(colourRGBA[0], colourRGBA[1], colourRGBA[2], colourRGBA[3]);
|
|
}
|
|
|
|
bool C4JRender::IsWidescreen() { return true; }
|
|
bool C4JRender::IsHiDef() { return true; }
|
|
void C4JRender::GetFramebufferSize(int& width, int& height) {
|
|
width = s_windowWidth;
|
|
height = s_windowHeight;
|
|
}
|
|
void C4JRender::CaptureThumbnail(ImageFileBuffer*) {}
|
|
void C4JRender::CaptureScreen(ImageFileBuffer*, XSOCIAL_PREVIEWIMAGE*) {}
|
|
void C4JRender::BeginConditionalSurvey(int) {}
|
|
void C4JRender::EndConditionalSurvey() {}
|
|
void C4JRender::BeginConditionalRendering(int) {}
|
|
void C4JRender::EndConditionalRendering() {}
|
|
|
|
void C4JRender::MatrixMode(int type) { ::glMatrixMode(type); }
|
|
void C4JRender::MatrixSetIdentity() { ::glLoadIdentity(); }
|
|
void C4JRender::MatrixTranslate(float x, float y, float z) {
|
|
::glTranslatef(x, y, z);
|
|
}
|
|
|
|
void C4JRender::MatrixRotate(float angle, float x, float y, float z) {
|
|
// We use math from the math lib instead of hardcoding it. How Ugly.
|
|
::glRotatef(angle * (180.0f / static_cast<float>(M_PI)), x, y, z);
|
|
}
|
|
|
|
void C4JRender::MatrixScale(float x, float y, float z) { ::glScalef(x, y, z); }
|
|
|
|
void C4JRender::MatrixPerspective(float fovy, float aspect, float zNear,
|
|
float zFar) {
|
|
::gluPerspective((double)fovy, (double)aspect, (double)zNear, (double)zFar);
|
|
}
|
|
|
|
void C4JRender::MatrixOrthogonal(float left, float right, float bottom,
|
|
float top, float zNear, float zFar) {
|
|
::glOrtho(left, right, bottom, top, zNear, zFar);
|
|
}
|
|
|
|
void C4JRender::MatrixPop() { ::glPopMatrix(); }
|
|
void C4JRender::MatrixPush() { ::glPushMatrix(); }
|
|
void C4JRender::MatrixMult(float* mat) { ::glMultMatrixf(mat); }
|
|
|
|
const float* C4JRender::MatrixGet(int type) {
|
|
static float mat[16];
|
|
::glGetFloatv(type, mat);
|
|
return mat;
|
|
}
|
|
|
|
void C4JRender::Set_matrixDirty() {} // immediate-mode
|
|
|
|
static GLenum mapPrimType(int pt) {
|
|
// Handle GL constants first
|
|
if (pt == GL_QUADS) return GL_QUADS;
|
|
if (pt == GL_TRIANGLES) return GL_TRIANGLES;
|
|
if (pt == GL_LINES) return GL_LINES;
|
|
if (pt == GL_LINE_STRIP) return GL_LINE_STRIP;
|
|
if (pt == GL_TRIANGLE_STRIP) return GL_TRIANGLE_STRIP;
|
|
if (pt == GL_TRIANGLE_FAN) return GL_TRIANGLE_FAN;
|
|
|
|
// Map from ePrimitiveType enum
|
|
switch (pt) {
|
|
case C4JRender::PRIMITIVE_TYPE_TRIANGLE_LIST:
|
|
return GL_TRIANGLES;
|
|
case C4JRender::PRIMITIVE_TYPE_TRIANGLE_STRIP:
|
|
return GL_TRIANGLE_STRIP;
|
|
case C4JRender::PRIMITIVE_TYPE_TRIANGLE_FAN:
|
|
return GL_TRIANGLE_FAN;
|
|
case C4JRender::PRIMITIVE_TYPE_QUAD_LIST:
|
|
return GL_QUADS;
|
|
case C4JRender::PRIMITIVE_TYPE_LINE_LIST:
|
|
return GL_LINES;
|
|
case C4JRender::PRIMITIVE_TYPE_LINE_STRIP:
|
|
return GL_LINE_STRIP;
|
|
default:
|
|
return GL_TRIANGLES;
|
|
}
|
|
}
|
|
|
|
// This is the clientside vertex processing.
|
|
void C4JRender::DrawVertices(ePrimitiveType PrimitiveType, int count,
|
|
void* dataIn, eVertexType vType,
|
|
C4JRender::ePixelShaderType psType) {
|
|
if (count <= 0 || !dataIn) return;
|
|
|
|
// trash trash trash trash
|
|
pthread_mutex_lock(&s_glCallMutex);
|
|
|
|
GLenum mode = mapPrimType((int)PrimitiveType);
|
|
|
|
if (vType == VERTEX_TYPE_COMPRESSED) {
|
|
int16_t* sdata = (int16_t*)dataIn;
|
|
::glBegin(mode);
|
|
for (int i = 0; i < count; i++) {
|
|
int16_t* vert = sdata + i * 8;
|
|
|
|
float x = vert[0] / 1024.0f;
|
|
float y = vert[1] / 1024.0f;
|
|
float z = vert[2] / 1024.0f;
|
|
|
|
// Unpack RGB565 colour (Tesselator stores as packedcol - 32768 to
|
|
// fit in int16)
|
|
unsigned short packedColor = (unsigned short)((int)vert[3] + 32768);
|
|
float r = ((packedColor >> 11) & 0x1f) / 31.0f;
|
|
float g = ((packedColor >> 5) & 0x3f) / 63.0f;
|
|
float b = (packedColor & 0x1f) / 31.0f;
|
|
|
|
float fu = vert[4] / 8192.0f;
|
|
float fv = vert[5] / 8192.0f;
|
|
// Tesselator does that. Thanks 4J.
|
|
if (fu >= 1.0f) fu -= 1.0f;
|
|
|
|
// Unit 1 (lightmap) UVs
|
|
float fu2 = (float)vert[6] / 256.0f;
|
|
float fv2 = (float)vert[7] / 256.0f;
|
|
|
|
::glColor3f(r, g, b);
|
|
::glTexCoord2f(fu, fv);
|
|
::glMultiTexCoord2f(GL_TEXTURE1, fu2, fv2);
|
|
::glVertex3f(x, y, z);
|
|
}
|
|
::glEnd();
|
|
} else {
|
|
unsigned int* idata = (unsigned int*)dataIn;
|
|
::glBegin(mode);
|
|
for (int i = 0; i < count; i++) {
|
|
float* fdata = (float*)(idata + i * 8);
|
|
|
|
unsigned int colorInt = idata[i * 8 + 5];
|
|
unsigned char cr = (colorInt >> 24) & 0xFF;
|
|
unsigned char cg = (colorInt >> 16) & 0xFF;
|
|
unsigned char cb = (colorInt >> 8) & 0xFF;
|
|
unsigned char ca = colorInt & 0xFF;
|
|
|
|
unsigned int normalInt = idata[i * 8 + 6];
|
|
int8_t nx = (int8_t)(normalInt & 0xFF);
|
|
int8_t ny = (int8_t)((normalInt >> 8) & 0xFF);
|
|
int8_t nz = (int8_t)((normalInt >> 16) & 0xFF);
|
|
|
|
unsigned int tex2Int = idata[i * 8 + 7];
|
|
|
|
if (nx != 0 || ny != 0 || nz != 0) {
|
|
::glNormal3f(nx / 127.0f, ny / 127.0f, nz / 127.0f);
|
|
}
|
|
|
|
// This breaks particle colors.. i think. fixme!
|
|
if (colorInt != 0) {
|
|
::glColor4ub(cr, cg, cb, ca);
|
|
}
|
|
|
|
::glTexCoord2f(fdata[3], fdata[4]);
|
|
|
|
// Unit 1 (lightmap) UVs - 0xfe00fe00 is sentinel for "no Unit 1
|
|
// UVs" Ugly hack, replace soon.
|
|
if (tex2Int != 0xfe00fe00) {
|
|
float u2 = (float)(short)(tex2Int & 0xFFFF) / 256.0f;
|
|
float v2 = (float)(short)((tex2Int >> 16) & 0xFFFF) / 256.0f;
|
|
::glMultiTexCoord2f(GL_TEXTURE1, u2, v2);
|
|
}
|
|
|
|
::glVertex3f(fdata[0], fdata[1], fdata[2]);
|
|
}
|
|
::glEnd();
|
|
}
|
|
::glFlush();
|
|
|
|
pthread_mutex_unlock(&s_glCallMutex);
|
|
}
|
|
|
|
void C4JRender::CBuffLockStaticCreations() {}
|
|
|
|
int C4JRender::CBuffCreate(int count) {
|
|
int id = (int)::glGenLists(count);
|
|
::glFlush();
|
|
return id;
|
|
}
|
|
|
|
void C4JRender::CBuffDelete(int first, int count) {
|
|
if (first > 0 && count > 0) {
|
|
::glDeleteLists(first, count);
|
|
::glFlush();
|
|
}
|
|
}
|
|
|
|
void C4JRender::CBuffStart(int index, bool /*full*/) {
|
|
if (index > 0) {
|
|
::glNewList(index, GL_COMPILE);
|
|
::glFlush();
|
|
}
|
|
}
|
|
|
|
void C4JRender::CBuffClear(int index) {
|
|
if (index > 0) {
|
|
::glNewList(index, GL_COMPILE);
|
|
::glEndList();
|
|
::glFlush();
|
|
}
|
|
}
|
|
|
|
int C4JRender::CBuffSize(int /*index*/) { return 0; }
|
|
|
|
void C4JRender::CBuffEnd() {
|
|
::glEndList();
|
|
::glFlush();
|
|
}
|
|
|
|
bool C4JRender::CBuffCall(int index, bool /*full*/) {
|
|
if (index <= 0) return false;
|
|
if (::glIsList(index)) {
|
|
::glCallList(index);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void C4JRender::CBuffTick() {}
|
|
void C4JRender::CBuffDeferredModeStart() {}
|
|
void C4JRender::CBuffDeferredModeEnd() {}
|
|
|
|
int C4JRender::TextureCreate() {
|
|
GLuint id = 0;
|
|
::glGenTextures(1, &id);
|
|
return (int)id;
|
|
}
|
|
|
|
void C4JRender::TextureFree(int idx) {
|
|
GLuint id = (GLuint)idx;
|
|
::glDeleteTextures(1, &id);
|
|
}
|
|
|
|
void C4JRender::TextureBind(int idx) {
|
|
if (idx < 0) {
|
|
::glBindTexture(GL_TEXTURE_2D, 0);
|
|
} else {
|
|
::glBindTexture(GL_TEXTURE_2D, (GLuint)idx);
|
|
}
|
|
}
|
|
|
|
void C4JRender::TextureBindVertex(int idx, bool scaleLight) {
|
|
// Unit 1 used for lightmapping in fixed-function or standard shaders
|
|
::glActiveTexture(GL_TEXTURE1);
|
|
if (idx < 0) {
|
|
::glBindTexture(GL_TEXTURE_2D, 0);
|
|
::glDisable(GL_TEXTURE_2D);
|
|
} else {
|
|
::glEnable(GL_TEXTURE_2D);
|
|
::glBindTexture(GL_TEXTURE_2D, (GLuint)idx);
|
|
::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
|
|
::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
|
::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
|
|
::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
|
|
|
|
// 4jcraft: jank workaround for entities
|
|
// referenced from the disabled code in GameRenderer::turnOnLightLayer
|
|
if (scaleLight) {
|
|
::glMatrixMode(GL_TEXTURE);
|
|
::glLoadIdentity();
|
|
float s = 1 / 16.0f / 15.0f * 15 / 16;
|
|
::glScalef(s, s, s);
|
|
::glTranslatef(8.0f, 8.0f, 8.0f);
|
|
::glMatrixMode(GL_MODELVIEW);
|
|
}
|
|
}
|
|
|
|
::glActiveTexture(GL_TEXTURE0);
|
|
::glFlush();
|
|
}
|
|
|
|
void C4JRender::TextureSetTextureLevels(int levels) {
|
|
// base level is always 0, no mipmaps sadly. I'll add them later.
|
|
::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL,
|
|
levels > 0 ? levels - 1 : 0);
|
|
s_textureLevels = levels;
|
|
}
|
|
int C4JRender::TextureGetTextureLevels() { return s_textureLevels; }
|
|
|
|
void C4JRender::TextureData(int width, int height, void* data, int level,
|
|
eTextureFormat /*format*/) {
|
|
// TODO: Check if correct format.
|
|
::glTexImage2D(GL_TEXTURE_2D, level, GL_RGBA, width, height, 0, GL_RGBA,
|
|
GL_UNSIGNED_BYTE, data);
|
|
|
|
::glFlush();
|
|
|
|
if (level == 0) {
|
|
::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0);
|
|
::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
|
|
::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
|
|
}
|
|
}
|
|
|
|
void C4JRender::TextureDataUpdate(int xoffset, int yoffset, int width,
|
|
int height, void* data, int level) {
|
|
::glTexSubImage2D(GL_TEXTURE_2D, level, xoffset, yoffset, width, height,
|
|
GL_RGBA, GL_UNSIGNED_BYTE, data);
|
|
::glFlush();
|
|
}
|
|
|
|
void C4JRender::TextureSetParam(int param, int value) {
|
|
::glTexParameteri(GL_TEXTURE_2D, param, value);
|
|
}
|
|
|
|
void C4JRender::TextureDynamicUpdateStart() {}
|
|
void C4JRender::TextureDynamicUpdateEnd() {}
|
|
|
|
void C4JRender::Tick() {}
|
|
void C4JRender::UpdateGamma(unsigned short) {}
|
|
|
|
// Converts RGBA data to the format expected by the texture loader.
|
|
static HRESULT LoadFromSTB(unsigned char* data, int width, int height,
|
|
D3DXIMAGE_INFO* pSrcInfo, int** ppDataOut) {
|
|
int pixelCount = width * height;
|
|
int* pixels = new int[pixelCount];
|
|
|
|
for (int i = 0; i < pixelCount; i++) {
|
|
unsigned char r = data[i * 4 + 0];
|
|
unsigned char g = data[i * 4 + 1];
|
|
unsigned char b = data[i * 4 + 2];
|
|
unsigned char a = data[i * 4 + 3];
|
|
|
|
// pixels[i] = (a << 24) | (b << 16) | (g << 8) | r;
|
|
pixels[i] = (a << 24) | (r << 16) | (g << 8) | b;
|
|
}
|
|
|
|
if (pSrcInfo) {
|
|
pSrcInfo->Width = width;
|
|
pSrcInfo->Height = height;
|
|
}
|
|
|
|
*ppDataOut = pixels;
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT C4JRender::LoadTextureData(const char* szFilename,
|
|
D3DXIMAGE_INFO* pSrcInfo, int** ppDataOut) {
|
|
int width, height, channels;
|
|
|
|
unsigned char* data = stbi_load(szFilename, &width, &height, &channels, 4);
|
|
if (!data) return E_FAIL;
|
|
|
|
HRESULT hr = LoadFromSTB(data, width, height, pSrcInfo, ppDataOut);
|
|
|
|
stbi_image_free(data);
|
|
return hr;
|
|
}
|
|
|
|
HRESULT C4JRender::LoadTextureData(std::uint8_t* pbData,
|
|
std::uint32_t byteCount,
|
|
D3DXIMAGE_INFO* pSrcInfo, int** ppDataOut) {
|
|
int width, height, channels;
|
|
|
|
unsigned char* data =
|
|
stbi_load_from_memory(pbData, byteCount, &width, &height, &channels, 4);
|
|
if (!data) return E_FAIL;
|
|
|
|
HRESULT hr = LoadFromSTB(data, width, height, pSrcInfo, ppDataOut);
|
|
|
|
stbi_image_free(data);
|
|
return hr;
|
|
}
|
|
|
|
HRESULT C4JRender::SaveTextureData(const char* szFilename,
|
|
D3DXIMAGE_INFO* pSrcInfo, int* ppDataOut) {
|
|
return S_OK;
|
|
}
|
|
HRESULT C4JRender::SaveTextureDataToMemory(void* pOutput, int outputCapacity,
|
|
int* outputLength, int width,
|
|
int height, int* ppDataIn) {
|
|
return S_OK;
|
|
}
|
|
void C4JRender::TextureGetStats() {}
|
|
void* C4JRender::TextureGetTexture(int idx) { return nullptr; }
|
|
|
|
void C4JRender::StateSetColour(float r, float g, float b, float a) {
|
|
::glColor4f(r, g, b, a);
|
|
}
|
|
|
|
void C4JRender::StateSetDepthMask(bool enable) {
|
|
::glDepthMask(enable ? GL_TRUE : GL_FALSE);
|
|
}
|
|
|
|
void C4JRender::StateSetBlendEnable(bool enable) {
|
|
if (enable)
|
|
::glEnable(GL_BLEND);
|
|
else
|
|
::glDisable(GL_BLEND);
|
|
}
|
|
|
|
void C4JRender::StateSetBlendFunc(int src, int dst) { ::glBlendFunc(src, dst); }
|
|
|
|
void C4JRender::StateSetBlendFactor(unsigned int colour) {
|
|
// colour is 0xAARRGGBB packed
|
|
float a = ((colour >> 24) & 0xFF) / 255.0f;
|
|
float r = ((colour >> 16) & 0xFF) / 255.0f;
|
|
float g = ((colour >> 8) & 0xFF) / 255.0f;
|
|
float b = (colour & 0xFF) / 255.0f;
|
|
::glBlendColor(r, g, b, a);
|
|
}
|
|
|
|
void C4JRender::StateSetAlphaFunc(int func, float param) {
|
|
::glAlphaFunc(func, param);
|
|
}
|
|
|
|
void C4JRender::StateSetDepthFunc(int func) { ::glDepthFunc(func); }
|
|
|
|
void C4JRender::StateSetFaceCull(bool enable) {
|
|
if (enable)
|
|
::glEnable(GL_CULL_FACE);
|
|
else
|
|
::glDisable(GL_CULL_FACE);
|
|
}
|
|
|
|
void C4JRender::StateSetFaceCullCW(bool enable) {
|
|
::glFrontFace(enable ? GL_CW : GL_CCW);
|
|
}
|
|
|
|
void C4JRender::StateSetLineWidth(float width) { ::glLineWidth(width); }
|
|
|
|
void C4JRender::StateSetWriteEnable(bool red, bool green, bool blue,
|
|
bool alpha) {
|
|
::glColorMask(red, green, blue, alpha);
|
|
}
|
|
|
|
void C4JRender::StateSetDepthTestEnable(bool enable) {
|
|
if (enable)
|
|
::glEnable(GL_DEPTH_TEST);
|
|
else
|
|
::glDisable(GL_DEPTH_TEST);
|
|
}
|
|
|
|
void C4JRender::StateSetAlphaTestEnable(bool enable) {
|
|
if (enable)
|
|
::glEnable(GL_ALPHA_TEST);
|
|
else
|
|
::glDisable(GL_ALPHA_TEST);
|
|
}
|
|
|
|
void C4JRender::StateSetDepthSlopeAndBias(float slope, float bias) {
|
|
if (slope != 0.0f || bias != 0.0f) {
|
|
::glEnable(GL_POLYGON_OFFSET_FILL);
|
|
::glPolygonOffset(slope, bias);
|
|
} else {
|
|
::glDisable(GL_POLYGON_OFFSET_FILL);
|
|
}
|
|
}
|
|
|
|
void C4JRender::StateSetFogEnable(bool enable) {
|
|
if (enable)
|
|
::glEnable(GL_FOG);
|
|
else
|
|
::glDisable(GL_FOG);
|
|
}
|
|
|
|
void C4JRender::StateSetFogMode(int mode) { ::glFogi(GL_FOG_MODE, mode); }
|
|
|
|
void C4JRender::StateSetFogNearDistance(float dist) {
|
|
::glFogf(GL_FOG_START, dist);
|
|
}
|
|
|
|
void C4JRender::StateSetFogFarDistance(float dist) {
|
|
::glFogf(GL_FOG_END, dist);
|
|
}
|
|
|
|
void C4JRender::StateSetFogDensity(float density) {
|
|
::glFogf(GL_FOG_DENSITY, density);
|
|
}
|
|
|
|
void C4JRender::StateSetFogColour(float red, float green, float blue) {
|
|
float c[4] = {red, green, blue, 1.0f};
|
|
::glFogfv(GL_FOG_COLOR, c);
|
|
}
|
|
|
|
void C4JRender::StateSetLightingEnable(bool enable) {
|
|
if (enable) {
|
|
::glEnable(GL_LIGHTING);
|
|
// Enable color material so glColor calls set material ambient+diffuse
|
|
::glEnable(GL_COLOR_MATERIAL);
|
|
::glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
|
|
} else {
|
|
::glDisable(GL_LIGHTING);
|
|
::glDisable(GL_COLOR_MATERIAL);
|
|
}
|
|
}
|
|
|
|
void C4JRender::StateSetVertexTextureUV(float u, float v) {
|
|
::glMultiTexCoord2f(GL_TEXTURE1, u, v);
|
|
}
|
|
|
|
void C4JRender::StateSetLightColour(int light, float red, float green,
|
|
float blue) {
|
|
float diffuse[4] = {red, green, blue, 1.0f};
|
|
::glLightfv(GL_LIGHT0 + light, GL_DIFFUSE, diffuse);
|
|
}
|
|
|
|
void C4JRender::StateSetLightAmbientColour(float red, float green, float blue) {
|
|
float ambient[4] = {red, green, blue, 1.0f};
|
|
float model[4] = {red, green, blue, 1.0f};
|
|
::glLightModelfv(GL_LIGHT_MODEL_AMBIENT, model);
|
|
::glLightfv(GL_LIGHT0, GL_AMBIENT, ambient);
|
|
}
|
|
|
|
void C4JRender::StateSetLightDirection(int light, float x, float y, float z) {
|
|
float dir[4] = {x, y, z,
|
|
0.0f}; // TODO: Java seems to do the reverse, gotta check.
|
|
::glLightfv(GL_LIGHT0 + light, GL_POSITION, dir);
|
|
}
|
|
|
|
void C4JRender::StateSetLightEnable(int light, bool enable) {
|
|
GLenum l = GL_LIGHT0 + light;
|
|
if (enable)
|
|
::glEnable(l);
|
|
else
|
|
::glDisable(l);
|
|
}
|
|
|
|
void C4JRender::StateSetViewport(eViewportType viewportType) {
|
|
// Use the full framebuffer for all viewport types
|
|
::glViewport(0, 0, s_windowWidth, s_windowHeight);
|
|
}
|
|
|
|
void C4JRender::StateSetEnableViewportClipPlanes(bool enable) {
|
|
// Clip planes not commonly used in the legacy path
|
|
if (enable)
|
|
::glEnable(GL_CLIP_PLANE0);
|
|
else
|
|
::glDisable(GL_CLIP_PLANE0);
|
|
}
|
|
|
|
void C4JRender::StateSetTexGenCol(int col, float x, float y, float z, float w,
|
|
bool eyeSpace) {
|
|
GLenum coord;
|
|
switch (col) {
|
|
case 0:
|
|
coord = GL_S;
|
|
break;
|
|
case 1:
|
|
coord = GL_T;
|
|
break;
|
|
case 2:
|
|
coord = GL_R;
|
|
break;
|
|
case 3:
|
|
coord = GL_Q;
|
|
break;
|
|
default:
|
|
coord = GL_S;
|
|
break;
|
|
}
|
|
float plane[4] = {x, y, z, w};
|
|
GLenum planeMode = eyeSpace ? GL_EYE_PLANE : GL_OBJECT_PLANE;
|
|
::glTexGeni(coord, GL_TEXTURE_GEN_MODE,
|
|
eyeSpace ? GL_EYE_LINEAR : GL_OBJECT_LINEAR);
|
|
::glTexGenfv(coord, planeMode, plane);
|
|
}
|
|
|
|
void C4JRender::StateSetStencil(int Function, uint8_t stencil_ref,
|
|
uint8_t stencil_func_mask,
|
|
uint8_t stencil_write_mask) {
|
|
::glEnable(GL_STENCIL_TEST);
|
|
::glStencilFunc(Function, stencil_ref, stencil_func_mask);
|
|
::glStencilMask(stencil_write_mask);
|
|
}
|
|
|
|
void C4JRender::StateSetForceLOD(int LOD) {} // No LOD bias in legacy GL path
|
|
|
|
void C4JRender::BeginEvent(LPCWSTR eventName) {}
|
|
void C4JRender::EndEvent() {}
|
|
void C4JRender::Suspend() {}
|
|
bool C4JRender::Suspended() { return false; }
|
|
void C4JRender::Resume() {}
|