void Video_DX9::init_context() {
// Enable Alpha Blitting
m_d3d_device->SetRenderState(D3DRS_ALPHABLENDENABLE, true);
m_d3d_device->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
m_d3d_device->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
m_d3d_device->SetRenderState(D3DRS_BLENDOP, D3DBLENDOP_ADD);
// Configure Texture Stages
m_d3d_device->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_DIFFUSE);
m_d3d_device->SetTextureStageState(0, D3DTSS_COLORARG2, D3DTA_TEXTURE);
m_d3d_device->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_DIFFUSE);
m_d3d_device->SetTextureStageState(0, D3DTSS_ALPHAARG2, D3DTA_TEXTURE);
// Set Lighting Variables
m_d3d_device->SetRenderState(D3DRS_NORMALIZENORMALS, true);
// Multisampling
m_d3d_device->SetRenderState(D3DRS_MULTISAMPLEANTIALIAS, DWORD(get_multisampling() > 1));
// More basic stuff
set_2d();
set_color(get_color());
set_clear_color(get_clear_color());
set_backface_culling(get_backface_culling());
set_lighting(get_lighting());
set_ambient_lighting(get_ambient_lighting());
set_alpha_test(is_alpha_test_enabled(), get_alpha_test_function(), get_alpha_test_value());
set_zwrite(is_zwrite_enabled());
set_ztest(is_ztest_enabled());
}
void View::resize(int w_, int h_) {
if (w == w_ && h == h_) {
did_resize(w_,h_);
return;
}
w = w_; h = h_;
View temp(w,h);
std::swap(image, temp.image);
std::swap(display, temp.display);
if (is_alpha) {
set_clear_color(clear_color);
fill_with_color(clear_color);
}
SDL_Rect dest_rect = {0, 0, w, h};
SDL_BlitSurface(temp.image, 0, image, &dest_rect);
mark_changed();
did_resize(w_,h_);
}
int main() {
test_colors();
test_dynamic_array();
test_vectors();
test_physics();
int pixels[] = {0x0000ffff, 0x0000ffff, 0x0000ffff, 0x0000ffff, 0x0000ffff, 0x0000ffff,
0x0000ffff, 0x0000ffff, 0x0000ffff, 0x0000ffff, 0x0000ffff, 0x0000ffff,
0x0000ffff, 0x0000ffff, 0x0000ffff, 0x0000ffff, 0x0000ffff, 0x0000ffff,
0x0000ffff, 0x0000ffff, 0x0000ffff, 0x0000ffff, 0x0000ffff, 0x0000ffff,
0x0000ffff, 0x0000ffff, 0x0000ffff, 0x0000ffff, 0x0000ffff, 0x0000ffff,
0x0000ffff, 0x0000ffff, 0x0000ffff, 0x0000ffff, 0x0000ffff, 0x0000ffff};
color pixels2[10000];
for (int i = 0; i < 10000; i++) pixels2[i] = 0xE650E1FF;
int window_width = 800;
int window_height = 600;
init_graphics();
renderer_handle rend = create_window(window_width, window_height, "TEST", 0);
texture_handle tex = load_texture_data(rend, pixels, 6, 6);
texture_handle tex2 = load_texture_data(rend, pixels2, 100, 100);
set_clear_color(rend, get_color(0,0,0,0xFF));
while (SDL_GetTicks() < 10000) {
clear(rend);
double theta = (double) SDL_GetTicks() / 300;
double r = 200 * cos(3*theta/5);
int x1 = r*cos(theta) - 3 + window_width/2;
int y1 = r*sin(theta) - 3 + window_height/2;
int x2 = r*cos(theta + 2*PI/3) - 3 + window_width/2;
int y2 = r*sin(theta + 2*PI/3) - 3 + window_height/2;
int x3 = r*cos(theta - 2*PI/3) - 3 + window_width/2;
int y3 = r*sin(theta - 2*PI/3) - 3 + window_height/2;
double scale = .75 - .25 * cos(6*theta/5);
int s = 100 * scale;
draw(rend, tex2, (window_width - s) / 2, (window_height - s) / 2, -theta, s/2, s/2, 0, 0, scale);
draw(rend, tex, x1, y1, 0, 0, 0, 0, 0, 1);
draw(rend, tex, x2, y2, 0, 0, 0, 0, 0, 1);
draw(rend, tex, x3, y3, 0, 0, 0, 0, 0, 1);
show(rend);
SDL_Delay(16);
}
destroy_window(rend);
cleanup();
return 0;
}
void DropDownMenu::init_menu_view(int text_size_) {
// Init main view
resize(get_w(), text_size_ + vertical_padding*2);
text_size = text_size_;
selected_entry_idx = 0;
menu = 0; clicked = false;
set_clear_color(green_color_c);
fill_with_color(get_clear_color());
// Init menu view
int row_size = (text_size + vertical_padding*2);
menu = new View(get_w(), (int)(entries.size() ? entries.size() : 1) * row_size);
// always display at least one entry
menu->draw_onto_self(GUIImage("GUIImages/dropdown_row.bmp"), DispPoint());
// display full menu
int i = 0;
for (list<string>::iterator it = entries.begin(); it != entries.end(); ++it, ++i) {
// menu->attach_subview(new MenuEntry(*it, text_size, *this, i),
// DispPoint(0, i * row_size));
menu->draw_onto_self(GUIImage("GUIImages/dropdown_row.bmp"),
DispPoint(0, i * row_size));
menu->attach_subview(createTextView(*it, text_size),
DispPoint(0, i * row_size));
}
attach_subview(menu, DispPoint());
}
ScrollView::ScrollView(int w_, int h_, View *display_view_)
:View(w_,h_),
scroll_bar(SCROLL_BAR_W, h_ * h_/display_view_->get_h(), this),
scroll_bar_bg(SCROLL_BAR_W, h_, this),
arrow_up(true, GUIImage("GUIImages/scroll_bar_vert2.bmp")),
arrow_down(false, GUIImage("GUIImages/scroll_bar_vert3.bmp")),
display_view(display_view_),
w_init(w_), h_init(h_),
scroll_y(0), scroll_y_vel(0), scrolling(false)
{
SDL_Color clear = {0xff, 0, 0xff};
GUIImage bg = GUIImage::create_filled(w_, h_, clear);
draw_onto_self(bg, VGPoint());
set_clear_color(clear);
attach_subview(display_view_, VGPoint());
if (display_view->get_h() <= get_h()) {
scrollable = false;
resize(min(display_view->get_w(), w_),
min(display_view->get_h(), h_));
return; // todo Remove to so you can resize later.
}
scrollable = true;
scroll_bar_bg.display();
scroll_bar.display();
scroll_bar_x = get_w()-scroll_bar_bg.get_w();
attach_subview(&scroll_bar_bg, VGPoint(scroll_bar_x, 0));
attach_subview(&arrow_up, VGPoint(scroll_bar_x, scroll_bar_bottom-7)); // HACK!!
attach_subview(&arrow_down, VGPoint(scroll_bar_x, scroll_bar_bottom-7+arrow_up.get_h())); // HACK!!
attach_subview(&scroll_bar, VGPoint(scroll_bar_x, scroll_bar_top));
}
renderer::renderer(const renderer_settings& settings) : current_settings(settings) {
#if BUILD_OPENGL
LOG("Calling gladLoadGL: %x.", intptr_t(gladLoadGL));
if (!gladLoadGL()) {
LOG("Calling gladLoadGL failed.");
throw renderer_error("Failed to initialize GLAD!");
}
#endif
LOG("glBlendFuncSeparate ADDR: %x", intptr_t(glBlendFuncSeparate));
LOG("Calling gladLoadGL succeeded.");
set_blending(true);
set_standard_blending();
set_clear_color(black);
GL_CHECK(glDisable(GL_DITHER));
GL_CHECK(glDisable(GL_LINE_SMOOTH));
GL_CHECK(glDisable(GL_POLYGON_SMOOTH));
GL_CHECK(glDisable(GL_MULTISAMPLE));
GL_CHECK(glDisable(GL_DEPTH_TEST));
GL_CHECK(glDepthMask(GL_FALSE));
GL_CHECK(glHint(GL_POLYGON_SMOOTH_HINT, GL_FASTEST));
GL_CHECK(glHint(GL_TEXTURE_COMPRESSION_HINT, GL_FASTEST));
GL_CHECK(glGenVertexArrays(1, &vao_buffer));
GL_CHECK(glBindVertexArray(vao_buffer));
GL_CHECK(glGenBuffers(1, &imgui_elements_id));
GL_CHECK(glGenBuffers(1, &triangle_buffer_id));
GL_CHECK(glBindBuffer(GL_ARRAY_BUFFER, triangle_buffer_id));
GL_CHECK(glEnableVertexAttribArray(static_cast<int>(vertex_attribute::position)));
GL_CHECK(glEnableVertexAttribArray(static_cast<int>(vertex_attribute::texcoord)));
GL_CHECK(glEnableVertexAttribArray(static_cast<int>(vertex_attribute::color)));
GL_CHECK(glVertexAttribPointer(static_cast<int>(vertex_attribute::position), 2, GL_FLOAT, GL_FALSE, sizeof(vertex), nullptr));
GL_CHECK(glVertexAttribPointer(static_cast<int>(vertex_attribute::texcoord), 2, GL_FLOAT, GL_FALSE, sizeof(vertex), reinterpret_cast<char*>(sizeof(float) * 2)));
GL_CHECK(glVertexAttribPointer(static_cast<int>(vertex_attribute::color), 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(vertex), reinterpret_cast<char*>(sizeof(float) * 2 + sizeof(float) * 2)));
GL_CHECK(glGenBuffers(1, &special_buffer_id));
GL_CHECK(glBindBuffer(GL_ARRAY_BUFFER, special_buffer_id));
enable_special_vertex_attribute();
GL_CHECK(glVertexAttribPointer(static_cast<int>(vertex_attribute::special), sizeof(special) / sizeof(float), GL_FLOAT, GL_FALSE, sizeof(special), nullptr));
disable_special_vertex_attribute();
GL_CHECK(glBindBuffer(GL_ARRAY_BUFFER, triangle_buffer_id));
#if USE_BUFFER_SUB_DATA
/* Preallocate necessary space */
GL_CHECK(glBindBuffer(GL_ARRAY_BUFFER, triangle_buffer_id));
GL_CHECK(glBufferData(GL_ARRAY_BUFFER, sizeof(vertex) * 30000, nullptr, GL_STREAM_DRAW));
GL_CHECK(glBindBuffer(GL_ARRAY_BUFFER, special_buffer_id));
GL_CHECK(glBufferData(GL_ARRAY_BUFFER, sizeof(special) * 6000, nullptr, GL_STREAM_DRAW));
GL_CHECK(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, imgui_elements_id));
GL_CHECK(glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(unsigned) * 12000, nullptr, GL_STREAM_DRAW));
#endif
#if BUILD_OPENGL
GLint read_size = 0;
GL_CHECK(glGetIntegerv(GL_MAX_TEXTURE_SIZE, &read_size));
ensure(read_size >= 0);
max_texture_size = static_cast<unsigned>(read_size);
#else
max_texture_size = 0u;
#endif
apply(settings, true);
}
void Video_GL::init() {
std::cout << "Initializing OpenGL" << std::endl;
//double buffer, no stencil, no accumulation buffer
SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 16);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 0);
SDL_GL_SetAttribute(SDL_GL_ACCUM_RED_SIZE, 0);
SDL_GL_SetAttribute(SDL_GL_ACCUM_GREEN_SIZE, 0);
SDL_GL_SetAttribute(SDL_GL_ACCUM_BLUE_SIZE, 0);
SDL_GL_SetAttribute(SDL_GL_ACCUM_ALPHA_SIZE, 0);
if(get_multisampling() > 1) {
SDL_GL_SetAttribute (SDL_GL_MULTISAMPLESAMPLES, get_multisampling());
SDL_GL_SetAttribute (SDL_GL_MULTISAMPLEBUFFERS, 1);
}
set_opengl_flag(true);
Video::init();
#if SDL_VERSION_ATLEAST(1,3,0)
m_context = SDL_GL_CreateContext(get_window());
#endif
{
const GLenum err = glewInit();
if(GLEW_OK != err) {
std::cerr << "GLEW Error: " << glewGetErrorString(err) << std::endl;
throw Video_Init_Failure();
}
}
// Set Fill/Shade Mode
glShadeModel(GL_SMOOTH);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
glEnable(GL_NORMALIZE); //GL_RESCALE_NORMALIZE);
// Enable Alpha Blitting
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
//glBlendEquation(GL_FUNC_ADD); // default // would require ARB ext
// Set lighting variables
glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);
glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);
if(glGetError() == GL_INVALID_ENUM)
std::cerr << "Quality Warning: Your graphics card does not support separate specular lighting in OpenGL.\n";
// Initialize Assorted Variables
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
//glPointSize(static_cast<GLfloat>(sqrt(pow(double(get_screen_width()), 2.) * pow(double(get_screen_height()), 2.)) / 1000000));
//glLineWidth(static_cast<GLfloat>(sqrt(pow(double(get_screen_width()), 2.) * pow(double(get_screen_height()), 2.)) / 1000000));
// Finish with a few function calls
set_2d();
set_color(get_color());
set_clear_color(get_clear_color());
set_backface_culling(get_backface_culling());
set_lighting(get_lighting());
set_ambient_lighting(get_ambient_lighting());
set_alpha_test(is_alpha_test_enabled(), get_alpha_test_function(), get_alpha_test_value());
set_zwrite(is_zwrite_enabled());
set_ztest(is_ztest_enabled());
union {
void * v;
#ifdef _LINUX
PFNGLXSWAPINTERVALEXTPROC pglSwapIntervalEXT;
PFNGLXSWAPINTERVALSGIPROC pglSwapIntervalSGI;
#endif
PFNGLBINDBUFFERARBPROC pglBindBufferARB;
PFNGLDELETEBUFFERSARBPROC pglDeleteBuffersARB;
PFNGLGENBUFFERSARBPROC pglGenBuffersARB;
PFNGLBUFFERDATAARBPROC pglBufferDataARB;
} ptr;
#ifdef _LINUX
ptr.v = SDL_GL_GetProcAddress("glXSwapIntervalEXT");
if(!ptr.v)
ptr.v = SDL_GL_GetProcAddress("wglSwapIntervalEXT");
m_pglSwapIntervalEXT = ptr.pglSwapIntervalEXT;
ptr.v = SDL_GL_GetProcAddress("glXSwapIntervalSGI");
if(!ptr.v)
ptr.v = SDL_GL_GetProcAddress("wglSwapIntervalSGI");
m_pglSwapIntervalSGI = ptr.pglSwapIntervalSGI;
#endif
// Has to be done after finding the function pointer
set_vertical_sync(get_vertical_sync());
m_vertex_buffers = strstr(reinterpret_cast<const char *>(glGetString(GL_EXTENSIONS)), "ARB_vertex_buffer_object") != 0;
if(m_vertex_buffers) {
ptr.v = SDL_GL_GetProcAddress("glBindBufferARB");
m_pglBindBufferARB = ptr.pglBindBufferARB;
ptr.v = SDL_GL_GetProcAddress("glDeleteBuffersARB");
m_pglDeleteBuffersARB = ptr.pglDeleteBuffersARB;
ptr.v = SDL_GL_GetProcAddress("glGenBuffersARB");
m_pglGenBuffersARB = ptr.pglGenBuffersARB;
ptr.v = SDL_GL_GetProcAddress("glBufferDataARB");
m_pglBufferDataARB = ptr.pglBufferDataARB;
}
else
std::cerr << "Performance Warning: Your graphics card does not offer Vertex Buffer Objects (VBO) in OpenGL.\n";
if(strstr((char*)glGetString(GL_EXTENSIONS), "GL_EXT_texture_filter_anisotropic"))
glGetIntegerv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, reinterpret_cast<GLint *>(&m_maximum_anisotropy));
else
m_maximum_anisotropy = 0;
}
void sphere()
{
SetGeomScreen(1000);
MATRIX m;
VECTOR trans = {0, 0, 300};
TransMatrix(&m, &trans);
SetTransMatrix(&m);
const int SPHERE_LATITUDE = 24;
const int SPHERE_LONGITUDE = 24;
const int SPHERE_RADIUS = 50;
SVECTOR* sphere_vector = (SVECTOR*)MemoryManager::malloc(SPHERE_LATITUDE * SPHERE_LONGITUDE * sizeof(*sphere_vector));
POLY_G4* poly_sphere = (POLY_G4*)MemoryManager::malloc(SPHERE_LATITUDE * SPHERE_LONGITUDE * sizeof(*poly_sphere));
{
/**
* x <- r * sin(\alpha) * cos(\beta)
* y <- r * sin(\alpha) * sin(\beta)
* z <- r * cos(\alpha)
* avec:
* \alpha \in [0, pi] : latitude
* \beta \in [0, 2*pi] : longitude
*/
SVECTOR* v = sphere_vector;
for ( int la = 0; la < SPHERE_LATITUDE; la++ ) {
int alpha = (TRIGO_PI * la) / SPHERE_LATITUDE;
int sa = sin4k[alpha];
int ca = cos4k[alpha];
for ( int lo = 0; lo < SPHERE_LONGITUDE; lo++, v++ ) {
int beta = (2 * TRIGO_PI * lo) / SPHERE_LONGITUDE;
unsigned short x = (SPHERE_RADIUS * sa * cos4k[beta]) / (TRIGO_SCALE * TRIGO_SCALE);
unsigned short y = (SPHERE_RADIUS * sa * sin4k[beta]) / (TRIGO_SCALE *TRIGO_SCALE);
unsigned short z = (SPHERE_RADIUS * ca) / TRIGO_SCALE;
setVector(v, x, y, z);
}
}
POLY_G4* p = poly_sphere;
for ( int la = 0; la < SPHERE_LATITUDE; la++ ) {
for ( int lo = 0; lo < SPHERE_LONGITUDE; lo++, p++ ) {
SetPolyG4(p);
}
}
}
set_clear_color(0);
static const int SPHERE_TRANSITION_STEP = 200;
static const int SPHERE_STEP_TIME = 600;
enum { SCENE_LAT_FLAT = 1,
SCENE_LAT_SMOOTH,
SCENE_LIGHT_FIX_EDGE,
SCENE_LIGHT_FIX_SQUARE,
SCENE_LIGHT_FIX,
SCENE_LIGHT_MOVE,
SCENE_LIGHT_CUTOFF,
SCENE_ZOOM,
SCENE_LIGHT_SINUS_WAVE, };
int current_scene = SCENE_LAT_FLAT;
int t = 0;
enable_auto_clear_color_buffer();
while ( t < SCENE_LIGHT_SINUS_WAVE * SPHERE_STEP_TIME)
{
SVECTOR rot = {8*t%4096, 4*t%4096, 10*t%4096};
RotMatrix(&rot, &m);
SetRotMatrix(&m);
// update sphere
POLY_G4* p = poly_sphere;
// offset plasma
static int off = 0;
if ( t >= 100 && t % 5 == 0 ) off++;
// light move
static int light_move_lat = 0;
static int light_move_long = 0;
static int light_move_dlat = 1;
static int light_move_dlong = 1;
if ( t % 1 == 0 ) {
if ( t % 3 == 0 ) {
light_move_lat += light_move_dlat;
if ( light_move_lat < 0 ) light_move_lat = 0;
if ( light_move_lat >= SPHERE_LATITUDE ) light_move_lat = SPHERE_LATITUDE-1;
if ( light_move_lat == 0 || light_move_lat == SPHERE_LATITUDE-1 ) light_move_dlat *= -1;
}
if ( t % 1 == 0 ) {
light_move_long += light_move_dlong;
if ( light_move_long < 0 ) light_move_long = 0;
if ( light_move_long >= SPHERE_LONGITUDE ) light_move_long = SPHERE_LONGITUDE-1;
if ( light_move_long == 0 || light_move_long == SPHERE_LONGITUDE-1 ) light_move_long *= -1;
}
}
// dynamic cutoff
static int light_dynamic_distance_max = 50;
if ( current_scene == SCENE_LIGHT_CUTOFF && t % 1 == 0 ) {
static const int LIGHT_DYNAMIC_DISTANCE_MIN = 20;
static const int LIGHT_DYNAMIC_DISTANCE_MAX = 60;
static int light_dynamic_ddist = -1;
light_dynamic_distance_max += light_dynamic_ddist;
if ( light_dynamic_distance_max <= LIGHT_DYNAMIC_DISTANCE_MIN || light_dynamic_distance_max >= LIGHT_DYNAMIC_DISTANCE_MAX ) light_dynamic_ddist *= -1;
}
int light_dynamic_distance_max2 = light_dynamic_distance_max * light_dynamic_distance_max;
// dynamic radius
if ( current_scene >= SCENE_ZOOM && t % 1 == 0 ) {
static const int ZOOM_MIN = 150;
static const int ZOOM_MAX = 900;
static int zoom_stride = 15;
static int zoom = 300;
SetGeomScreen(zoom);
zoom += zoom_stride;
if ( zoom <= ZOOM_MIN || zoom >= ZOOM_MAX ) zoom_stride *= -1;
}
int dt = 1;
for ( int la = 0; la < SPHERE_LATITUDE; la++ ) {
for ( int lo = 0; lo < SPHERE_LONGITUDE; lo++, p++ ) {
int lo_next = (lo+1)%SPHERE_LONGITUDE;
int la_next = SignalProcessing::min(la+1, SPHERE_LATITUDE-1);
SVECTOR* v0 = &sphere_vector[la*SPHERE_LONGITUDE+lo];
SVECTOR* v1 = &sphere_vector[la*SPHERE_LONGITUDE+lo_next];
SVECTOR* v2 = &sphere_vector[la_next*SPHERE_LONGITUDE+lo];
SVECTOR* v3 = &sphere_vector[la_next*SPHERE_LONGITUDE+lo_next];
long dmy, flag;
int otz = 0;
otz += RotTransPers(v0, (long*)&p->x0, &dmy, &flag);
otz += RotTransPers(v1, (long*)&p->x1, &dmy, &flag);
otz += RotTransPers(v2, (long*)&p->x2, &dmy, &flag);
otz += RotTransPers(v3, (long*)&p->x3, &dmy, &flag);
otz /= 4;
limitRange(otz, 0, OT_LENGTH-1);
AddPrim(ot + OT_LENGTH - 1 - otz, p);
if ( t < SCENE_LAT_FLAT*SPHERE_STEP_TIME ) { // latitude same flat color
current_scene = SCENE_LAT_FLAT;
unsigned char b = 255 * la / SPHERE_LATITUDE;
setRGB0(p, b, b, b);
setRGB1(p, b, b, b);
setRGB2(p, b, b, b);
setRGB3(p, b, b, b);
} else if ( t < SCENE_LAT_SMOOTH*SPHERE_STEP_TIME ) { // latitude same smooth color
current_scene = SCENE_LAT_SMOOTH;
unsigned char b = 255 * la / SPHERE_LATITUDE;
unsigned char bb = 255 * ((la+1)%SPHERE_LATITUDE) / SPHERE_LATITUDE;
if ( t < (SCENE_LAT_SMOOTH-1)*SPHERE_STEP_TIME + SPHERE_TRANSITION_STEP ) {
int d= (t%SPHERE_TRANSITION_STEP);
b = (b * d + p->r0 * (SPHERE_TRANSITION_STEP - d)) / SPHERE_TRANSITION_STEP;
bb = (bb * d + p->r2 * (SPHERE_TRANSITION_STEP - d)) / SPHERE_TRANSITION_STEP;
}
setRGB0(p, b, b, b);
setRGB1(p, b, b, b);
setRGB2(p, bb, bb, bb);
setRGB3(p, bb, bb, bb);
} else if ( t < SCENE_LIGHT_FIX_EDGE*SPHERE_STEP_TIME ) { // latitude same smooth color + lighting fix
dt = 3;
current_scene = SCENE_LIGHT_FIX_EDGE;
unsigned char b = 255;
unsigned char bb = 255;
const int LIGHT_LAT = 3*SPHERE_LATITUDE/4;
const int LIGHT_LONG = SPHERE_LONGITUDE/4;
const int LIGHT_DISTANCE_MAX = 50;
const int LIGHT_DISTANCE_MAX2 = LIGHT_DISTANCE_MAX * LIGHT_DISTANCE_MAX;
SVECTOR* l = &sphere_vector[LIGHT_LAT*SPHERE_LONGITUDE+LIGHT_LONG];
SVECTOR* v = &sphere_vector[la*SPHERE_LONGITUDE+lo];
SVECTOR* vv = &sphere_vector[la_next*SPHERE_LONGITUDE+lo];
int d = SignalProcessing::dist2(l, v);
int dd = SignalProcessing::dist2(l, vv);
b = (SignalProcessing::max(0, LIGHT_DISTANCE_MAX2 - d) * b) / LIGHT_DISTANCE_MAX2;
bb = (SignalProcessing::max(0, LIGHT_DISTANCE_MAX2 - dd) * bb) / LIGHT_DISTANCE_MAX2;
// smooth
if ( t < (SCENE_LIGHT_FIX-1)*SPHERE_STEP_TIME + SPHERE_TRANSITION_STEP ) {
int d= (t%SPHERE_TRANSITION_STEP);
b = (b * d + p->r0 * (SPHERE_TRANSITION_STEP - d)) / SPHERE_TRANSITION_STEP;
bb = (bb * d + p->r2 * (SPHERE_TRANSITION_STEP - d)) / SPHERE_TRANSITION_STEP;
}
setRGB0(p, b, b, b);
setRGB1(p, b, b, b);
setRGB2(p, bb, bb, bb);
setRGB3(p, bb, bb, bb);
} else if ( t < SCENE_LIGHT_FIX_SQUARE*SPHERE_STEP_TIME ) { // latitude same smooth color + lighting fix
dt = 3;
current_scene = SCENE_LIGHT_FIX_SQUARE;
unsigned char b = 255;
unsigned char bb = 255;
unsigned char bbb = 255;
unsigned char bbbb = 255;
const int LIGHT_LAT = 3*SPHERE_LATITUDE/4;
const int LIGHT_LONG = SPHERE_LONGITUDE/4;
const int LIGHT_DISTANCE_MAX = 50;
const int LIGHT_DISTANCE_MAX2 = LIGHT_DISTANCE_MAX * LIGHT_DISTANCE_MAX;
SVECTOR* l = &sphere_vector[LIGHT_LAT*SPHERE_LONGITUDE+LIGHT_LONG];
SVECTOR* v = &sphere_vector[la*SPHERE_LONGITUDE+lo];
SVECTOR* vv = &sphere_vector[la_next*SPHERE_LONGITUDE+lo];
SVECTOR* vvv = &sphere_vector[la*SPHERE_LONGITUDE+lo_next];
SVECTOR* vvvv = &sphere_vector[la_next*SPHERE_LONGITUDE+lo_next];
int d = SignalProcessing::dist2(l, v);
int dd = SignalProcessing::dist2(l, vv);
int ddd = SignalProcessing::dist2(l, vvv);
int dddd = SignalProcessing::dist2(l, vvvv);
b = (SignalProcessing::max(0, LIGHT_DISTANCE_MAX2 - d) * b) / LIGHT_DISTANCE_MAX2;
bb = (SignalProcessing::max(0, LIGHT_DISTANCE_MAX2 - dd) * bb) / LIGHT_DISTANCE_MAX2;
bbb = (SignalProcessing::max(0, LIGHT_DISTANCE_MAX2 - ddd) * bbb) / LIGHT_DISTANCE_MAX2;
bbbb = (SignalProcessing::max(0, LIGHT_DISTANCE_MAX2 - dddd) * bbbb) / LIGHT_DISTANCE_MAX2;
// smooth
if ( t < (SCENE_LIGHT_FIX-1)*SPHERE_STEP_TIME + SPHERE_TRANSITION_STEP ) {
int d= (t%SPHERE_TRANSITION_STEP);
b = (b * d + p->r0 * (SPHERE_TRANSITION_STEP - d)) / SPHERE_TRANSITION_STEP;
bb = (bb * d + p->r2 * (SPHERE_TRANSITION_STEP - d)) / SPHERE_TRANSITION_STEP;
bbb = (bbb * d + p->r2 * (SPHERE_TRANSITION_STEP - d)) / SPHERE_TRANSITION_STEP;
bbbb = (bbbb * d + p->r2 * (SPHERE_TRANSITION_STEP - d)) / SPHERE_TRANSITION_STEP;
}
setRGB0(p, b, b, b);
setRGB1(p, bb, bb, bb);
setRGB2(p, bbb, bbb, bbb);
setRGB3(p, bbbb, bbbb, bbbb);
} else if ( t < SCENE_LIGHT_FIX*SPHERE_STEP_TIME ) { // latitude same smooth color + lighting fix
dt = 1;
current_scene = SCENE_LIGHT_FIX;
unsigned char b = 255;
unsigned char bb = 255;
unsigned char bbb = 255;
unsigned char bbbb = 255;
const int LIGHT_LAT = 3*SPHERE_LATITUDE/4;
const int LIGHT_LONG = SPHERE_LONGITUDE/4;
const int LIGHT_DISTANCE_MAX = 50;
const int LIGHT_DISTANCE_MAX2 = LIGHT_DISTANCE_MAX * LIGHT_DISTANCE_MAX;
SVECTOR* l = &sphere_vector[LIGHT_LAT*SPHERE_LONGITUDE+LIGHT_LONG];
SVECTOR* v = &sphere_vector[la*SPHERE_LONGITUDE+lo];
SVECTOR* vv = &sphere_vector[la_next*SPHERE_LONGITUDE+lo];
SVECTOR* vvv = &sphere_vector[la*SPHERE_LONGITUDE+lo_next];
SVECTOR* vvvv = &sphere_vector[la_next*SPHERE_LONGITUDE+lo_next];
int d = SignalProcessing::dist2(l, v);
int dd = SignalProcessing::dist2(l, vv);
int ddd = SignalProcessing::dist2(l, vvv);
int dddd = SignalProcessing::dist2(l, vvvv);
b = (SignalProcessing::max(0, LIGHT_DISTANCE_MAX2 - d) * b) / LIGHT_DISTANCE_MAX2;
bb = (SignalProcessing::max(0, LIGHT_DISTANCE_MAX2 - dd) * bb) / LIGHT_DISTANCE_MAX2;
bbb = (SignalProcessing::max(0, LIGHT_DISTANCE_MAX2 - ddd) * bbb) / LIGHT_DISTANCE_MAX2;
bbbb = (SignalProcessing::max(0, LIGHT_DISTANCE_MAX2 - dddd) * bbbb) / LIGHT_DISTANCE_MAX2;
// smooth
if ( t < (SCENE_LIGHT_FIX-1)*SPHERE_STEP_TIME + SPHERE_TRANSITION_STEP ) {
int d= (t%SPHERE_TRANSITION_STEP);
b = (b * d + p->r0 * (SPHERE_TRANSITION_STEP - d)) / SPHERE_TRANSITION_STEP;
bb = (bb * d + p->r2 * (SPHERE_TRANSITION_STEP - d)) / SPHERE_TRANSITION_STEP;
bbb = (bbb * d + p->r1 * (SPHERE_TRANSITION_STEP - d)) / SPHERE_TRANSITION_STEP;
bbbb = (bbbb * d + p->r3 * (SPHERE_TRANSITION_STEP - d)) / SPHERE_TRANSITION_STEP;
}
setRGB0(p, b, b, b);
setRGB2(p, bb, bb, bb);
setRGB1(p, bbb, bbb, bbb);
setRGB3(p, bbbb, bbbb, bbbb);
} else if ( t < SCENE_LIGHT_MOVE*SPHERE_STEP_TIME ) { // latitude same smooth color + lighting move
current_scene = SCENE_LIGHT_MOVE;
unsigned char b = 255;
unsigned char bb = 255;
unsigned char bbb = 255;
unsigned char bbbb = 255;
const int LIGHT_DISTANCE_MAX = 50;
const int LIGHT_DISTANCE_MAX2 = LIGHT_DISTANCE_MAX * LIGHT_DISTANCE_MAX;
// light
{
SVECTOR* l = &sphere_vector[light_move_lat*SPHERE_LONGITUDE+light_move_long];
SVECTOR* v = &sphere_vector[la*SPHERE_LONGITUDE+lo];
SVECTOR* vv = &sphere_vector[la_next*SPHERE_LONGITUDE+lo];
SVECTOR* vvv = &sphere_vector[la*SPHERE_LONGITUDE+lo_next];
SVECTOR* vvvv = &sphere_vector[la_next*SPHERE_LONGITUDE+lo_next];
int d = SignalProcessing::dist2(l, v);
int dd = SignalProcessing::dist2(l, vv);
int ddd = SignalProcessing::dist2(l, vvv);
int dddd = SignalProcessing::dist2(l, vvvv);
b = (SignalProcessing::max(0, LIGHT_DISTANCE_MAX2 - d) * b) / LIGHT_DISTANCE_MAX2;
bb = (SignalProcessing::max(0, LIGHT_DISTANCE_MAX2 - dd) * bb) / LIGHT_DISTANCE_MAX2;
bbb = (SignalProcessing::max(0, LIGHT_DISTANCE_MAX2 - ddd) * bbb) / LIGHT_DISTANCE_MAX2;
bbbb = (SignalProcessing::max(0, LIGHT_DISTANCE_MAX2 - dddd) * bbbb) / LIGHT_DISTANCE_MAX2;
}
// smooth
if ( t < (SCENE_LIGHT_MOVE-1)*SPHERE_STEP_TIME + SPHERE_TRANSITION_STEP ) {
int d= (t%SPHERE_TRANSITION_STEP);
b = (b * d + p->r0 * (SPHERE_TRANSITION_STEP - d)) / SPHERE_TRANSITION_STEP;
bb = (bb * d + p->r2 * (SPHERE_TRANSITION_STEP - d)) / SPHERE_TRANSITION_STEP;
bbb = (bbb * d + p->r1 * (SPHERE_TRANSITION_STEP - d)) / SPHERE_TRANSITION_STEP;
bbbb = (bbbb * d + p->r3 * (SPHERE_TRANSITION_STEP - d)) / SPHERE_TRANSITION_STEP;
}
setRGB0(p, b, b, b);
setRGB2(p, bb, bb, bb);
setRGB1(p, bbb, bbb, bbb);
setRGB3(p, bbbb, bbbb, bbbb);
} else if ( t < SCENE_LIGHT_CUTOFF*SPHERE_STEP_TIME ) { // latitude same smooth color + lighting move + dynamic cutoff
current_scene = SCENE_LIGHT_CUTOFF;
unsigned char b = 255;
unsigned char bb = 255;
unsigned char bbb = 255;
unsigned char bbbb = 255;
// light
{
SVECTOR* l = &sphere_vector[light_move_lat*SPHERE_LONGITUDE+light_move_long];
SVECTOR* v = &sphere_vector[la*SPHERE_LONGITUDE+lo];
SVECTOR* vv = &sphere_vector[la_next*SPHERE_LONGITUDE+lo];
SVECTOR* vvv = &sphere_vector[la*SPHERE_LONGITUDE+lo_next];
SVECTOR* vvvv = &sphere_vector[la_next*SPHERE_LONGITUDE+lo_next];
int d = SignalProcessing::dist2(l, v);
int dd = SignalProcessing::dist2(l, vv);
int ddd = SignalProcessing::dist2(l, vvv);
int dddd = SignalProcessing::dist2(l, vvvv);
b = (SignalProcessing::max(0, light_dynamic_distance_max2 - d) * b) / light_dynamic_distance_max2;
bb = (SignalProcessing::max(0, light_dynamic_distance_max2 - dd) * bb) / light_dynamic_distance_max2;
bbb = (SignalProcessing::max(0, light_dynamic_distance_max2 - ddd) * bbb) / light_dynamic_distance_max2;
bbbb = (SignalProcessing::max(0, light_dynamic_distance_max2 - dddd) * bbbb) / light_dynamic_distance_max2;
}
// smooth
if ( t < (SCENE_LIGHT_CUTOFF-1)*SPHERE_STEP_TIME + SPHERE_TRANSITION_STEP ) {
int d= (t%SPHERE_TRANSITION_STEP);
b = (b * d + p->r0 * (SPHERE_TRANSITION_STEP - d)) / SPHERE_TRANSITION_STEP;
bb = (bb * d + p->r2 * (SPHERE_TRANSITION_STEP - d)) / SPHERE_TRANSITION_STEP;
bbb = (bbb * d + p->r1 * (SPHERE_TRANSITION_STEP - d)) / SPHERE_TRANSITION_STEP;
bbbb = (bbbb * d + p->r3 * (SPHERE_TRANSITION_STEP - d)) / SPHERE_TRANSITION_STEP;
}
setRGB0(p, b, b, b);
setRGB2(p, bb, bb, bb);
setRGB1(p, bbb, bbb, bbb);
setRGB3(p, bbbb, bbbb, bbbb);
} else if ( t < SCENE_ZOOM*SPHERE_STEP_TIME ) { // latitude same smooth color + lighting move + dynamic cutoff + zoom
current_scene = SCENE_ZOOM;
unsigned char b = 255;
unsigned char bb = 255;
unsigned char bbb = 255;
unsigned char bbbb = 255;
// light
{
SVECTOR* l = &sphere_vector[light_move_lat*SPHERE_LONGITUDE+light_move_long];
SVECTOR* v = &sphere_vector[la*SPHERE_LONGITUDE+lo];
SVECTOR* vv = &sphere_vector[la_next*SPHERE_LONGITUDE+lo];
SVECTOR* vvv = &sphere_vector[la*SPHERE_LONGITUDE+lo_next];
SVECTOR* vvvv = &sphere_vector[la_next*SPHERE_LONGITUDE+lo_next];
int d = SignalProcessing::dist2(l, v);
int dd = SignalProcessing::dist2(l, vv);
int ddd = SignalProcessing::dist2(l, vvv);
int dddd = SignalProcessing::dist2(l, vvvv);
b = (SignalProcessing::max(0, light_dynamic_distance_max2 - d) * b) / light_dynamic_distance_max2;
bb = (SignalProcessing::max(0, light_dynamic_distance_max2 - dd) * bb) / light_dynamic_distance_max2;
bbb = (SignalProcessing::max(0, light_dynamic_distance_max2 - ddd) * bbb) / light_dynamic_distance_max2;
bbbb = (SignalProcessing::max(0, light_dynamic_distance_max2 - dddd) * bbbb) / light_dynamic_distance_max2;
}
// smooth
if ( t < (SCENE_ZOOM-1)*SPHERE_STEP_TIME + SPHERE_TRANSITION_STEP ) {
int d= (t%SPHERE_TRANSITION_STEP);
b = (b * d + p->r0 * (SPHERE_TRANSITION_STEP - d)) / SPHERE_TRANSITION_STEP;
bb = (bb * d + p->r2 * (SPHERE_TRANSITION_STEP - d)) / SPHERE_TRANSITION_STEP;
bbb = (bbb * d + p->r1 * (SPHERE_TRANSITION_STEP - d)) / SPHERE_TRANSITION_STEP;
bbbb = (bbbb * d + p->r3 * (SPHERE_TRANSITION_STEP - d)) / SPHERE_TRANSITION_STEP;
}
setRGB0(p, b, b, b);
setRGB2(p, bb, bb, bb);
setRGB1(p, bbb, bbb, bbb);
setRGB3(p, bbbb, bbbb, bbbb);
}
else { // smooth bande move + lighting move
current_scene = SCENE_LIGHT_SINUS_WAVE;
const int LIGHT_DISTANCE_MAX = 50;
const int LIGHT_DISTANCE_MAX2 = LIGHT_DISTANCE_MAX * LIGHT_DISTANCE_MAX;
const int NB_COLOR = 5;
unsigned char b = (255 * (((la+off)%SPHERE_LATITUDE)%NB_COLOR)) / (NB_COLOR-1);
unsigned char bb = (255 * (((la+1+off)%SPHERE_LATITUDE)%NB_COLOR)) / (NB_COLOR-1);
unsigned char bbb = (255 * (((la+off)%SPHERE_LATITUDE)%NB_COLOR)) / (NB_COLOR-1);
unsigned char bbbb = (255 * (((la+1+off)%SPHERE_LATITUDE)%NB_COLOR)) / (NB_COLOR-1);
// light
{
SVECTOR* l = &sphere_vector[light_move_lat*SPHERE_LONGITUDE+light_move_long];
SVECTOR* v = &sphere_vector[la*SPHERE_LONGITUDE+lo];
SVECTOR* vv = &sphere_vector[la_next*SPHERE_LONGITUDE+lo];
SVECTOR* vvv = &sphere_vector[la*SPHERE_LONGITUDE+lo_next];
SVECTOR* vvvv = &sphere_vector[la_next*SPHERE_LONGITUDE+lo_next];
int d = SignalProcessing::dist2(l, v);
int dd = SignalProcessing::dist2(l, vv);
int ddd = SignalProcessing::dist2(l, vvv);
int dddd = SignalProcessing::dist2(l, vvvv);
b = (SignalProcessing::max(0, LIGHT_DISTANCE_MAX2 - d) * b) / LIGHT_DISTANCE_MAX2;
bb = (SignalProcessing::max(0, LIGHT_DISTANCE_MAX2 - dd) * bb) / LIGHT_DISTANCE_MAX2;
bbb = (SignalProcessing::max(0, LIGHT_DISTANCE_MAX2 - ddd) * bbb) / LIGHT_DISTANCE_MAX2;
bbbb = (SignalProcessing::max(0, LIGHT_DISTANCE_MAX2 - dddd) * bbbb) / LIGHT_DISTANCE_MAX2;
}
// smooth
if ( t < 5*SPHERE_STEP_TIME + SPHERE_TRANSITION_STEP ) {
int d= (t%SPHERE_TRANSITION_STEP);
b = (b * d + p->r0 * (SPHERE_TRANSITION_STEP - d)) / SPHERE_TRANSITION_STEP;
bb = (bb * d + p->r2 * (SPHERE_TRANSITION_STEP - d)) / SPHERE_TRANSITION_STEP;
bbb = (bbb * d + p->r1 * (SPHERE_TRANSITION_STEP - d)) / SPHERE_TRANSITION_STEP;
bbbb = (bbbb * d + p->r3 * (SPHERE_TRANSITION_STEP - d)) / SPHERE_TRANSITION_STEP;
}
setRGB0(p, b, b, b);
setRGB2(p, bb, bb, bb);
setRGB1(p, bbb, bbb, bbb);
setRGB3(p, bbbb, bbbb, bbbb);
}
}
}
display();
t += dt;
}
MemoryManager::free(sphere_vector);
MemoryManager::free(poly_sphere);
}
