paysages3d/lib_paysages/render.c

840 lines
20 KiB
C
Raw Normal View History

#include "render.h"
#include <stdlib.h>
#include <math.h>
#include "IL/il.h"
#include "IL/ilu.h"
#include "shared/types.h"
#include "shared/constants.h"
#include "shared/functions.h"
#include "system.h"
int render_width;
int render_height;
int render_quality;
static int _pixel_count;
static Array* render_zone = NULL;
static RenderFragment* scanline_up;
static RenderFragment* scanline_down;
static int scanline_left;
static int scanline_right;
static Color background_color;
static volatile int _dirty_left;
static volatile int _dirty_right;
static volatile int _dirty_up;
static volatile int _dirty_down;
static volatile int _dirty_count;
static Mutex* _lock;
static volatile int _interrupt = 0;
static volatile int _progress_pixels;
static volatile double _progress = 0.0;
static volatile double _progress_step_start = 0.0;
static volatile double _progress_step_length = 1.0;
#define RENDER_INVERSE 1
#define RENDER_WIREFRAME 1
static void _previewResize(int width, int height) {}
static void _previewClear(Color col) {}
static void _previewDraw(int x, int y, Color col) {}
static void _previewUpdate(double progress) {}
static PreviewCallbackResize _cb_preview_resize = _previewResize;
static PreviewCallbackClear _cb_preview_clear = _previewClear;
static PreviewCallbackDraw _cb_preview_draw = _previewDraw;
static PreviewCallbackUpdate _cb_preview_update = _previewUpdate;
void renderSave(FILE* f)
{
}
void renderLoad(FILE* f)
{
}
void renderInit()
{
_lock = mutexCreate();
renderSetBackgroundColor(&COLOR_BLACK);
}
void renderSetSize(int width, int height)
{
int x;
int y;
if (render_zone != NULL)
{
/* Delete previous render zone */
for (x = 0; x < render_width; x++)
{
for (y = 0; y < render_height; y++)
{
arrayDelete(render_zone + (y * render_width + x));
}
}
free(render_zone);
free(scanline_up);
free(scanline_down);
}
render_width = width;
render_height = height;
render_zone = malloc(sizeof(Array) * width * height);
scanline_left = 0;
scanline_right = render_width - 1;
scanline_up = malloc(sizeof(RenderFragment) * width);
scanline_down = malloc(sizeof(RenderFragment) * width);
_dirty_left = render_width;
_dirty_right = -1;
_dirty_down = render_height;
_dirty_up = -1;
_dirty_count = 0;
_pixel_count = render_width * render_height;
for (y = 0; y < height; y++)
{
for (x = 0; x < width; x++)
{
arrayCreate(render_zone + (y * width + x), sizeof(RenderFragment));
}
}
_cb_preview_resize(render_width, render_height);
_cb_preview_clear(background_color);
}
int renderSetQuality(int quality)
{
if (quality < 1)
{
render_quality = 1;
}
else if (quality > 10)
{
render_quality = 10;
}
else
{
render_quality = quality;
}
return render_quality;
}
void renderClear()
{
int x;
int y;
for (x = 0; x < render_width; x++)
{
for (y = 0; y < render_height; y++)
{
arrayClear(render_zone + (y * render_width + x));
}
}
scanline_left = 0;
scanline_right = render_width - 1;
_progress = 0.0;
_progress_step_start = 0.0;
_progress_step_length = 0.0;
_interrupt = 0;
_cb_preview_clear(background_color);
_cb_preview_update(_progress * _progress_step_length + _progress_step_start);
_dirty_left = render_width;
_dirty_right = -1;
_dirty_down = render_height;
_dirty_up = -1;
_dirty_count = 0;
}
void renderInterrupt()
{
_interrupt = 1;
}
void renderSetBackgroundColor(Color* col)
{
background_color = *col;
}
int _sortRenderFragment(void const* a, void const* b)
{
double za, zb;
za = ((RenderFragment*)a)->z;
zb = ((RenderFragment*)b)->z;
if (za > zb)
{
return 1;
}
else if (za < zb)
{
return -1;
}
else
{
return 0;
}
}
static Color _getPixelColor(Array* pixel_data)
{
RenderFragment* fragment;
Color result = background_color;
int i;
if (pixel_data->length > 0)
{
for (i = 0; i < pixel_data->length; i++)
{
fragment = ((RenderFragment*)pixel_data->data) + i;
colorMask(&result, &(fragment->vertex.color));
}
}
return result;
}
static inline void _setDirtyPixel(Array* pixel_data, int x, int y)
{
pixel_data->dirty = 1;
if (x < _dirty_left)
{
_dirty_left = x;
}
if (x > _dirty_right)
{
_dirty_right = x;
}
if (y < _dirty_down)
{
_dirty_down = y;
}
if (y > _dirty_up)
{
_dirty_up = y;
}
_dirty_count++;
}
static void _processDirtyPixels()
{
Color col;
Array* pixel_data;
int x, y;
for (y = _dirty_down; y <= _dirty_up; y++)
{
for (x = _dirty_left; x <= _dirty_right; x++)
{
pixel_data = render_zone + y * render_width + x;
if (pixel_data->dirty)
{
col = _getPixelColor(pixel_data);
_cb_preview_draw(x, y, col);
pixel_data->dirty = 0;
}
}
}
_cb_preview_update(_progress * _progress_step_length + _progress_step_start);
_dirty_left = render_width;
_dirty_right = -1;
_dirty_down = render_height;
_dirty_up = -1;
_dirty_count = 0;
}
static void _setAllDirty()
{
int x, y;
_dirty_left = 0;
_dirty_right = render_width - 1;
_dirty_down = 0;
_dirty_up = render_height - 1;
for (y = _dirty_down; y <= _dirty_up; y++)
{
for (x = _dirty_left; x <= _dirty_right; x++)
{
(render_zone + y * render_width + x)->dirty = 1;
}
}
}
void renderAddFragment(RenderFragment* fragment)
{
Array* pixel_data;
int x = fragment->x;
int y = fragment->y;
double z = fragment->z;
int i, dirty;
int fragments_count;
RenderFragment* fragments;
dirty = 0;
if (x >= 0 && x < render_width && y >= 0 && y < render_height && z > 1.0)
{
pixel_data = render_zone + (y * render_width + x);
fragments = (RenderFragment*)pixel_data->data;
fragments_count = pixel_data->length;
if (fragments_count == 0)
{
arrayAppend(pixel_data, fragment);
dirty = 1;
}
else if (fragments[0].z > z)
{
if (fragments[0].vertex.color.a < 1.0)
{
arrayInsert(pixel_data, fragment, 0);
dirty = 1;
}
}
else
{
for (i = 1; i <= fragments_count; i++)
{
if ((i == fragments_count) || (fragments[i].z > z))
{
if (fragment->vertex.color.a > 0.999999)
{
if (i > 1)
{
arrayLStrip(pixel_data, i - 1);
}
arrayReplace(pixel_data, fragment, 0);
}
else if (i == fragments_count)
{
arrayAppend(pixel_data, fragment);
}
else
{
arrayInsert(pixel_data, fragment, i);
}
dirty = 1;
break;
}
}
}
if (dirty)
{
_setDirtyPixel(pixel_data, x, y);
}
}
}
void renderPushFragment(int x, int y, double z, Vertex* vertex)
{
RenderFragment fragment;
fragment.x = x;
fragment.y = y;
fragment.z = z;
fragment.vertex = *vertex;
renderAddFragment(&fragment);
}
static void __vertexGetDiff(Vertex* v1, Vertex* v2, Vertex* result)
{
result->location.x = v2->location.x - v1->location.x;
result->location.y = v2->location.y - v1->location.y;
result->location.z = v2->location.z - v1->location.z;
result->normal.x = v2->normal.x - v1->normal.x;
result->normal.y = v2->normal.y - v1->normal.y;
result->normal.z = v2->normal.z - v1->normal.z;
result->color.r = v2->color.r - v1->color.r;
result->color.g = v2->color.g - v1->color.g;
result->color.b = v2->color.b - v1->color.b;
result->color.a = v2->color.a - v1->color.a;
result->callback = v1->callback;
result->callback_data = v1->callback_data;
}
static void __vertexInterpolate(Vertex* v1, Vertex* diff, double value, Vertex* result)
{
result->location.x = v1->location.x + diff->location.x * value;
result->location.y = v1->location.y + diff->location.y * value;
result->location.z = v1->location.z + diff->location.z * value;
result->normal.x = v1->normal.x + diff->normal.x * value;
result->normal.y = v1->normal.y + diff->normal.y * value;
result->normal.z = v1->normal.z + diff->normal.z * value;
result->color.r = v1->color.r + diff->color.r * value;
result->color.g = v1->color.g + diff->color.g * value;
result->color.b = v1->color.b + diff->color.b * value;
result->color.a = v1->color.a + diff->color.a * value;
result->callback = v1->callback;
result->callback_data = v1->callback_data;
}
static void __pushScanLinePoint(RenderFragment point)
{
if (point.x < 0 || point.x >= render_width)
{
return;
}
if (point.x > scanline_right)
{
scanline_right = point.x;
scanline_up[scanline_right] = point;
scanline_down[scanline_right] = point;
if (point.x < scanline_left)
{
scanline_left = point.x;
}
}
else if (point.x < scanline_left)
{
scanline_left = point.x;
scanline_up[scanline_left] = point;
scanline_down[scanline_left] = point;
}
else
{
if (point.y > scanline_up[point.x].y)
{
scanline_up[point.x] = point;
}
if (point.y < scanline_down[point.x].y)
{
scanline_down[point.x] = point;
}
}
}
static void __pushScanLineEdge(Vector3 v1, Vector3 v2, Vertex* vertex1, Vertex* vertex2)
{
double dx, dy, dz, fx;
Vertex diff;
int startx = lround(v1.x);
int endx = lround(v2.x);
int curx;
RenderFragment fragment;
if (endx < startx)
{
__pushScanLineEdge(v2, v1, vertex2, vertex1);
}
else if (endx < 0 || startx >= render_width)
{
return;
}
else if (startx == endx)
{
fragment.x = startx;
fragment.y = lround(v1.y);
fragment.z = v1.z;
fragment.vertex = *vertex1;
__pushScanLinePoint(fragment);
fragment.x = endx;
fragment.y = lround(v2.y);
fragment.z = v2.z;
fragment.vertex = *vertex2;
__pushScanLinePoint(fragment);
}
else
{
if (startx < 0)
{
startx = 0;
}
if (endx >= render_width)
{
endx = render_width - 1;
}
dx = v2.x - v1.x;
dy = v2.y - v1.y;
dz = v2.z - v1.z;
__vertexGetDiff(vertex1, vertex2, &diff);
for (curx = startx; curx <= endx; curx++)
{
fx = (double)curx + 0.5;
if (fx < v1.x)
{
fx = v1.x;
}
else if (fx > v2.x)
{
fx = v2.x;
}
fx = fx - v1.x;
fragment.x = curx;
fragment.y = lround(v1.y + dy * fx / dx);
fragment.z = v1.z + dz * fx / dx;
__vertexInterpolate(vertex1, &diff, fx / dx, &(fragment.vertex));
__pushScanLinePoint(fragment);
}
}
}
static void __clearScanLines()
{
int x;
for (x = scanline_left; x <= scanline_right; x++)
{
scanline_up[x].y = -1;
scanline_down[x].y = render_height;
}
scanline_left = render_width;
scanline_right = -1;
}
static void __renderScanLines()
{
int x, starty, endy, cury;
Vertex diff;
double dy, dz, fy;
RenderFragment up, down, current;
if (scanline_right > 0)
{
for (x = scanline_left; x <= scanline_right; x++)
{
up = scanline_up[x];
down = scanline_down[x];
starty = down.y;
endy = up.y;
if (endy < 0 || starty >= render_height)
{
continue;
}
if (starty < 0)
{
starty = 0;
}
if (endy >= render_height)
{
endy = render_height - 1;
}
dy = (double)(up.y - down.y);
dz = up.z - down.z;
__vertexGetDiff(&down.vertex, &up.vertex, &diff);
current.x = x;
for (cury = starty; cury <= endy; cury++)
{
fy = (double)cury - down.y;
current.y = cury;
current.z = down.z + dz * fy / dy;
__vertexInterpolate(&down.vertex, &diff, fy / dy, &current.vertex);
#ifdef RENDER_WIREFRAME
if (cury == starty || cury == endy)
{
current.vertex.color = COLOR_RED;
}
#endif
renderAddFragment(&current);
}
}
}
}
void renderPushTriangle(Renderer* renderer, Vertex* v1, Vertex* v2, Vertex* v3)
{
Vector3 p1, p2, p3;
double limit_width = (double)(render_width - 1);
double limit_height = (double)(render_height - 1);
p1 = renderer->projectPoint(renderer, v1->location);
p2 = renderer->projectPoint(renderer, v2->location);
p3 = renderer->projectPoint(renderer, v3->location);
/* Filter if outside screen */
if (p1.z < 1.0 || p2.z < 1.0 || p3.z < 1.0 || (p1.x < 0.0 && p2.x < 0.0 && p3.x < 0.0) || (p1.y < 0.0 && p2.y < 0.0 && p3.y < 0.0) || (p1.x > limit_width && p2.x > limit_width && p3.x > limit_width) || (p1.y > limit_height && p2.y > limit_height && p3.y > limit_height))
{
return;
}
__clearScanLines();
__pushScanLineEdge(p1, p2, v1, v2);
__pushScanLineEdge(p2, p3, v2, v3);
__pushScanLineEdge(p3, p1, v3, v1);
mutexAcquire(_lock);
__renderScanLines();
mutexRelease(_lock);
}
void renderPushQuad(Renderer* renderer, Vertex* v1, Vertex* v2, Vertex* v3, Vertex* v4)
{
renderPushTriangle(renderer, v2, v3, v1);
renderPushTriangle(renderer, v4, v1, v3);
}
typedef struct {
int startx;
int endx;
int starty;
int endy;
int finished;
int interrupt;
Thread* thread;
Renderer* renderer;
} RenderChunk;
void* _renderPostProcessChunk(void* data)
{
int x, y, i;
int dirty;
Array* pixel_data;
RenderFragment* fragments;
RenderChunk* chunk = (RenderChunk*)data;
#ifdef RENDER_INVERSE
for (y = render_height - 1 - chunk->starty; y >= render_height - 1 - chunk->endy; y--)
#else
for (y = chunk->starty; y <= chunk->endy; y++)
#endif
{
for (x = chunk->startx; x <= chunk->endx; x++)
{
pixel_data = render_zone + (y * render_width + x);
fragments = (RenderFragment*)pixel_data->data;
dirty = 0;
for (i = 0; i < pixel_data->length; i++)
{
if (fragments[i].vertex.callback)
{
if (fragments[i].vertex.callback(fragments + i, chunk->renderer, fragments[i].vertex.callback_data))
{
/* TODO Store over-exposure */
colorNormalize(&fragments[i].vertex.color);
dirty = 1;
}
}
}
if (dirty)
{
mutexAcquire(_lock);
_setDirtyPixel(pixel_data, x, y);
mutexRelease(_lock);
}
_progress_pixels++;
}
if (chunk->interrupt)
{
break;
}
}
chunk->finished = 1;
return NULL;
}
#define MAX_CHUNKS 8
void renderPostProcess(Renderer* renderer, int nbchunks)
{
volatile RenderChunk chunks[MAX_CHUNKS];
int i;
int x, y, dx, dy, nx, ny;
int loops, running;
if (nbchunks > MAX_CHUNKS)
{
nbchunks = MAX_CHUNKS;
}
if (nbchunks < 1)
{
nbchunks = 1;
}
nx = 10;
ny = 10;
dx = render_width / nx;
dy = render_height / ny;
x = 0;
y = 0;
_progress_pixels = 0;
for (i = 0; i < nbchunks; i++)
{
chunks[i].thread = NULL;
chunks[i].renderer = renderer;
}
running = 0;
loops = 0;
while ((y < ny && !_interrupt) || running > 0)
{
timeSleepMs(100);
for (i = 0; i < nbchunks; i++)
{
if (chunks[i].thread)
{
if (chunks[i].finished)
{
threadJoin(chunks[i].thread);
chunks[i].thread = NULL;
running--;
}
else if (_interrupt)
{
chunks[i].interrupt = 1;
}
}
if (y < ny && !chunks[i].thread && !_interrupt)
{
chunks[i].finished = 0;
chunks[i].interrupt = 0;
chunks[i].startx = x * dx;
if (x == nx)
{
chunks[i].endx = render_width - 1;
}
else
{
chunks[i].endx = (x + 1) * dx - 1;
}
chunks[i].starty = y * dy;
if (y == ny)
{
chunks[i].endy = render_height - 1;
}
else
{
chunks[i].endy = (y + 1) * dy - 1;
}
chunks[i].thread = threadCreate(_renderPostProcessChunk, (void*)(chunks + i));
running++;
if (++x >= nx)
{
y++;
x = 0;
}
}
}
if (++loops >= 10)
{
mutexAcquire(_lock);
_progress = (double)_progress_pixels / (double)_pixel_count;
_processDirtyPixels();
mutexRelease(_lock);
loops = 0;
}
}
_progress = 1.0;
_processDirtyPixels();
}
void renderUpdate()
{
mutexAcquire(_lock);
_processDirtyPixels();
mutexRelease(_lock);
}
void renderSaveToFile(const char* path)
{
ILuint image_id;
ilGenImages(1, &image_id);
ilBindImage(image_id);
Color result;
ILuint x, y;
ILuint rgba;
ILuint data[render_height * render_width];
ILenum error;
Array* pixel_data;
for (y = 0; y < render_height; y++)
{
for (x = 0; x < render_width; x++)
{
pixel_data = render_zone + (y * render_width + x);
result = _getPixelColor(pixel_data);
rgba = colorTo32BitRGBA(&result);
data[y * render_width + x] = rgba;
}
}
ilTexImage((ILuint)render_width, (ILuint)render_height, 1, 4, IL_RGBA, IL_UNSIGNED_BYTE, data);
ilSaveImage(path);
ilDeleteImages(1, &image_id);
while ((error=ilGetError()) != IL_NO_ERROR)
{
fprintf(stderr, "IL ERROR : %s\n", iluErrorString(error));
}
}
void renderSetPreviewCallbacks(PreviewCallbackResize resize, PreviewCallbackClear clear, PreviewCallbackDraw draw, PreviewCallbackUpdate update)
{
_cb_preview_resize = resize ? resize : _previewResize;
_cb_preview_clear = clear ? clear : _previewClear;
_cb_preview_draw = draw ? draw : _previewDraw;
_cb_preview_update = update ? update : _previewUpdate;
_cb_preview_resize(render_width, render_height);
_cb_preview_clear(background_color);
_setAllDirty();
_processDirtyPixels();
_cb_preview_update(1.0);
}
int renderSetNextProgressStep(double start, double end)
{
if (_interrupt)
{
return 0;
}
else
{
_progress = 0.0;
_progress_step_start = start;
_progress_step_length = end - start;
return 1;
}
}
int renderTellProgress(double progress)
{
if (_interrupt)
{
return 0;
}
else
{
_progress = progress;
return 1;
}
}