mirror of https://github.com/mode777/rayjs.git
233 lines
6.3 KiB
C
233 lines
6.3 KiB
C
|
#ifndef RLIGHTMAPPER_H
|
||
|
#define RLIGHTMAPPER_H
|
||
|
|
||
|
#include <raylib.h>
|
||
|
|
||
|
typedef struct Lightmapper {
|
||
|
void * lm_handle;
|
||
|
float * data;
|
||
|
int w;
|
||
|
int h;
|
||
|
float progress;
|
||
|
} Lightmapper;
|
||
|
|
||
|
typedef struct LightmapperConfig {
|
||
|
int hemisphereSize;
|
||
|
float zNear;
|
||
|
float zFar;
|
||
|
Color backgroundColor;
|
||
|
int interpolationPasses;
|
||
|
float interpolationThreshold;
|
||
|
float cameraToSurfaceDistanceModifier;
|
||
|
} LightmapperConfig;
|
||
|
|
||
|
LightmapperConfig GetDefaultLightmapperConfig();
|
||
|
Lightmapper LoadLightmapper(int w, int h, Mesh mesh, LightmapperConfig cfg);
|
||
|
Material LoadMaterialLightmapper(Color emissiveColor, float intensity);
|
||
|
void UnloadLightmapper(Lightmapper lm);
|
||
|
void BeginLightmap();
|
||
|
void EndLightmap();
|
||
|
bool BeginLightmapFragment(Lightmapper * lm);
|
||
|
void EndLightmapFragment(Lightmapper * lm);
|
||
|
Image LoadImageFromLightmapper(Lightmapper lm);
|
||
|
|
||
|
|
||
|
#endif
|
||
|
|
||
|
#if defined(RLIGHTMAPPER_IMPLEMENTATION)
|
||
|
|
||
|
#define LIGHTMAPPER_IMPLEMENTATION
|
||
|
//#define LM_DEBUG_INTERPOLATION
|
||
|
#include "lightmapper.h"
|
||
|
|
||
|
static const char* fs =
|
||
|
"#version 330\n"
|
||
|
"in vec2 fragTexCoord;\n"
|
||
|
"in vec4 fragColor;\n"
|
||
|
"out vec4 finalColor;\n"
|
||
|
"uniform sampler2D texture0;\n"
|
||
|
"uniform vec4 colDiffuse;\n"
|
||
|
"void main()\n"
|
||
|
"{\n"
|
||
|
" vec4 texelColor = texture(texture0, fragTexCoord);\n"
|
||
|
" texelColor = texelColor * colDiffuse * fragColor * vec4(intensity, intensity, intensity, 1.0);\n"
|
||
|
" finalColor = vec4(texelColor.rgb, (gl_FrontFacing ? 1.0 : 0.0));\n"
|
||
|
"}";
|
||
|
|
||
|
const char* vs = "#version 330\n"
|
||
|
"in vec3 vertexPosition;\n"
|
||
|
"in vec2 vertexTexCoord;\n"
|
||
|
"in vec4 vertexColor;\n"
|
||
|
"out vec2 fragTexCoord;\n"
|
||
|
"out vec4 fragColor;\n"
|
||
|
"uniform mat4 mvp;\n"
|
||
|
"void main()\n"
|
||
|
"{\n"
|
||
|
" fragTexCoord = vertexTexCoord;\n"
|
||
|
" fragColor = vertexColor;\n"
|
||
|
" gl_Position = mvp * vec4(vertexPosition, 1.0);\n"
|
||
|
"}";
|
||
|
|
||
|
static void FloatVToMatrix(float *array, struct Matrix *matrix) {
|
||
|
matrix->m0 = array[0];
|
||
|
matrix->m1 = array[1];
|
||
|
matrix->m2 = array[2];
|
||
|
matrix->m3 = array[3];
|
||
|
matrix->m4 = array[4];
|
||
|
matrix->m5 = array[5];
|
||
|
matrix->m6 = array[6];
|
||
|
matrix->m7 = array[7];
|
||
|
matrix->m8 = array[8];
|
||
|
matrix->m9 = array[9];
|
||
|
matrix->m10 = array[10];
|
||
|
matrix->m11 = array[11];
|
||
|
matrix->m12 = array[12];
|
||
|
matrix->m13 = array[13];
|
||
|
matrix->m14 = array[14];
|
||
|
matrix->m15 = array[15];
|
||
|
}
|
||
|
|
||
|
LightmapperConfig GetDefaultLightmapperConfig(){
|
||
|
return (LightmapperConfig){
|
||
|
64, 0.001f, 100.0f, WHITE, 2, 0.01f, 0.0f
|
||
|
};
|
||
|
}
|
||
|
|
||
|
static Shader defaultShader;
|
||
|
|
||
|
Material LoadMaterialLightmapper(Color emissiveColor, float emissiveIntensity)
|
||
|
{
|
||
|
if(defaultShader.id == 0) defaultShader = LoadShaderFromMemory(vs, fs);
|
||
|
|
||
|
Material mat = LoadMaterialDefault();
|
||
|
mat.shader = defaultShader;
|
||
|
mat.maps[MATERIAL_MAP_DIFFUSE].color = emissiveColor; // Diffuse color
|
||
|
//mat.params[0] = emissiveIntensity;
|
||
|
return mat;
|
||
|
}
|
||
|
|
||
|
|
||
|
Lightmapper LoadLightmapper(int w, int h, Mesh mesh, LightmapperConfig cfg){
|
||
|
Lightmapper lm = {0};
|
||
|
lm_context* ctx = lm.lm_handle = lmCreate(cfg.hemisphereSize, cfg.zNear, cfg.zFar,
|
||
|
cfg.backgroundColor.r / (float)255, cfg.backgroundColor.g / (float)255, cfg.backgroundColor.b / (float)255,
|
||
|
cfg.interpolationPasses, cfg.interpolationThreshold, cfg.cameraToSurfaceDistanceModifier);
|
||
|
|
||
|
if(ctx == NULL){
|
||
|
TraceLog(LOG_ERROR, "Unable to create lightmapper. Init failed.");
|
||
|
goto RETURN;
|
||
|
}
|
||
|
|
||
|
lm.w = w;
|
||
|
lm.h = h;
|
||
|
float *data = lm.data = calloc(w * h * 4, sizeof(float));
|
||
|
lmSetTargetLightmap(ctx, data, w, h, 4);
|
||
|
|
||
|
const void* indices = NULL;
|
||
|
lm_type indicesType = LM_NONE;
|
||
|
int count = mesh.vertexCount;
|
||
|
if(mesh.indices != NULL){
|
||
|
indices = mesh.indices;
|
||
|
indicesType = LM_UNSIGNED_SHORT;
|
||
|
count = mesh.triangleCount * 3;
|
||
|
}
|
||
|
|
||
|
lmSetGeometry(ctx, NULL,
|
||
|
LM_FLOAT, (unsigned char*)mesh.vertices, 0,
|
||
|
LM_FLOAT , (unsigned char*)mesh.normals, 0,
|
||
|
LM_FLOAT, (unsigned char*)mesh.texcoords, 0,
|
||
|
count, indicesType, indices);
|
||
|
|
||
|
RETURN:
|
||
|
return lm;
|
||
|
}
|
||
|
|
||
|
void UnloadLightmapper(Lightmapper lm){
|
||
|
free(lm.data);
|
||
|
lmDestroy((lm_context *)lm.lm_handle);
|
||
|
}
|
||
|
|
||
|
static Matrix mProjection;
|
||
|
static Matrix mModelview;
|
||
|
|
||
|
void BeginLightmap()
|
||
|
{
|
||
|
rlEnableDepthTest();
|
||
|
rlDisableColorBlend();
|
||
|
rlDisableBackfaceCulling();
|
||
|
mProjection = rlGetMatrixProjection();
|
||
|
mModelview = rlGetMatrixModelview();
|
||
|
}
|
||
|
|
||
|
void EndLightmap(){
|
||
|
//rlDisableDepthTest();
|
||
|
rlEnableColorBlend();
|
||
|
rlEnableBackfaceCulling();
|
||
|
int w = GetScreenWidth() * GetWindowScaleDPI().x;
|
||
|
int h = GetScreenHeight() * GetWindowScaleDPI().y;
|
||
|
rlViewport(0, 0, w, h);
|
||
|
rlDisableFramebuffer();
|
||
|
glUseProgram(0);
|
||
|
glBindTexture(GL_TEXTURE_2D, 0);
|
||
|
glBindBuffer(GL_PIXEL_PACK_BUFFER, 0);
|
||
|
glBindVertexArray(0);
|
||
|
glBindFramebuffer(GL_FRAMEBUFFER, 0);
|
||
|
glBindFramebuffer(GL_READ_FRAMEBUFFER, 0);
|
||
|
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
|
||
|
rlSetMatrixModelview(mModelview);
|
||
|
rlSetMatrixProjection(mProjection);
|
||
|
}
|
||
|
|
||
|
static int vp[4];
|
||
|
static float view[16], projection[16];
|
||
|
static Matrix matView, matProj;
|
||
|
|
||
|
bool BeginLightmapFragment(Lightmapper * lm){
|
||
|
lm_bool status = lmBegin((lm_context *)lm->lm_handle, vp, view, projection);
|
||
|
if(status){
|
||
|
rlViewport(vp[0], vp[1], vp[2], vp[3]);
|
||
|
FloatVToMatrix(view, &matView);
|
||
|
FloatVToMatrix(projection, &matProj);
|
||
|
rlSetMatrixModelview(matView);
|
||
|
rlSetMatrixProjection(matProj);
|
||
|
} else {
|
||
|
lm->progress = 1.0f;
|
||
|
}
|
||
|
return (bool)status;
|
||
|
}
|
||
|
|
||
|
void EndLightmapFragment(Lightmapper * lm){
|
||
|
lm->progress = lmProgress((lm_context *)lm->lm_handle);
|
||
|
lmEnd((lm_context *)lm->lm_handle);
|
||
|
}
|
||
|
|
||
|
Image LoadImageFromLightmapper(Lightmapper lm){
|
||
|
Image im = { 0 };
|
||
|
|
||
|
if(lm.progress < 1.0f){
|
||
|
TraceLog(LOG_ERROR, "Lightmapping is not finished");
|
||
|
return im;
|
||
|
}
|
||
|
// postprocess texture
|
||
|
float *temp = calloc(lm.w * lm.h * 4, sizeof(float));
|
||
|
for (int i = 0; i < 16; i++)
|
||
|
{
|
||
|
lmImageDilate(lm.data, temp, lm.w, lm.h, 4);
|
||
|
lmImageDilate(temp, lm.data, lm.w, lm.h, 4);
|
||
|
}
|
||
|
lmImageSmooth(lm.data, temp, lm.w, lm.h, 4);
|
||
|
lmImageDilate(temp, lm.data, lm.w, lm.h, 4);
|
||
|
lmImagePower(lm.data, lm.w, lm.h, 4, 1.0f / 2.2f, 0x7); // gamma correct color channels
|
||
|
free(temp);
|
||
|
|
||
|
unsigned char *tempub = (unsigned char*)calloc(lm.w * lm.h * 4, sizeof(unsigned char));
|
||
|
lmImageFtoUB(lm.data, tempub, lm.w, lm.h, 4, 1.0f);
|
||
|
|
||
|
im.data = tempub;
|
||
|
im.format = PIXELFORMAT_UNCOMPRESSED_R8G8B8A8;
|
||
|
im.height = lm.w;
|
||
|
im.width = lm.h;
|
||
|
im.mipmaps = 1;
|
||
|
return im;
|
||
|
}
|
||
|
#endif
|