mirror of
https://github.com/AquariaOSE/Aquaria.git
synced 2024-12-27 07:06:00 +00:00
334 lines
8.1 KiB
C
334 lines
8.1 KiB
C
#ifdef WIN32
|
|
#define WIN32_LEAN_AND_MEAN
|
|
#include <windows.h>
|
|
#endif
|
|
#include <gl/gl.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include "prof.h"
|
|
#include "prof_internal.h"
|
|
|
|
#pragma warning(disable:4305; disable:4244)
|
|
|
|
// use factor to compute a glow amount
|
|
static int get_colors(float factor,
|
|
float text_color_ret[3],
|
|
float glow_color_ret[3],
|
|
float *glow_alpha_ret)
|
|
{
|
|
const float GLOW_RANGE = 0.5f;
|
|
const float GLOW_ALPHA_MAX = 0.5f;
|
|
float glow_alpha;
|
|
int i;
|
|
float hot[3] = {1, 1.0, 0.9};
|
|
float cold[3] = {0.15, 0.9, 0.15};
|
|
|
|
float glow_cold[3] = {0.5f, 0.5f, 0};
|
|
float glow_hot[3] = {1.0f, 1.0f, 0};
|
|
|
|
if (factor < 0) factor = 0;
|
|
if (factor > 1) factor = 1;
|
|
|
|
for (i=0; i < 3; ++i)
|
|
text_color_ret[i] = cold[i] + (hot[i] - cold[i]) * factor;
|
|
|
|
// Figure out whether to start up the glow as well.
|
|
glow_alpha = (factor - GLOW_RANGE) / (1 - GLOW_RANGE);
|
|
if (glow_alpha < 0) {
|
|
*glow_alpha_ret = 0;
|
|
return 0;
|
|
}
|
|
|
|
for (i=0; i < 3; ++i)
|
|
glow_color_ret[i] = glow_cold[i] + (glow_hot[i] - glow_cold[i]) * factor;
|
|
|
|
*glow_alpha_ret = glow_alpha * GLOW_ALPHA_MAX;
|
|
return 1;
|
|
}
|
|
|
|
static void draw_rectangle(float x0, float y0, float x1, float y1)
|
|
{
|
|
// FACE_CULL is disabled so winding doesn't matter
|
|
glVertex2f(x0, y0);
|
|
glVertex2f(x1, y0);
|
|
glVertex2f(x1, y1);
|
|
glVertex2f(x0, y1);
|
|
}
|
|
|
|
typedef struct
|
|
{
|
|
float x0,y0;
|
|
float sx,sy;
|
|
} GraphLocation;
|
|
|
|
static void graph_func(int id, int x0, int x1, float *values, void *data)
|
|
{
|
|
GraphLocation *loc = (GraphLocation *) data;
|
|
int i, r,g,b;
|
|
|
|
// trim out values that are under 0.2 ms to accelerate rendering
|
|
while (x0 < x1 && (*values < 0.0002f)) { ++x0; ++values; }
|
|
while (x1 > x0 && (values[x1-1-x0] < 0.0002f)) --x1;
|
|
|
|
if (id == 0)
|
|
glColor4f(1,1,1,0.5);
|
|
else {
|
|
if (x0 == x1) return;
|
|
|
|
id = (id >> 8) + id;
|
|
r = id * 37;
|
|
g = id * 59;
|
|
b = id * 45;
|
|
#pragma warning(disable:4761)
|
|
glColor3ub((r & 127) + 80, (g & 127) + 80, (b & 127) + 80);
|
|
}
|
|
|
|
glBegin(GL_LINE_STRIP);
|
|
if (x0 == x1) {
|
|
float x,y;
|
|
x = loc->x0 + x0 * loc->sx;
|
|
y = loc->y0 + values[0] * loc->sy;
|
|
glVertex2f(x,loc->y0);
|
|
glVertex2f(x, y);
|
|
}
|
|
for (i=0; i < x1-x0; ++i) {
|
|
float x,y;
|
|
x = loc->x0 + (i+x0) * loc->sx;
|
|
y = loc->y0 + values[i] * loc->sy;
|
|
glVertex2f(x,y);
|
|
}
|
|
glEnd();
|
|
}
|
|
|
|
Prof_extern_C void Prof_draw_graph_gl(float sx, float sy, float x_spacing, float y_spacing)
|
|
{
|
|
#ifdef Prof_ENABLED
|
|
Prof_Begin(iprof_draw_graph)
|
|
GraphLocation loc = { sx, sy, x_spacing, y_spacing * 1000 };
|
|
Prof_graph(128, graph_func, &loc);
|
|
Prof_End
|
|
#endif
|
|
}
|
|
|
|
|
|
// float to string conversion with sprintf() was
|
|
// taking up 10-20% of the Prof_draw time, so I
|
|
// wrote a faster float-to-string converter
|
|
|
|
static char int_to_string[100][4];
|
|
static char int_to_string_decimal[100][4];
|
|
static char int_to_string_mid_decimal[100][4];
|
|
static void int_to_string_init(void)
|
|
{
|
|
int i;
|
|
for (i=0; i < 100; ++i) {
|
|
sprintf(int_to_string[i], "%d", i);
|
|
sprintf(int_to_string_decimal[i], ".%02d", i);
|
|
sprintf(int_to_string_mid_decimal[i], "%d.%d", i/10, i % 10);
|
|
}
|
|
}
|
|
|
|
static char *formats[5] =
|
|
{
|
|
"%.0f",
|
|
"%.1f",
|
|
"%.2f",
|
|
"%.3f",
|
|
"%.4f",
|
|
};
|
|
|
|
static void float_to_string(char *buf, float num, int precision)
|
|
{
|
|
int x,y;
|
|
switch(precision) {
|
|
case 2:
|
|
if (num < 0 || num >= 100)
|
|
break;
|
|
x = num;
|
|
y = (num - x) * 100;
|
|
strcpy(buf, int_to_string[x]);
|
|
strcat(buf, int_to_string_decimal[y]);
|
|
return;
|
|
case 3:
|
|
if (num < 0 || num >= 10)
|
|
break;
|
|
num *= 10;
|
|
x = num;
|
|
y = (num - x) * 100;
|
|
strcpy(buf, int_to_string_mid_decimal[x]);
|
|
strcat(buf, int_to_string_decimal[y]+1);
|
|
return;
|
|
case 4:
|
|
if (num < 0 || num >= 1)
|
|
break;
|
|
num *= 100;
|
|
x = num;
|
|
y = (num - x) * 100;
|
|
buf[0] = '0';
|
|
strcpy(buf+1, int_to_string_decimal[x]);
|
|
strcat(buf, int_to_string_decimal[y]+1);
|
|
return;
|
|
}
|
|
sprintf(buf, formats[precision], num);
|
|
}
|
|
|
|
Prof_extern_C void Prof_draw_gl(float sx, float sy,
|
|
float full_width, float height,
|
|
float line_spacing, int precision,
|
|
void (*printText)(float x, float y, char *str), float (*textWidth)(char *str))
|
|
{
|
|
#ifdef Prof_ENABLED
|
|
Prof_Begin(iprof_draw)
|
|
|
|
int i,j,n,o;
|
|
GLuint cull, texture;
|
|
float backup_sy;
|
|
|
|
float field_width = textWidth("5555.55");
|
|
float name_width = full_width - field_width * 3;
|
|
float plus_width = textWidth("+");
|
|
|
|
int max_records;
|
|
|
|
Prof_Report *pob;
|
|
|
|
if (!int_to_string[0][0]) int_to_string_init();
|
|
|
|
if (precision < 1) precision = 1;
|
|
if (precision > 4) precision = 4;
|
|
|
|
// disable face culling to avoid having to get winding correct
|
|
texture = glIsEnabled(GL_TEXTURE_2D);
|
|
cull = glIsEnabled(GL_CULL_FACE);
|
|
if (cull == GL_TRUE) {
|
|
glDisable(GL_CULL_FACE);
|
|
}
|
|
|
|
pob = Prof_create_report();
|
|
|
|
for (i=0; i < NUM_TITLE; ++i) {
|
|
if (pob->title[i]) {
|
|
float header_x0 = sx;
|
|
float header_x1 = header_x0 + full_width;
|
|
|
|
if (i == 0)
|
|
glColor4f(0.1f, 0.3f, 0, 0.85);
|
|
else
|
|
glColor4f(0.2f, 0.1f, 0.1f, 0.85);
|
|
|
|
glBegin(GL_QUADS);
|
|
draw_rectangle(header_x0, sy-2, header_x1, sy-line_spacing+2);
|
|
glEnd();
|
|
|
|
if (i == 0)
|
|
glColor4f(0.6, 0.4, 0, 0);
|
|
else
|
|
glColor4f(0.8f, 0.1f, 0.1f, 0);
|
|
|
|
printText(sx+2, sy, pob->title[i]);
|
|
|
|
sy += 1.5*line_spacing;
|
|
height -= abs(line_spacing)*1.5;
|
|
}
|
|
}
|
|
|
|
max_records = height / abs(line_spacing);
|
|
|
|
o = 0;
|
|
n = pob->num_record;
|
|
if (n > max_records) n = max_records;
|
|
if (pob->hilight >= o + n) {
|
|
o = pob->hilight - n + 1;
|
|
}
|
|
|
|
backup_sy = sy;
|
|
|
|
// Draw the background colors for the zone data.
|
|
glDisable(GL_TEXTURE_2D);
|
|
glBegin(GL_QUADS);
|
|
|
|
glColor4f(0,0,0,0.85);
|
|
draw_rectangle(sx, sy, sx + full_width, sy - line_spacing);
|
|
sy += line_spacing;
|
|
|
|
for (i = 0; i < n; i++) {
|
|
float y0, y1;
|
|
|
|
if (i & 1) {
|
|
glColor4f(0.1, 0.1f, 0.2, 0.85);
|
|
} else {
|
|
glColor4f(0.1f, 0.1f, 0.3, 0.85);
|
|
}
|
|
if (i+o == pob->hilight)
|
|
glColor4f(0.3f, 0.3f, 0.1f, 0.85);
|
|
|
|
y0 = sy;
|
|
y1 = sy - line_spacing;
|
|
|
|
draw_rectangle(sx, y0, sx + full_width, y1);
|
|
sy += line_spacing;
|
|
}
|
|
glEnd();
|
|
|
|
sy = backup_sy;
|
|
glColor4f(0.7,0.7,0.7,0);
|
|
|
|
if (pob->header[0])
|
|
printText(sx+8, sy, pob->header[0]);
|
|
|
|
for (j=1; j < NUM_HEADER; ++j)
|
|
if (pob->header[j])
|
|
printText(sx + name_width + field_width * (j-1) +
|
|
field_width/2 - textWidth(pob->header[j])/2, sy, pob->header[j]);
|
|
|
|
sy += line_spacing;
|
|
|
|
for (i = 0; i < n; i++) {
|
|
char buf[256], *b = buf;
|
|
Prof_Report_Record *r = &pob->record[i+o];
|
|
float text_color[3], glow_color[3];
|
|
float glow_alpha;
|
|
float x = sx + textWidth(" ") * r->indent + plus_width/2;
|
|
if (r->prefix) {
|
|
buf[0] = r->prefix;
|
|
++b;
|
|
} else {
|
|
x += plus_width;
|
|
}
|
|
if (r->number)
|
|
sprintf(b, "%s (%d)", r->name, r->number);
|
|
else
|
|
sprintf(b, "%s", r->name);
|
|
if (get_colors(r->heat, text_color, glow_color, &glow_alpha)) {
|
|
glColor4f(glow_color[0], glow_color[1], glow_color[2], glow_alpha);
|
|
//printText(x+2, sy-1, buf);
|
|
printText(x+1, sy, buf);
|
|
}
|
|
glColor3fv(text_color);
|
|
printText(x + 1, sy, buf);
|
|
|
|
for (j=0; j < NUM_VALUES; ++j) {
|
|
if (r->value_flag & (1 << j)) {
|
|
int pad;
|
|
float_to_string(buf, r->values[j], j == 2 ? 2 : precision);
|
|
pad = field_width- plus_width - textWidth(buf);
|
|
if (r->indent) pad += plus_width;
|
|
printText(sx + pad + name_width + field_width * j, sy, buf);
|
|
}
|
|
}
|
|
|
|
|
|
sy += line_spacing;
|
|
}
|
|
|
|
Prof_free_report(pob);
|
|
|
|
if (cull == GL_TRUE)
|
|
glEnable(GL_CULL_FACE);
|
|
if (texture == GL_TRUE)
|
|
glEnable(GL_TEXTURE_2D);
|
|
|
|
Prof_End
|
|
#endif
|
|
}
|
|
|