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 init() {
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowSize(360, 360);
glutCreateWindow( "Cylinder Calculate Light" );
glEnable(GL_DEPTH_TEST);
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
set_lighting();
GenerateSurface();
glShadeModel(GL_SMOOTH);
}
int main(int argc, char* argv[]) {
//glut initialization
glutInit(&argc, argv);
glutInitWindowSize(init_win_width, init_win_height);
win_id = glutCreateWindow(win_title);
if(win_id <= 0) {
fprintf(stderr, "Error: glutCreateWindow() returned %d\n", win_id);
exit(1);
}
//scene initialization
init();
glutDisplayFunc(display);
glutKeyboardFunc(keyboard);
glutIdleFunc(idle);
glutMouseFunc(mouse);
glutMotionFunc(motion);
set_projection();
set_lighting();
init_textures();
glEnable(GL_TEXTURE_2D);
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_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
numOfVerts = NULL;
glBindTexture(GL_TEXTURE_2D, 0);
glutMainLoop();
return 0;
}
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;
}
static void draw_screen()
{
static double last_frame_time;
static int frame_index;
static float frame_rates[FRAME_INDEX_MAX];
static float frame_times[FRAME_INDEX_MAX];
double start_time = time_now_double();
glClearColor(0.0, 0.0, 0.0, 0.0);
graph_dev_start_frame();
sng_set_foreground(WHITE);
sng_abs_xy_draw_string("F1 FOR HELP", NANO_FONT, SCREEN_WIDTH - 100, 10);
static struct entity_context *cx;
if (!cx)
cx = entity_context_new(50, 50);
if (wireframe != oldwireframe) {
oldwireframe = wireframe;
if (wireframe)
set_renderer(cx, WIREFRAME_RENDERER | BLACK_TRIS);
else
set_renderer(cx, FLATSHADING_RENDERER);
}
float r = target_mesh->radius / tan(FOV / 3.0); /* 50% size for middle zoom */
float r_cam = r * lobby_zoom / 255.0;
camera_set_parameters(cx, 0.1f, r * 2.2, SCREEN_WIDTH, SCREEN_HEIGHT, FOV);
camera_set_pos(cx, r_cam, 0, 0);
camera_look_at(cx, 0, 0, 0);
camera_assign_up_direction(cx, 0, 1, 0);
union vec3 light_pos = { { 1.01 * r, 0, 0 } };
quat_rot_vec_self(&light_pos, &light_orientation);
set_lighting(cx, light_pos.v.x, light_pos.v.y, light_pos.v.z);
calculate_camera_transform(cx);
struct entity *e = add_entity(cx, target_mesh, 0, 0, 0, WHITE);
struct entity *ae = NULL;
if (planet_mode) {
update_entity_material(e, &planet_material);
if (draw_atmosphere) {
ae = add_entity(cx, atmosphere_mesh, 0, 0, 0, WHITE);
update_entity_scale(ae, 1.03);
update_entity_material(ae, &atmosphere_material);
}
}
update_entity_orientation(e, &lobby_orientation);
if (isDraggingLight) {
union vec3 light_dir = { { 10.75 * r_cam, 0, 0 } };
quat_rot_vec_self(&light_dir, &light_orientation);
sng_set_foreground(WHITE);
render_line(cx, light_dir.v.x, light_dir.v.y, light_dir.v.z, 0, 0, 0);
e = add_entity(cx, light_mesh, light_dir.v.x, light_dir.v.y, light_dir.v.z, WHITE);
} else {
e = add_entity(cx, light_mesh, light_pos.v.x, light_pos.v.y, light_pos.v.z, WHITE);
}
render_entities(cx);
remove_all_entity(cx);
if (helpmode)
draw_help_screen(0);
if (display_frame_stats > 0) {
float avg_frame_rate = 0;
float avg_frame_time = 0;
int i;
for (i = 0; i < FRAME_INDEX_MAX; i++) {
avg_frame_rate += frame_rates[i];
avg_frame_time += frame_times[i];
}
avg_frame_rate /= (float)FRAME_INDEX_MAX;
avg_frame_time /= (float)FRAME_INDEX_MAX;
sng_set_foreground(WHITE);
char stat_buffer[30];
sprintf(stat_buffer, "fps %5.2f", 1.0/avg_frame_rate);
sng_abs_xy_draw_string(stat_buffer, NANO_FONT, 2, 10);
sprintf(stat_buffer, "t %0.2f ms", avg_frame_time * 1000.0);
sng_abs_xy_draw_string(stat_buffer, NANO_FONT, 92, 10);
}
if (display_frame_stats > 1)
graph_dev_display_debug_menu_show();
graph_dev_end_frame();
glFinish();
/*
* Swap the buffers. This this tells the driver to
* render the next frame from the contents of the
* back-buffer, and to set all rendering operations
* to occur on what was the front-buffer.
*
* Double buffering prevents nasty visual tearing
* from the application drawing on areas of the
* screen that are being updated at the same time.
*/
SDL_GL_SwapBuffers();
if (display_frame_stats > 0) {
double end_time = time_now_double();
frame_rates[frame_index] = start_time - last_frame_time;
frame_times[frame_index] = end_time - start_time;
frame_index = (frame_index + 1) % FRAME_INDEX_MAX;
last_frame_time = start_time;
}
}
static int draw_proc(struct menu_item *item,
struct menu_draw_params *draw_params)
{
static Gfx null_dl = gsSPEndDisplayList();
struct item_data *data = item->data;
/* handle input */
if (!input_bind_held(COMMAND_PREVROOM) &&
!input_bind_held(COMMAND_NEXTROOM))
{
uint16_t pad = input_pad();
if (pad & BUTTON_Z) {
if (pad & BUTTON_D_UP)
data->y += 50.f;
if (pad & BUTTON_D_DOWN)
data->y += -50.f;
if (pad & BUTTON_D_LEFT) {
data->x -= cos(data->yaw) * 50.f;
data->z += sin(data->yaw) * 50.f;
}
if (pad & BUTTON_D_RIGHT) {
data->x -= cos(data->yaw) * -50.f;
data->z += sin(data->yaw) * -50.f;
}
}
else {
if (pad & BUTTON_D_UP) {
data->x -= sin(data->yaw) * 50.f;
data->z -= cos(data->yaw) * 50.f;
}
if (pad & BUTTON_D_DOWN) {
data->x -= sin(data->yaw) * -50.f;
data->z -= cos(data->yaw) * -50.f;
}
if (pad & BUTTON_D_LEFT)
data->yaw += .2f;
if (pad & BUTTON_D_RIGHT)
data->yaw -= .2f;
}
}
/* load resources */
if (data->state == STATE_LOAD) {
/* initialize segment table */
z64_stab_t stab = z64_stab;
/* load scene */
if (data->scene_index != data->scene_next || !data->scene_file) {
if (data->scene_file)
free(data->scene_file);
data->scene_index = data->scene_next;
data->room_index = -1;
z64_scene_table_t *scene_entry = &z64_scene_table[data->scene_index];
uint32_t scene_vrom_start = scene_entry->scene_vrom_start;
uint32_t scene_vrom_end = scene_entry->scene_vrom_end;
uint32_t scene_vrom_size = scene_vrom_end - scene_vrom_start;
data->scene_file = malloc(scene_vrom_size);
zu_getfile(scene_vrom_start, data->scene_file, scene_vrom_size);
}
stab.seg[Z64_SEG_SCENE] = MIPS_KSEG0_TO_PHYS(data->scene_file);
/* populate room list */
struct zu_file room_files[0x100];
zu_scene_rooms(zu_sr_header(data->scene_file,
z64_file.scene_setup_index, &stab),
room_files, 0x100, &data->n_rooms, &stab);
/* load room */
if (data->room_index != data->room_next || !data->room_file) {
if (data->room_file) {
free(data->room_file);
zu_mesh_destroy(&data->room_mesh);
}
data->room_index = data->room_next;
uint32_t room_vrom_start = room_files[data->room_index].vrom_start;
uint32_t room_vrom_end = room_files[data->room_index].vrom_end;
uint32_t room_vrom_size = room_vrom_end - room_vrom_start;
data->room_file = malloc(room_vrom_size);
zu_getfile(room_vrom_start, data->room_file, room_vrom_size);
stab.seg[Z64_SEG_ROOM] = MIPS_KSEG0_TO_PHYS(data->room_file);
/* populate mesh */
zu_room_mesh(zu_sr_header(data->room_file,
z64_file.scene_setup_index, &stab),
&data->room_mesh, &stab);
/* populate vertex list */
struct zu_vlist vlist;
zu_vlist_init(&vlist);
stab.seg[0x08] = MIPS_KSEG0_TO_PHYS(&null_dl);
stab.seg[0x09] = MIPS_KSEG0_TO_PHYS(&null_dl);
stab.seg[0x0A] = MIPS_KSEG0_TO_PHYS(&null_dl);
stab.seg[0x0B] = MIPS_KSEG0_TO_PHYS(&null_dl);
stab.seg[0x0C] = MIPS_KSEG0_TO_PHYS(&null_dl);
stab.seg[0x0D] = MIPS_KSEG0_TO_PHYS(&null_dl);
for (int i = 0; i < ZU_MESH_TYPES; ++i)
for (int j = 0; j < data->room_mesh.all[i].size; ++j)
zu_vlist_add_dl(&vlist, &stab,
zu_seg_locate(&stab,
data->room_mesh.all[i].dlists[j]));
/* compute bounding box */
struct zu_bbox bbox;
zu_vlist_bbox(&vlist, &bbox);
/* set orientation */
{
data->x = (bbox.x1 + bbox.x2) / 2.f;
data->y = (bbox.y1 + bbox.y2) / 2.f;
data->z = (bbox.z1 + bbox.z2) / 2.f;
data->yaw = 0.f;
}
zu_vlist_destroy(&vlist);
}
/* proceed to rendering */
data->state = STATE_RENDER;
}
/* render room */
if (data->state == STATE_RENDER && data->room_file) {
/* initialize rcp for rendering rooms */
static void *zbuf = NULL;
if (!zbuf)
zbuf = memalign(64, 2 * Z64_SCREEN_WIDTH * Z64_SCREEN_HEIGHT);
gDisplayListAppend(&data->gfx.poly_opa.p,
/* clear z buffer */
gsDPPipeSync(),
gsDPSetCycleType(G_CYC_FILL),
gsDPSetRenderMode(G_RM_NOOP, G_RM_NOOP2),
gsDPSetColorImage(G_IM_FMT_RGBA, G_IM_SIZ_16b, Z64_SCREEN_WIDTH, zbuf),
gsDPSetFillColor((GPACK_ZDZ(G_MAXFBZ, 0) << 16) |
GPACK_ZDZ(G_MAXFBZ, 0)),
gsDPFillRectangle(0, 0, Z64_SCREEN_WIDTH - 1, Z64_SCREEN_HEIGHT - 1),
gsDPPipeSync(),
gsDPSetColorImage(G_IM_FMT_RGBA, G_IM_SIZ_16b, Z64_SCREEN_WIDTH,
ZU_MAKE_SEG(Z64_SEG_CIMG, 0)),
gsDPSetDepthImage(zbuf),
/* rsp settings */
gsSPSegment(Z64_SEG_SCENE, data->scene_file),
gsSPSegment(Z64_SEG_ROOM, data->room_file),
gsSPSegment(0x08, &null_dl),
gsSPSegment(0x09, &null_dl),
gsSPSegment(0x0A, &null_dl),
gsSPSegment(0x0B, &null_dl),
gsSPSegment(0x0C, &null_dl),
gsSPSegment(0x0D, &null_dl),
gsSPLoadGeometryMode(G_ZBUFFER | G_SHADE | G_CULL_BACK | G_LIGHTING |
G_SHADING_SMOOTH),
/* rdp settings */
gsDPSetAlphaCompare(G_AC_NONE),
gsDPSetDepthSource(G_ZS_PIXEL),
gsDPSetAlphaDither(G_AD_DISABLE),
gsDPSetColorDither(G_CD_DISABLE),
gsDPSetCombineKey(G_OFF),
gsDPSetTextureConvert(G_TC_FILT),
gsDPSetTextureFilter(G_TF_BILERP),
gsDPSetTextureLOD(G_TL_TILE),
gsDPSetTexturePersp(G_TP_PERSP),
gsDPSetCycleType(G_CYC_2CYCLE),
gsDPPipelineMode(G_PM_NPRIMITIVE),
gsDPSetEnvColor(0xFF, 0xFF, 0xFF, 0xFF),
gsDPSetFogColor(0x00, 0x00, 0x00, 0x00),
gsDPSetScissor(G_SC_NON_INTERLACE, 32, 32,
Z64_SCREEN_WIDTH - 32, Z64_SCREEN_HEIGHT - 32),
);
/* create projection matrix */
{
Mtx m;
MtxF mf;
MtxF mt;
guPerspectiveF(&mf, NULL, atanf(2.f),
(float)Z64_SCREEN_WIDTH / (float)Z64_SCREEN_HEIGHT,
50.f, 5000.f, 1.f);
{
guScaleF(&mt, data->scale, data->scale, data->scale);
guMtxCatF(&mt, &mf, &mf);
}
{
guRotateF(&mt, M_PI / 6.f, 1.f, 0.f, 0.f);
guMtxCatF(&mt, &mf, &mf);
}
{
guTranslateF(&mt, 0.f, -100.f, -200.f);
guMtxCatF(&mt, &mf, &mf);
}
{
guRotateF(&mt, -data->yaw, 0.f, 1.f, 0.f);
guMtxCatF(&mt, &mf, &mf);
}
{
guTranslateF(&mt, -data->x, -data->y, -data->z);
guMtxCatF(&mt, &mf, &mf);
}
guMtxF2L(&mf, &m);
gSPMatrix(data->gfx.poly_opa.p++,
gDisplayListData(&data->gfx.poly_opa.d, m),
G_MTX_PROJECTION | G_MTX_LOAD);
gSPMatrix(data->gfx.poly_xlu.p++,
gDisplayListData(&data->gfx.poly_xlu.d, m),
G_MTX_PROJECTION | G_MTX_LOAD);
}
/* create modelview matrix */
{
Mtx m;
guMtxIdent(&m);
gSPMatrix(data->gfx.poly_opa.p++,
gDisplayListData(&data->gfx.poly_opa.d, m),
G_MTX_MODELVIEW | G_MTX_LOAD);
gSPMatrix(data->gfx.poly_xlu.p++,
gDisplayListData(&data->gfx.poly_xlu.d, m),
G_MTX_MODELVIEW | G_MTX_LOAD);
}
/* configure lights */
zu_gfx_inject(&data->gfx);
set_lighting();
/* execute scene config */
z64_scene_config_table[z64_scene_table[
z64_game.scene_index].scene_config](&z64_game);
zu_gfx_restore(&data->gfx);
/* draw scene */
for (int i = 0; i < ZU_MESH_TYPES; ++i)
for (int j = 0; j < data->room_mesh.all[i].size; ++j) {
if (i == ZU_MESH_OPA || i == ZU_MESH_NEAR) {
gSPDisplayList(data->gfx.poly_opa.p++,
data->room_mesh.all[i].dlists[j]);
}
else if (i == ZU_MESH_XLU || i == ZU_MESH_FAR) {
gSPDisplayList(data->gfx.poly_xlu.p++,
data->room_mesh.all[i].dlists[j]);
}
}
/* draw actors */
if (z64_game.pause_state == 0) {
zu_gfx_inject(&data->gfx);
z64_DrawActors(&z64_game, &z64_game.actor_ctxt);
zu_gfx_restore(&data->gfx);
}
/* draw additional stuff */
draw_crosshair(item);
/* flush */
gfx_disp(gsSPDisplayList(zu_gfx_flush(&data->gfx)));
/* restore rcp modes */
gfx_mode_init();
/* draw info */
gfx_mode_set(GFX_MODE_COLOR, GPACK_RGBA8888(0xC0, 0xC0, 0xC0,
draw_params->alpha));
gfx_printf(draw_params->font, 36, 44, "scene %i", data->scene_index);
gfx_printf(draw_params->font, 36, 44 + menu_get_cell_height(item->owner, 1),
"room %i", data->room_index);
}
/* wait for rendering to finish before unloading */
if (data->state == STATE_UNLOAD)
data->state = STATE_LOAD;
return 1;
}
