int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE);
glutInitContextVersion(2,1);
// Init window
glutInitWindowPosition((glutGet(GLUT_SCREEN_WIDTH) - SIZE_X) / 2, (glutGet(GLUT_SCREEN_HEIGHT) - SIZE_Y) / 2);
glutInitWindowSize(SIZE_X, SIZE_Y);
glutCreateWindow("PV112 - cv2");
// Register callbacks
glutDisplayFunc(render);
glutIdleFunc(render);
glutKeyboardFunc(keyPressed);
glutReshapeFunc(resize);
glutPassiveMotionFunc(mouse_moved);
glutMotionFunc(mouse_moved);
glutWarpPointer( glutGet(GLUT_WINDOW_WIDTH)/2, glutGet(GLUT_WINDOW_HEIGHT)/2 );
// Enable depth testing
glEnable(GL_DEPTH_TEST);
// Enable lighting
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
load_scene();
// Main loop
glutMainLoop();
return 0;
}
Lightway::Lightway(QWidget *parent, Qt::WFlags flags)
: QMainWindow(parent, flags)
{
ui.setupUi(this);
viewport = new Viewport(this);
setPreviewWidget(viewport);
historyViewer = new SampleHistoryViewer(this);
setSampleViewWidget(historyViewer);
renderCore_ = unique_ptr<RenderCore>(new RenderCore());
viewport->renderCore = renderCore_.get();
scene = unique_ptr<RTScene>(new RTScene());
//scene->scene = load_scene("../../../assets/sponza.obj", float3(0, 0, 0), 1);
scene->scene = load_scene("../../../assets/validation/diffuse_validation5.obj", float3(0, 0, 0), 1);
//scene->scene = load_scene("../../../assets/validation/spec_validation3.obj", float3(0, 0, 0), 1);
//scene->scene = load_scene("../../../assets/validation/t_validation1.obj", float3(0, 0, 0), 1);
//scene->scene = load_scene("../../../assets/bunny.obj", float3(0, 0, 0), 5);
scene->make_accl();
renderCore_->scene = scene.get();
historyViewer->syncTo(&renderCore_->sampleDebugger().shr);
connect(ui.actionRecord_10, SIGNAL(triggered()), this, SLOT(record10()));
connect(ui.actionRecord_50, SIGNAL(triggered()), this, SLOT(record50()));
connect(&renderCore_->sampleDebugger().shr, SIGNAL(finishedRecording()), this, SLOT(recordingFinished()));
}
//TODO: Add to docs
static int luaScene_raw_load(lua_State* L){
void* raw_config = lua_touserdata(L, 1);
if(raw_config){
auto scene = reinterpret_cast<Scene*>(lua_touserdata(L, lua_upvalueindex(1)));
scene->load_scene(*reinterpret_cast<SimConfig*>(raw_config));
}
return 0;
}
int main(int argc, const char * argv[]) {
char story_path[256];
setbuf(stdout, NULL);
//printf("Please inform the path to the story you want to play:\n> " );
strcpy(story_path, "..\\NginText\\stories\\prototype.story");
//gets(story_path);
open_story(story_path);
load_scene("@Inicio");
system("pause");
exit(0);
}
int key_hook_scene(int keycode, t_env *e)
{
if (keycode == M || keycode == M_MAC)
{
e->scene->mode = e->scene->mode == EDIT_MODE ? MOVE_MODE : EDIT_MODE;
e->scene->selected_object = NULL;
}
if (keycode == R || keycode == R_MAC)
load_scene(e->scene_type, e);
else if (keycode == P || keycode == P_MAC)
switch_scene(LEFT, e);
else if (keycode == N || keycode == N_MAC)
switch_scene(RIGHT, e);
return (0);
}
int main( int argc, char* argv[] )
{
Options opt;
Matrix3 mat;
Matrix4 trn;
make_transformation_matrix( &trn, Vector3::Zero, Quaternion::Identity, Vector3( 2, 2, 2 ) );
make_normal_matrix( &mat, trn );
if ( !parse_args( &opt, argc, argv ) ) {
return 1;
}
RaytracerApplication app( opt );
// load the given scene
if ( !load_scene( &app.scene, opt.input_filename ) ) {
std::cout << "Error loading scene " << opt.input_filename << ". Aborting.\n";
return 1;
}
if ( opt.open_window ) {
real_t fps = 30.0;
const char* title = "15462 Project 2 - Raytracer";
// start a new application
return Application::start_application( &app, opt.width, opt.height, fps, title );
} else {
app.initialize();
app.toggle_raytracing( opt.width, opt.height );
if ( !app.raytracing ) {
return 1;
}
assert( app.buffer );
// raytrace until done
app.raytracer.raytrace( app.buffer, 0 );
// output result
app.output_image();
return 0;
}
}
void init_scene(t_rt *rt, char *scene)
{
if (rt)
{
rt->objs = NULL;
rt->lights = NULL;
if (!(rt->camera))
init_camera(&(rt->camera), *(rt->screen),
rt->space);
load_scene(rt, scene);
if (!(rt->lights))
init_lights(&(rt->lights));
if (!(rt->objs))
init_objs(&(rt->objs));
if (scene)
free(scene);
}
}
int main(int argc, const char** argv) {
// command line
yc_parser* parser = yc_init_parser(argc, argv, "view meshes");
float amb = yc_parse_optf(parser, "--ambient", 0, "ambient factor", 0);
bool camera_lights = yc_parse_optb(parser, "--camera_lights", "-c",
"enable camera lights", false);
int camera = yc_parse_opti(parser, "--camera", "-C", "camera", 0);
bool no_ui = yc_parse_optb(parser, "--no-ui", 0, "runs offline", false);
float aspect =
yc_parse_optf(parser, "--aspect", "-a", "image aspect", 16.0f / 9.0f);
float dt =
yc_parse_optf(parser, "--delta_time", "-dt", "delta time", 1 / 60.0f);
int res =
yc_parse_opti(parser, "--resolution", "-r", "image resolution", 720);
const char* imfilename =
yc_parse_opts(parser, "--output", "-o", "image filename", "out.png");
const char* filename =
yc_parse_args(parser, "scene", "scene filename", 0, true);
yc_done_parser(parser);
// load scene
yo_scene* scene = load_scene(filename);
scene->cameras[camera].width = aspect * scene->cameras[camera].height;
// init rigid simulation
yb_scene* scene_bvh;
ysr_scene* rigid_scene = make_rigid_scene(scene, &scene_bvh);
// start
ui_loop(filename, imfilename, scene, rigid_scene, dt,
(int)round(res * aspect), res, camera_lights, amb, no_ui);
// done
// TODO: clean bvh
ysr_free_scene(rigid_scene);
yo_free_scene(scene);
return EXIT_SUCCESS;
}
int main(int argc, char **argv)
{
t_rt s_rt;
if (argc == 3)
{
s_rt.s_eye.x = -3000;
s_rt.s_eye.y = 0;
s_rt.s_eye.z = 0;
s_rt.s_rot.x = 0;
s_rt.s_rot.y = 0;
s_rt.s_rot.z = 0;
s_rt.mode = 0;
init_mlx(&s_rt);
load_scene(&s_rt, argv);
raytracing(&s_rt);
launch_mlx(&s_rt);
mlx_loop(s_rt.mlx_ptr);
}
else
ft_putstr("Usage : ./rtv1 misc/objects.rt misc/spots.rt\n", 2);
return (EXIT_SUCCESS);
}
int main(int argv, char ** argc) {
glutInit(&argv, argc);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA);
//glutInitContextVersion(3, 3);
//glutInitContextFlags(GLUT_COMPATIBILITY_PROFILE);
glutCreateWindow("OGL Test: Triangle");
glutDisplayFunc(disp_func);
glutReshapeFunc(reshape_func);
glutTimerFunc(500, show_fps, 1);
glutTimerFunc(10, pulse_func_10, 1);
glutIdleFunc(idle_func);
glutMouseFunc(mouse_func);
glutMotionFunc(mouse_motion_func);
glutKeyboardFunc(keyb_func);
glpp::context::create();
glpp::current_ctx().depth_test().enable();
GLuint err;
if ((err = glewInit()) != GLEW_OK) {
fprintf(stderr, "Cannot initialize GLEW. %s\n", glewGetErrorString(err));
return -1;
}
load_models();
load_shaders();
load_scene();
std::cout << "Total tex units " << glpp::current_ctx().capabilities().total_texture_units() << std::endl;
update_prespective ();
glEnable(GL_CULL_FACE);
glutMainLoop();
return 0;
}
int main(unsigned long long spe, unsigned long long argp,
unsigned long long envp)
{
spe_program_info_t info;
scene_t scene;
#if defined(_DEBUG)
printf("SPU params {%d, %d, %d}\n",
(unsigned int)spe, (unsigned int)argp,
(unsigned int)envp, sizeof(spe_program_info_t));
#if _DEBUG > 2
printf("SPU sizeof object3d_t: %d\n", sizeof(object3d_t));
printf("SPU sizeof material_t: %d\n", sizeof(material_t));
printf("SPU sizeof plane_t: %d\n", sizeof(plane_t));
printf("SPU sizeof polygon_t: %d\n", sizeof(polygon_t));
printf("SPU sizeof sphere_t: %d\n", sizeof(sphere_t));
printf("SPU sizeof unsigned int: %d\n", sizeof(unsigned int));
printf("SPU sizeof unsigned long long: %d\n", sizeof(unsigned long long));
printf("SPU sizeof point_t*: %d\n", sizeof(point_t *));
printf("SPU sizeof ray_t: %d\n", sizeof(ray_t));
#endif /* _DEBUG > 1 */
#endif /* _DEBUG */
load_program_info(argp, &info);
load_scene(info.scene_ea, &scene);
#if defined(_DEBUG) && _DEBUG > 1
preview_scene(&scene);
#endif
/* now start churnin rays */
spu_raytrace(&info, &scene);
return 0;
}
int main(){
BOOL done = FALSE;
MSG msg;
IDirect3DDevice9 *device = NULL;
IDirect3DSurface9 *main_rendertarget = NULL;
D3DFORMAT format;
float old_time = 0;
/* render-to-texture-stuff */
IDirect3DTexture9 *rtt_texture;
IDirect3DSurface9 *rtt_surface;
IDirect3DTexture9 *rtt_32_texture;
IDirect3DSurface9 *rtt_32_surface;
/* textures used from mainloop */
int white, black;
int odd_is_back_again[4];
int at_the_gathering_2003[4];
int o_d_d_in_your_face[4];
int world_domination[4];
int back_once_again[3];
int were_back;
int cred[4];
int mad_props[4];
int not_eph[4];
int piss_the_fuck_off[11];
int hardcore;
int refmap, refmap2;
int eatyrcode;
int code_0, code_1;
int overlaytest;
int circle_particle;
/* special-textures */
int rtt_texture_id;
int rtt_32_texture_id;
int video_texture_id;
int dilldall,dilldall2;
int metaball_text;
/* videos */
video *vid;
/* 3d-scenes */
scene *fysikkfjall;
scene *startblob;
scene *inni_abstrakt;
scene *korridor;
scene *skjerm_rom;
scene *bare_paa_lissom;
format = D3DFMT_X8R8G8B8;
device = d3dwin_open(TITLE, WIDTH, HEIGHT, format, FULLSCREEN);
if(!device){
format = D3DFMT_A8R8G8B8;
device = d3dwin_open(TITLE, WIDTH, HEIGHT, format, FULLSCREEN);
if(!device){
format = D3DFMT_X1R5G5B5;
device = d3dwin_open(TITLE, WIDTH, HEIGHT, format, FULLSCREEN);
if(!device){
format = D3DFMT_R5G6B5;
device = d3dwin_open(TITLE, WIDTH, HEIGHT, format, FULLSCREEN);
if(!device) error("failed to initialize Direct3D9");
}
}
}
#ifdef BIGSCREEN
set_gamma(device,1.05f);
#endif
if (!BASS_Init(1, 44100, BASS_DEVICE_LATENCY, win, NULL)) error("failed to initialize BASS");
fp = file_open("worlddomination.ogg");
if (!fp) error("music-file not found");
music_file = BASS_StreamCreateFile(1, fp->data, 0, fp->size, 0);
/*** music ***/
// if(!pest_open(win)) error("failed to initialize DirectSond");
// if(!pest_load("worlddomination.ogg",0)) error("failed to load music-file");
/*** subsystems ***/
init_tunnel();
video_init();
if(!init_particles(device)) error("failed to initialize");
if(!init_overlays(device)) error("f**k a duck");
if(!init_marching_cubes(device)) error("screw a kangaroo");
make_random_particles(particles, PARTICLES, vector_make(0,-180,0), 500);
make_random_particles(particles2, PARTICLES2, vector_make(0,-180,0), 500);
make_random_particles(particles3, PARTICLES3, vector_make(0,0,0), 800);
/*** rendertextures ***/
if (IDirect3DDevice9_CreateTexture(device, 512, 256, 0,D3DUSAGE_RENDERTARGET, D3DFMT_X8R8G8B8, D3DPOOL_DEFAULT, &rtt_texture, NULL)!=D3D_OK) error("failed to create rendertarget-texture");
if (IDirect3DTexture9_GetSurfaceLevel(rtt_texture,0,&rtt_surface)!=D3D_OK) error("could not get kvasi-backbuffer-surface");
if ((rtt_texture_id=texture_insert(device, "rendertexture.jpg", rtt_texture))==-1) error("fakk off!");
if(IDirect3DDevice9_CreateTexture(device,16,16,0,D3DUSAGE_RENDERTARGET|D3DUSAGE_AUTOGENMIPMAP,D3DFMT_X8R8G8B8,D3DPOOL_DEFAULT, &rtt_32_texture, NULL)!=D3D_OK) error("failed to create rendertarget-texture");
if(IDirect3DTexture9_GetSurfaceLevel(rtt_32_texture,0,&rtt_32_surface)!=D3D_OK) error("could not get kvasi-backbuffer-surface");
if((rtt_32_texture_id=texture_insert(device, "rendertexture2.jpg", rtt_32_texture))==-1) error("fakk off!");
/*** textures ***/
/* solid colors for fades etc */
if((white=texture_load(device,"white.png",FALSE))==-1) error("shjit!");
if((black=texture_load(device,"black.png",FALSE))==-1) error("shjit!");
/* textoverlays */
if((odd_is_back_again[0]=texture_load(device,"odd_is_back_again_0.png",FALSE))==-1) error("failed to load image");
if((odd_is_back_again[1]=texture_load(device,"odd_is_back_again_1.png",FALSE))==-1) error("failed to load image");
if((odd_is_back_again[2]=texture_load(device,"odd_is_back_again_2.png",FALSE))==-1) error("failed to load image");
if((odd_is_back_again[3]=texture_load(device,"odd_is_back_again_3.png",FALSE))==-1) error("failed to load image");
if((at_the_gathering_2003[0]=texture_load(device,"at_the_gathering_2003_0.png",FALSE))==-1) error("failed to load image");
if((at_the_gathering_2003[1]=texture_load(device,"at_the_gathering_2003_1.png",FALSE))==-1) error("failed to load image");
if((at_the_gathering_2003[2]=texture_load(device,"at_the_gathering_2003_2.png",FALSE))==-1) error("failed to load image");
if((at_the_gathering_2003[3]=texture_load(device,"at_the_gathering_2003_3.png",FALSE))==-1) error("failed to load image");
if((back_once_again[0]=texture_load(device,"back_once_again_0.png",TRUE))==-1) error("failed to load image");
if((back_once_again[1]=texture_load(device,"back_once_again_1.png",TRUE))==-1) error("failed to load image");
if((back_once_again[2]=texture_load(device,"back_once_again_2.png",TRUE))==-1) error("failed to load image");
if((o_d_d_in_your_face[0]=texture_load(device,"o_d_d_in_your_face_0.png",TRUE))==-1) error("failed to load image");
if((o_d_d_in_your_face[1]=texture_load(device,"o_d_d_in_your_face_1.png",TRUE))==-1) error("failed to load image");
if((o_d_d_in_your_face[2]=texture_load(device,"o_d_d_in_your_face_2.png",TRUE))==-1) error("failed to load image");
if((o_d_d_in_your_face[3]=texture_load(device,"o_d_d_in_your_face_3.png",TRUE))==-1) error("failed to load image");
if((world_domination[0]=texture_load(device,"world_domination_0.png",TRUE))==-1) error("failed to load image");
if((world_domination[1]=texture_load(device,"world_domination_1.png",TRUE))==-1) error("failed to load image");
if((world_domination[2]=texture_load(device,"world_domination_2.png",TRUE))==-1) error("failed to load image");
if((world_domination[3]=texture_load(device,"world_domination_3.png",TRUE))==-1) error("failed to load image");
if((were_back=texture_load(device,"were_back.png",TRUE))==-1) error("failed to load image");
if((cred[0]=texture_load(device,"cred_0.png",TRUE))==-1) error("failed to load image");
if((cred[1]=texture_load(device,"cred_1.png",TRUE))==-1) error("failed to load image");
if((cred[2]=texture_load(device,"cred_2.png",TRUE))==-1) error("failed to load image");
if((cred[3]=texture_load(device,"cred_3.png",TRUE))==-1) error("failed to load image");
if((mad_props[0]=texture_load(device,"mad_props_0.png",TRUE))==-1) error("failed to load image");
if((mad_props[1]=texture_load(device,"mad_props_1.png",TRUE))==-1) error("failed to load image");
if((mad_props[2]=texture_load(device,"mad_props_2.png",TRUE))==-1) error("failed to load image");
if((mad_props[3]=texture_load(device,"mad_props_3.png",TRUE))==-1) error("failed to load image");
if((not_eph[0]=texture_load(device,"not_eph_0.png",TRUE))==-1) error("failed to load image");
if((not_eph[1]=texture_load(device,"not_eph_1.png",TRUE))==-1) error("failed to load image");
if((not_eph[2]=texture_load(device,"not_eph_2.png",TRUE))==-1) error("failed to load image");
if((not_eph[3]=texture_load(device,"not_eph_3.png",TRUE))==-1) error("failed to load image");
if((piss_the_fuck_off[0]=texture_load(device,"piss_the_fuck_off_0.png",TRUE))==-1) error("failed to load image");
if((piss_the_fuck_off[1]=texture_load(device,"piss_the_fuck_off_1.png",TRUE))==-1) error("failed to load image");
if((piss_the_fuck_off[2]=texture_load(device,"piss_the_fuck_off_2.png",TRUE))==-1) error("failed to load image");
if((piss_the_fuck_off[3]=texture_load(device,"piss_the_fuck_off_3.png",TRUE))==-1) error("failed to load image");
if((piss_the_fuck_off[4]=texture_load(device,"piss_the_fuck_off_4.png",TRUE))==-1) error("failed to load image");
if((piss_the_fuck_off[5]=texture_load(device,"piss_the_fuck_off_5.png",TRUE))==-1) error("failed to load image");
if((piss_the_fuck_off[6]=texture_load(device,"piss_the_fuck_off_6.png",TRUE))==-1) error("failed to load image");
if((piss_the_fuck_off[7]=texture_load(device,"piss_the_fuck_off_7.png",TRUE))==-1) error("failed to load image");
if((piss_the_fuck_off[8]=texture_load(device,"piss_the_fuck_off_8.png",TRUE))==-1) error("failed to load image");
if((piss_the_fuck_off[9]=texture_load(device,"piss_the_fuck_off_9.png",TRUE))==-1) error("failed to load image");
if((piss_the_fuck_off[10]=texture_load(device,"piss_the_fuck_off_10.png",TRUE))==-1) error("failed to load image");
if((hardcore=texture_load(device,"hardcore.png",TRUE))==-1) error("failed to load image");
/* other textures */
if((circle_particle=texture_load(device,"circle_particle.jpg",FALSE))==-1) error("shjit!");
if((refmap=texture_load(device,"fysikkfjall/refmap.jpg",FALSE))==-1) error("shjit!");
if((refmap2=texture_load(device,"refmap2.jpg",FALSE))==-1) error("shjit!");
if((eatyrcode=texture_load(device,"eatyrcode.jpg",FULLSCREEN_HACK))==-1) error("shjit!");
if((code_0=texture_load(device,"code-0.jpg",FALSE))==-1) error("shjit!");
if((code_1=texture_load(device,"code-1.jpg",FALSE))==-1) error("shjit!");
if((overlaytest=texture_load(device,"overlaytest.jpg",FALSE))==-1) error("shjit!");
if((dilldall=texture_load(device,"dilldall.png",FALSE))==-1) error("shjit!");
if((dilldall2=texture_load(device,"dilldall2.png",FALSE))==-1) error("shjit!");
if((metaball_text=texture_load(device,"metaballs.png",TRUE))==-1) error("shjit!");
/*** video ***/
if(!(vid=video_load(device,"test.kpg"))) error("fæck!");
video_texture_id = texture_insert(device, "skjerm_rom/skjerm_tom.tga", vid->texture);
/*** misc stuff ***/
/* main rendertarget */
IDirect3DDevice9_GetRenderTarget(device,0,&main_rendertarget);
/* default state */
IDirect3DDevice9_CreateStateBlock(device, D3DSBT_ALL, &default_state);
init_defaultstate(device);
IDirect3DStateBlock9_Capture(default_state);
/*** 3d scenes ***/
if(!(fysikkfjall=load_scene(device,"fysikkfjall/fysikkfjall.krs"))) error("failed to load 3d scene");
if(!(startblob=load_scene(device,"startblob/startblob.krs"))) error("failed to load 3d scene");
if(!(inni_abstrakt=load_scene(device,"inni_abstrakt/inni_abstrakt.krs"))) error("failed to load 3d scene");
if(!(korridor=load_scene(device,"korridor/korridor.krs"))) error("failed to load 3d scene");
if(!(skjerm_rom=load_scene(device,"skjerm_rom/skjerm_rom.krs"))) error("failed to load 3d scene");
if(!(bare_paa_lissom=load_scene(device,"bare_paa_lissom/bare_paa_lissom.krs"))) error("failed to load 3d scene");
// pest_play();
BASS_Start();
BASS_StreamPlay(music_file, 1, 0);
do{
grid g;
int i;
matrix m, temp, temp_matrix;
matrix marching_cubes_matrix;
long long bytes_played = BASS_ChannelGetPosition(music_file);
float time = bytes_played * (1.0 / (44100 * 2 * 2));
// float time = pest_get_pos()+0.05f;
float delta_time = time-old_time;
int beat = (int)(time*((float)BPM/60.f));
if(time_index<(sizeof(timetable)/4)){
while(timetable[time_index]<time) time_index++;
}
#ifdef _DEBUG
printf("time: %2.2f, delta_time: %2.2f, time_index: %i, beat: %i \r",time,delta_time,time_index,beat);
#endif
IDirect3DDevice9_SetRenderTarget(device,0,main_rendertarget);
IDirect3DStateBlock9_Apply(default_state);
IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER|D3DCLEAR_STENCIL, 0, 1.0f, 0);
// IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_ZBUFFER, 0, 1.0f, 0);
IDirect3DDevice9_BeginScene(device);
#if 1
if(time_index<40){
if(time_index>0&&time_index<5){
draw_overlay(device,odd_is_back_again[time_index-1],0,0,1,FALSE);
}else if(time_index>4&&time_index<19){
float itime = time*10;
grid_flat(g,0,0);
for(i=0;i<7;i++){
int scale = (time_index&1);
grid_wave(g,(float)sin(itime-i+sin(i-itime))*0.3f*scale,(float)cos(itime*0.69f+i*0.733f)*0.3f*scale,7,(float)sin(itime+i*0.1f)*0.5f*scale);
}
draw_grid(device, g, odd_is_back_again[3], FALSE);
}else if(time_index>=19){
float itime = (time-timetable[18])*0.5f;
grid_flat(g,0,0);
for(i=0;i<7;i++){
grid_wave(g,(float)sin(time-i+sin(i-time))*0.3f,(float)cos(time*0.69f+i*0.733f)*0.3f,7, itime*itime);
}
draw_grid(device, g, odd_is_back_again[3], FALSE);
}
if(time_index>20&&time_index<25){
draw_overlay(device,at_the_gathering_2003[(time_index-21)%4],0,0,1,TRUE);
}else if(time_index>=25&&time_index<38){
float itime = time*10;
grid_flat(g,0,0);
for(i=0;i<10;i++){
int scale = (time_index&1);
grid_wave(g,(float)sin(itime-i+sin(i-itime))*0.3f*scale,(float)cos(itime*0.69f+i*0.733f)*0.3f*scale,7,(float)sin(itime+i*0.1f)*0.5f*scale);
}
draw_grid(device,g,at_the_gathering_2003[3],TRUE);
}else if(time_index>=38){
float itime = (time-timetable[37])*0.5f;
grid_flat(g,0,0);
for(i=0;i<10;i++){
grid_wave(g,(float)sin(time-i+sin(i-time))*0.3f,(float)cos(time*0.69f+i*0.733f)*0.3f,7, itime*itime);
}
draw_grid(device,g,at_the_gathering_2003[3],TRUE);
}
}else if(time_index<52){
animate_scene(inni_abstrakt,(time-timetable[39]));
draw_scene(device,inni_abstrakt,0,TRUE);
flash(device,white,time,timetable[39],1);
if(time_index<43){
draw_overlay(device, back_once_again[(time_index-40)%3],0,0,1,FALSE);
}else if(time_index<47){
draw_overlay(device, o_d_d_in_your_face[(time_index-43)%4],0,0,1,FALSE);
}else if(time_index<51){
draw_overlay(device, world_domination[(time_index-47)%4],0,0,1,FALSE);
}else{
draw_overlay(device, were_back,0,0,(time-timetable[51]),FALSE);
}
draw_overlay(device,dilldall,sin(sin(time)*0.07f+(((beat+1)/2)*0.8f)),sin(time*0.03337f+(((beat+1)/2)*0.14f)),0.5f,TRUE);
draw_overlay(device,dilldall2,sin(sin(time*0.1f)*0.07f+time*0.1f+(((beat+1)/2)*0.8f)),sin(time*0.01337f+(((beat+1)/2)*0.14f)),0.5f,TRUE);
}else if(time_index<69){
animate_scene(startblob,(time-timetable[39]-0.27f+((beat+1)&2))*0.74948f);
startblob->cameras[0].fog = TRUE;
startblob->cameras[0].fog_start = 100.f;
startblob->cameras[0].fog_end = 700.f;
if(time_index>=53 && time_index<66 && time_index&1 ){
float f = fade(timetable[time_index-1],1.7f,time,0.5f,0);
f *= f;
f *= 2;
if(f>0.f)
IDirect3DDevice9_SetRenderTarget(device,0,rtt_surface);
draw_scene(device,startblob,0,TRUE);
draw_particles(device, particles3, PARTICLES3, code_0);
if(f>0.f){
IDirect3DDevice9_SetRenderTarget(device,0,main_rendertarget);
draw_radialblur(device,0,0,f,0,rtt_texture_id, FALSE);
}
if(time_index<61) draw_overlay(device,cred[((time_index/2)-2)%4],0,0,f*3,FALSE);
}else{
draw_scene(device,startblob,0,TRUE);
draw_particles(device, particles3, PARTICLES3, circle_particle);
}
if(time_index>=54&& !(time_index&1)){
float f = fade(timetable[time_index-1],1.8f,time,1.f,0)*0.8f;
IDirect3DDevice9_SetRenderTarget(device,0,rtt_32_surface);
draw_scene(device,startblob,0,TRUE);
draw_particles(device, particles3, PARTICLES3, code_0);
IDirect3DDevice9_SetRenderTarget(device,0,main_rendertarget);
IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAGFILTER, D3DTEXF_POINT);
draw_overlay(device,rtt_32_texture_id,0,0,f,TRUE);
draw_overlay(device,rtt_32_texture_id,0,0,f,TRUE);
IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
}
flash(device,were_back,time,timetable[51],2);
flash(device,white,time,timetable[51],1);
}else if(time_index<79){
for(i=0;i<BALLS;i++){
balls[i].pos.x = (float)sin(time+i-sin((float)i*0.1212111f))*0.35f;
balls[i].pos.y = (float)cos(time-(float)i*0.29342111f)*0.35f;
balls[i].pos.z = (float)sin(time*0.31121f+sin(i-time))*0.35f;
balls[i].r = 0.15f + (float)sin(time+i)*0.01f;
balls[i].pos = vector_normalize(balls[i].pos);
balls[i].pos = vector_scale(balls[i].pos, (float)(cos(i*0.11131f-time*0.55311f)+sin(time+(float)sin(time-i+time*0.3f)))*0.2f );
}
animate_scene(korridor,(time-timetable[68])*0.65f );
draw_scene(device,korridor,(beat/4)&1,TRUE);
memcpy(temp,korridor->objects[korridor->object_count-1]->mat,sizeof(matrix));
matrix_scale(marching_cubes_matrix,vector_make(120,120,120));
matrix_multiply(marching_cubes_matrix,temp,marching_cubes_matrix);
matrix_rotate(temp,vector_make(time,-time,time*0.5f+sin(time)));
matrix_multiply(marching_cubes_matrix,marching_cubes_matrix,temp);
IDirect3DDevice9_SetTransform( device, D3DTS_WORLD, (D3DMATRIX*)&marching_cubes_matrix );
fill_metafield_blur(balls, BALLS,0.98f);
march_my_cubes_opt(balls, BALLS, 0.9f);
IDirect3DDevice9_SetRenderState(device, D3DRS_CULLMODE, D3DCULL_NONE);
set_texture(device,0,refmap2);
IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXCOORDINDEX, D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR );
IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_ADD);
IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG2, D3DTA_CURRENT);
draw_marched_cubes(device);
flash(device,white,time,timetable[68],1);
if(time_index>69&&time_index<74){
draw_overlay(device,mad_props[(time_index+2)%4],0,0,1,FALSE);
}else if(time_index>73&&time_index<77){
draw_overlay(device,not_eph[(time_index+2)%4],0,0,1,FALSE);
}else if(time_index==77){
float f = fade(timetable[76],2.5f,time,1,0);
draw_overlay(device,not_eph[3],0,0,f,FALSE);
}
}
if(time_index>77&&time_index<92){
float f = fade(timetable[77],timetable[78]-timetable[77],time,0,1);
draw_overlay(device,eatyrcode,0,0,f,FALSE);
if(time>109.5f){
IDirect3DStateBlock9_Apply(default_state);
animate_particles(particles, PARTICLES, delta_time*30);
animate_particles(particles2, PARTICLES2, delta_time*28);
draw_particles(device, particles, PARTICLES, code_0);
draw_particles(device, particles2, PARTICLES2, code_1);
}
if(time_index>79&&time_index<90){
draw_overlay(device,piss_the_fuck_off[(time_index-80)%11],0,0,1,FALSE);
}else if(time_index==90){
float f = fade(timetable[89],2,time,1,0);
draw_overlay(device,piss_the_fuck_off[10],0,0,f,FALSE);
}
if(time_index==91){
float f = fade(timetable[90],2,time,1,0);
draw_overlay(device,hardcore,0,0,f,FALSE);
}
}else if(time_index>91 && time_index<97){
animate_scene(skjerm_rom,time);
video_update(vid, time);
draw_scene(device,skjerm_rom,((beat/4)&1),TRUE);
draw_overlay(device,dilldall,sin(sin(time)*0.07f+(((beat+1)/2)*0.8f)),sin(time*0.03337f+(((beat+1)/2)*0.14f)),0.5f,TRUE);
draw_overlay(device,dilldall2,sin(sin(time*0.1f)*0.07f+time*0.1f+(((beat+1)/2)*0.8f)),sin(time*0.01337f+(((beat+1)/2)*0.14f)),0.5f,TRUE);
if(time_index>92)
draw_overlay(device, world_domination[(time_index-93)%4],0,0,1,FALSE);
}else if(time_index>96&&time_index<104){
grid_zero(g);
matrix_translate(m, vector_make(cos(time)*1.5f, sin(time)*1.5f,time*10));
matrix_rotate(temp_matrix, vector_make(sin(time*0.8111f)*0.2f,sin(time*1.2f)*0.2f,time));
matrix_multiply(m,m,temp_matrix);
render_tunnel(g,m);
matrix_rotate(temp_matrix, vector_make(0,M_PI,0));
matrix_multiply(m,m,temp_matrix);
render_tunnel(g,m);
matrix_rotate(temp_matrix, vector_make(M_PI,0,0));
matrix_multiply(m,m,temp_matrix);
render_tunnel(g,m);
grid_add_noice(g,sin(time)*0.1f);
draw_grid(device, g, circle_particle, FALSE);
if(time_index>97&&time_index<102){
float f = 1;
if(time_index==101) f = fade(timetable[100],3,time,1,0);
draw_overlay(device, o_d_d_in_your_face[(time_index-42)%4],0,0,f,FALSE);
}
}
if(time_index>101 && time_index<104){
float f = fade(timetable[101],8,time,0,1);
float f2 = fade(timetable[101],4,time,0,1);
draw_overlay(device,black,0,0,f2,FALSE);
IDirect3DDevice9_SetRenderTarget(device,0,rtt_surface);
IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER, 0, 1.0f, 0);
IDirect3DStateBlock9_Apply(default_state);
animate_scene(bare_paa_lissom,time-timetable[101]);
draw_scene(device,bare_paa_lissom,0,TRUE);
time *=0.5f;
for(i=0;i<BALLS2;i++){
balls2[i].pos.x = (float)sin(time+i-sin((float)i*0.1212111f))*0.35f;
balls2[i].pos.y = (float)cos(time-(float)i*0.29342111f)*0.35f;
balls2[i].pos.z = (float)sin(time*0.31121f+sin(i-time))*0.35f;
balls2[i].r = 0.15f + (float)sin(time+i)*0.01f;
balls2[i].pos = vector_normalize(balls2[i].pos);
balls2[i].pos = vector_scale(balls2[i].pos, (float)(cos(i*0.11131f-time*0.55311f)+sin(time+(float)sin(time-i+time*0.3f)))*0.2f );
}
memcpy(temp,bare_paa_lissom->objects[bare_paa_lissom->object_count-1]->mat,sizeof(matrix));
matrix_scale(marching_cubes_matrix,vector_make(120,120,120));
matrix_multiply(marching_cubes_matrix,temp,marching_cubes_matrix);
IDirect3DDevice9_SetTransform( device, D3DTS_WORLD, (D3DMATRIX*)&marching_cubes_matrix );
fill_metafield(balls2, BALLS2);
march_my_cubes_opt(balls2, BALLS2, 0.9f);
IDirect3DDevice9_SetRenderState(device, D3DRS_CULLMODE, D3DCULL_NONE);
set_texture(device,0,refmap);
IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXCOORDINDEX, D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR );
IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_ADD);
IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG2, D3DTA_CURRENT);
draw_marched_cubes(device);
IDirect3DDevice9_SetRenderTarget(device,0,main_rendertarget);
draw_overlay(device,rtt_texture_id,0,0,f,TRUE);
if(time_index==103){
float f;
time *= 2;
f = fade(timetable[time_index-1],3,time,1,0);
draw_overlay(device,metaball_text,0,0,f,FALSE);
flash(device,white,time,timetable[time_index-1],1);
}
}
if(time_index==104){
float f = fade(timetable[103],timetable[104]-timetable[103],time,0,1);
animate_scene(korridor,180-(time-timetable[time_index-1])*0.8f );
draw_scene(device,korridor,(beat/4)&1,TRUE);
draw_overlay(device,black,0,0,f,FALSE);
}
if(time_index==105){
float f = fade(timetable[104],timetable[105]-timetable[104],time,0,1);
float t = (time-timetable[time_index-1])*0.6f+2.2f;
animate_scene(fysikkfjall,t);
draw_scene(device,fysikkfjall,0,TRUE);
draw_overlay(device,black,0,0,f,FALSE);
}
#endif
/*
*/
/*
draw_overlay(device, were_back, (1+sin(time))*0.5f, TRUE);
*/
// animate_scene(risterom,time);
// draw_scene(device,risterom,0,TRUE);
#if 0 //helvete_har_frosset
draw_overlay(device, eatyrcode, 1,FALSE);
IDirect3DStateBlock9_Apply(default_state);
animate_particles(particles, PARTICLES, delta_time*30);
animate_particles(particles2, PARTICLES2, delta_time*28);
draw_particles(device, particles, PARTICLES, code_0);
draw_particles(device, particles2, PARTICLES2, code_1);
#endif
#ifdef pikk
// IDirect3DDevice9_SetRenderTarget(device,0,rtt_surface);
IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER, 0, 1.0f, 0);
draw_overlay(device, eatyrcode, TRUE);
animate_scene(startblob,(time-timetable[39]-0.27f)*0.7453f);
draw_scene(device,startblob,0,FALSE);
draw_particles(device, particles, PARTICLES, code_0);
draw_particles(device, particles2, PARTICLES2, code_1);
// IDirect3DDevice9_SetRenderTarget(device,0,main_rendertarget);
/*
draw_radialblur(device,
(float)sin(time)*0.2f,
(float)sin(-time*0.331f)*0.13f,
(float)(2+(float)sin(time*0.5f))*0.2f,
0,//sin(time)*0.25f,
rtt_texture_id, TRUE);
animate_scene(fysikkfjall,time);
draw_scene(device,fysikkfjall,0,FALSE);
*/
// draw_overlay(device, rtt_texture_id, TRUE);
#endif
// draw_overlay(device, eatyrcode, FALSE);
// video_update(vid, time);
#if 0
// IDirect3DDevice9_SetRenderTarget(device,0,rtt_surface);
animate_scene(testscene,time);
// morph_object(testscene->objects[0], time );
draw_scene(device,testscene,0,TRUE);
// draw_particles(device, particles, PARTICLES, particle);
// IDirect3DDevice9_SetRenderTarget(device,0,main_rendertarget);
#endif
#if 0
time *=0.5f;
for(i=0;i<BALLS2;i++){
balls2[i].pos.x = (float)sin(time+i-sin((float)i*0.1212111f))*0.35f;
balls2[i].pos.y = (float)cos(time-(float)i*0.29342111f)*0.35f;
balls2[i].pos.z = (float)sin(time*0.31121f+sin(i-time))*0.35f;
balls2[i].r = 0.15f + (float)sin(time+i)*0.01f;
balls2[i].pos = vector_normalize(balls2[i].pos);
balls2[i].pos = vector_scale(balls2[i].pos, (float)(cos(i*0.11131f-time*0.55311f)+sin(time+(float)sin(time-i+time*0.3f)))*0.2f );
// balls2[i].pos.x *= 2.8f;
}
matrix_translate(temp,vector_make(0,0,87));
matrix_scale(marching_cubes_matrix,vector_make(50,50,50));
matrix_multiply(marching_cubes_matrix,temp,marching_cubes_matrix);
IDirect3DDevice9_SetTransform( device, D3DTS_WORLD, (D3DMATRIX*)&marching_cubes_matrix );
fill_metafield(balls2, BALLS2);
// fill_metafield_blur(balls, BALLS,0.98f);
march_my_cubes_opt(balls2, BALLS2, 0.9f);
// march_my_cubes(0.9f);
IDirect3DDevice9_SetRenderState(device, D3DRS_CULLMODE, D3DCULL_CW);
set_texture(device,0,refmap);
IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXCOORDINDEX, D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR );
IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_ADD);
IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG2, D3DTA_CURRENT);
draw_marched_cubes(device);
#endif
#if 0
// time *= 0.5f;
grid_zero(g);
// for(i=0;i<10;i++)
// grid_wave(g,sin(time-i+sin(i-time))*0.3f,cos(time*0.69f+i*0.733f)*0.3f,7,sin(time+i*0.1f)*0.5f);
matrix_translate(m, vector_make(cos(time)*1.5f, sin(time)*1.5f,time*10));
matrix_rotate(temp_matrix, vector_make(sin(time*0.8111f)*0.2f,sin(time*1.2f)*0.2f,time));
matrix_multiply(m,m,temp_matrix);
// empty_grid( grid );
render_tunnel(g,m);
matrix_rotate(temp_matrix, vector_make(0,M_PI,0));
matrix_multiply(m,m,temp_matrix);
render_tunnel(g,m);
matrix_rotate(temp_matrix, vector_make(M_PI,0,0));
matrix_multiply(m,m,temp_matrix);
render_tunnel(g,m);
// tyfuus_expand_grid( screen, grid, texture );
grid_add_noice(g,sin(time)*0.1f);
draw_grid(device, g, circle_particle, FALSE);
#endif
// IDirect3DDevice9_SetRenderTarget(device,0,main_rendertarget);
// video_update(vid,time);
/*
draw_radialblur(device,
(float)sin(time)*0.2f,
(float)sin(-time*0.331f)*0.13f,
(float)(1+(float)sin(time*0.5f))*0.2f,
0,//sin(time)*0.25f,
rtt_texture_id, FALSE);
*/
// IDirect3DStateBlock9_Apply(default_state);
// draw_overlay(device,rtt_texture_id,FALSE);
// draw_overlay(device,fullscreen,FALSE);
// draw_radialblur(device,0,sin(time*0.2f)*2.f, rtt_texture_id);
// IDirect3DDevice9_StretchRect(device,main_rendertarget,NULL,rtt_surface,NULL,D3DTEXF_NONE);
// IDirect3DBaseTexture9_GenerateMipSubLevels(rtt_texture);
IDirect3DDevice9_EndScene(device);
if(IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL)==D3DERR_DEVICELOST)
error("fakkin lost device. keep your hands off alt-tab, looser.");
old_time = time;
while (PeekMessage(&msg,NULL,0,0,PM_REMOVE)){
TranslateMessage(&msg);
DispatchMessage(&msg);
if (msg.message == WM_QUIT ||
msg.message == WM_KEYDOWN && LOWORD(msg.wParam) == VK_ESCAPE)
done = TRUE;
}
}while(!done);
deinit_marching_cubes();
deinit_overlays();
deinit_particles();
free_scene(fysikkfjall);
free_scene(startblob);
free_scene(inni_abstrakt);
free_scene(korridor);
free_scene(skjerm_rom);
free_scene(bare_paa_lissom);
free_materials();
free_textures();
free_video(vid);
rtt_surface->lpVtbl->Release(rtt_surface);
rtt_32_surface->lpVtbl->Release(rtt_32_surface);
main_rendertarget->lpVtbl->Release(main_rendertarget);
IDirect3DStateBlock9_Release(default_state);
d3dwin_close();
if (music_file) BASS_StreamFree( music_file );
if (fp) file_close( fp );
BASS_Free();
// pest_close();
return 0;
}
int main(int argc, char** argv) {
try {
constexpr auto surface =
wayverb::core::surface<wayverb::core::simulation_bands>{
{{0.07, 0.09, 0.11, 0.12, 0.13, 0.14, 0.16, 0.17}},
{{0.07, 0.09, 0.11, 0.12, 0.13, 0.14, 0.16, 0.17}}};
if (argc != 2) {
throw std::runtime_error{"Expected a scene file."};
}
auto scene_data = load_scene(argv[1]);
scene_data.set_surfaces(surface);
// const auto box = wayverb::core::geo::box{glm::vec3{0},
// glm::vec3{5.56, 3.97, 2.81}};
// const auto scene_data =
// wayverb::core::geo::get_scene_data(box, surface);
const auto aabb_centre = centre(
wayverb::core::geo::compute_aabb(scene_data.get_vertices()));
const auto source = aabb_centre + glm::vec3{0, 0, 0.2};
const auto receiver = aabb_centre + glm::vec3{0, 0, -0.2};
const auto rays = 1 << 16;
const auto img_src_order = 4;
const auto cutoff = 1000;
const auto usable_portion = 0.6;
const auto output_sample_rate = 44100.0;
const auto params = wayverb::waveguide::single_band_parameters{cutoff, usable_portion};
// Set up simulation.
wayverb::combined::engine engine{
wayverb::core::compute_context{},
scene_data,
source,
receiver,
wayverb::core::environment{},
wayverb::raytracer::simulation_parameters{rays, img_src_order},
wayverb::combined::make_waveguide_ptr(params)};
// When the engine changes, print a nice progress bar.
util::progress_bar pb{std::cout};
engine.connect_engine_state_changed([&](auto state, auto progress) {
set_progress(pb, progress);
});
// Run simulation.
const auto intermediate = engine.run(true);
// Do directional postprocessing.
const wayverb::core::orientation receiver_orientation{};
std::vector<util::named_value<
std::unique_ptr<wayverb::combined::capsule_base>>>
capsules;
capsules.emplace_back(
"microphone",
wayverb::combined::make_capsule_ptr(
wayverb::core::attenuator::microphone{
wayverb::core::orientation{}, 0.5},
receiver_orientation));
capsules.emplace_back(
"hrtf",
wayverb::combined::make_capsule_ptr(
wayverb::core::attenuator::hrtf{
wayverb::core::orientation{},
wayverb::core::attenuator::hrtf::channel::left},
receiver_orientation));
auto output_channels = util::map_to_vector(
begin(capsules), end(capsules), [&](const auto& i) {
return map(
[&](const auto& i) {
return i->postprocess(*intermediate,
output_sample_rate);
},
i);
});
// Reduce volume to reasonable level.
constexpr auto volume_factor = 0.05;
for (auto& i : output_channels) {
wayverb::core::mul(i.value, volume_factor);
}
// Write out.
for (const auto& i : output_channels) {
write(util::build_string(i.name, ".wav").c_str(),
i.value,
output_sample_rate,
audio_file::format::wav,
audio_file::bit_depth::pcm16);
}
} catch (const std::exception& e) {
std::cerr << e.what() << '\n';
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
Project(Display *display)
: Screen(display)
, scene_root(nullptr, "root")
{
load_scene();
}
//box[], particles[], shapes[]
static int luaScene_load(lua_State* L){
SimConfig config;
for(lua_pushnil(L); lua_next(L, 1); lua_pop(L, 1)){
long long int i = lua_tointeger(L, -2) - 1;
if(i < 0 || i >= 9){
fprintf(stderr, "Invalid index for box table encountered while loading scene.\n");
return 0;
}
config.box[i % 3][i / 3] = lua_tonumber(L, -1);
}
config.n_particles = lua_rawlen(L, 2);
config.particles = new Particle[config.n_particles];
size_t pid = 0;
for(lua_pushnil(L); lua_next(L, 2);){
config.particles[pid++] = maan::get_LuaValue<Particle>(L);
}
config.n_shapes = lua_rawlen(L, 3);
config.shapes = new Shape[config.n_shapes];
//TODO: Add a is_class(lua_State* L, int idx) function to maan.
size_t sid = 0;
for(lua_pushnil(L); lua_next(L, 3);){
if(!lua_isuserdata(L, -1)){
fprintf(stderr, "Unknown item type encountered in shapes table while loading scene. 'Shape' expected, got '%s'.\n", luaL_typename(L, -1));
delete[] config.particles;
delete[] config.shapes;
return 0;
}
lua_getmetatable(L, -1);
lua_pushstring(L, "__class_id");
lua_rawget(L, -2);
if(lua_isnil(L, -1)){
fprintf(stderr, "Unknown userdata type encountered in shapes table while loading scene.\n");
delete[] config.particles;
delete[] config.shapes;
return 0;
}
void* class_id = lua_touserdata(L, -1);
lua_pop(L, 2);
auto shape = Shape();
if(maan::detail::ClassInfo<Sphere>::get_metatable_key() == class_id){
shape.type = Shape::SPHERE;
lua_pop(L, 1);
}
else if(maan::detail::ClassInfo<Mesh>::get_metatable_key() == class_id){
shape.type = Shape::MESH;
auto mesh = maan::get_LuaValue<Mesh>(L);
shape.mesh.n_vertices = mesh.vertices_.size();
shape.mesh.vertices = new Vertex[shape.mesh.n_vertices];
int i = 0;
for(auto vertex: mesh.vertices_){
shape.mesh.vertices[i++] = vertex;
}
}
else{
lua_getmetatable(L, -1);
lua_pushstring(L, "__name");
lua_rawget(L, -2);
fprintf(stderr, "Unknown class type encountered in shapes table while loading scene. 'Shape' expected, got '%s'.\n", lua_tostring(L, -1));
lua_pop(L, 2);
delete[] config.particles;
delete[] config.shapes;
return 0;
}
config.shapes[sid++] = shape;
}
auto scene = reinterpret_cast<Scene*>(lua_touserdata(L, lua_upvalueindex(1)));
scene->load_scene(config);
delete[] config.particles;
delete[] config.shapes;
return 0;
}
/****** Change scene if in specified range ******/
void Scene::check_scene_ranges()
{
for(int x = -1; ++x < scene_range_list.size();)
{
std::string tgt = scene_range_list[x].target;
std::string s_file = scene_range_list[x].next_scene_file;
/* Check bounding box */
if((sprite_list[tgt].orig_x <= scene_range_list[x].max_x) && (sprite_list[tgt].orig_x >= scene_range_list[x].min_x) &&
(sprite_list[tgt].orig_y <= scene_range_list[x].max_y) && (sprite_list[tgt].orig_y >= scene_range_list[x].min_y)) { load_scene(s_file); }
}
for(int x = -1; ++x < scene_button_range_list.size();)
{
std::string tgt = scene_button_range_list[x].target;
bool collide = true;
if(sprite_list[tgt].left_bound() > scene_button_range_list[x].max_x) { collide = false; }
if(sprite_list[tgt].right_bound() < scene_button_range_list[x].min_x) { collide = false; }
if(sprite_list[tgt].top_bound() > scene_button_range_list[x].max_y) { collide = false; }
if(sprite_list[tgt].bottom_bound() < scene_button_range_list[x].min_y) { collide = false; }
scene_button_range_list[x].in_range = collide;
}
}
// Required entry point
//------------------------------------------------------------------------------
int sample_main( int argc, const char** argv )
{
// show console and redirect printing
NVPWindow::sysVisibleConsole();
const Config config( argc, argv );
Timer timer;
//
// Load scene
//
std::cerr << "Load scene ... "; std::cerr.flush();
timer.start();
bake::Scene scene;
SceneMemory* scene_memory;
float scene_bbox_min[] = {FLT_MAX, FLT_MAX, FLT_MAX};
float scene_bbox_max[] = {-FLT_MAX, -FLT_MAX, -FLT_MAX};
if (!load_scene( config.scene_filename.c_str(), scene, scene_bbox_min, scene_bbox_max, scene_memory, config.num_instances_per_mesh )) {
std::cerr << "Failed to load scene, exiting" << std::endl;
exit(-1);
}
printTimeElapsed( timer );
// Print scene stats
{
std::cerr << "Loaded scene: " << config.scene_filename << std::endl;
std::cerr << "\t" << scene.num_meshes << " meshes, " << scene.num_instances << " instances" << std::endl;
size_t num_vertices = 0;
size_t num_triangles = 0;
for (size_t i = 0; i < scene.num_meshes; ++i) {
num_vertices += scene.meshes[i].num_vertices;
num_triangles += scene.meshes[i].num_triangles;
}
std::cerr << "\tuninstanced vertices: " << num_vertices << std::endl;
std::cerr << "\tuninstanced triangles: " << num_triangles << std::endl;
}
// OptiX Prime requires all instances to have the same vertex stride
for (size_t i = 1; i < scene.num_meshes; ++i) {
if (scene.meshes[i].vertex_stride_bytes != scene.meshes[0].vertex_stride_bytes) {
std::cerr << "Error: all meshes must have the same vertex stride. Bailing.\n";
exit(-1);
}
}
//
// Generate AO samples
//
std::cerr << "Minimum samples per face: " << config.min_samples_per_face << std::endl;
std::cerr << "Generate sample points ... \n"; std::cerr.flush();
timer.reset();
timer.start();
std::vector<size_t> num_samples_per_instance(scene.num_instances);
const size_t total_samples = bake::distributeSamples( scene, config.min_samples_per_face, config.num_samples, &num_samples_per_instance[0] );
bake::AOSamples ao_samples;
allocate_ao_samples( ao_samples, total_samples );
bake::sampleInstances( scene, &num_samples_per_instance[0], config.min_samples_per_face, ao_samples );
printTimeElapsed( timer );
std::cerr << "Total samples: " << total_samples << std::endl;
{
const int sqrt_num_rays = static_cast<int>( sqrtf( static_cast<float>( config.num_rays ) ) + .5f );
std::cerr << "Rays per sample: " << sqrt_num_rays * sqrt_num_rays << std::endl;
std::cerr << "Total rays: " << total_samples * sqrt_num_rays * sqrt_num_rays << std::endl;
}
//
// Evaluate AO samples
//
std::cerr << "Compute AO ... "; std::cerr.flush();
timer.reset();
timer.start();
std::vector<float> ao_values( total_samples );
std::fill(ao_values.begin(), ao_values.end(), 0.0f);
float scene_maxdistance;
float scene_offset;
{
const float scene_scale = std::max(std::max(scene_bbox_max[0] - scene_bbox_min[0],
scene_bbox_max[1] - scene_bbox_min[1]),
scene_bbox_max[2] - scene_bbox_min[2]);
scene_maxdistance = scene_scale * config.scene_maxdistance_scale;
scene_offset = scene_scale * config.scene_offset_scale;
if (config.scene_offset){
scene_offset = config.scene_offset;
}
if (config.scene_maxdistance){
scene_maxdistance = config.scene_maxdistance;
}
}
if (config.use_ground_plane_blocker) {
// Add blocker for ground plane (no surface samples)
std::vector<bake::Mesh> blocker_meshes;
std::vector<bake::Instance> blocker_instances;
std::vector<float> plane_vertices;
std::vector<unsigned int> plane_indices;
make_ground_plane(scene_bbox_min, scene_bbox_max, config.ground_upaxis, config.ground_scale_factor, config.ground_offset_factor,
scene.meshes[0].vertex_stride_bytes,
plane_vertices, plane_indices, blocker_meshes, blocker_instances);
bake::Scene blockers = { &blocker_meshes[0], blocker_meshes.size(), &blocker_instances[0], blocker_instances.size() };
bake::computeAOWithBlockers(scene, blockers,
ao_samples, config.num_rays, scene_offset, scene_maxdistance, config.use_cpu, config.conserve_memory, &ao_values[0]);
} else {
bake::computeAO(scene, ao_samples, config.num_rays, scene_offset, scene_maxdistance, config.use_cpu, config.conserve_memory, &ao_values[0]);
}
printTimeElapsed( timer );
std::cerr << "Map AO to vertices ... "; std::cerr.flush();
timer.reset();
timer.start();
float** vertex_ao = new float*[ scene.num_instances ];
for (size_t i = 0; i < scene.num_instances; ++i ) {
vertex_ao[i] = new float[ scene.meshes[scene.instances[i].mesh_index].num_vertices ];
}
bake::mapAOToVertices( scene, &num_samples_per_instance[0], ao_samples, &ao_values[0], config.filter_mode, config.regularization_weight, vertex_ao );
printTimeElapsed( timer );
if (!config.output_filename.empty())
{
std::cerr << "Save vertex ao ... "; std::cerr.flush();
timer.reset();
timer.start();
bool saved = save_results(config.output_filename.c_str(), scene, vertex_ao);
printTimeElapsed(timer);
if (saved){
std::cerr << "Saved vertex ao to: " << config.output_filename << std::endl;
}
else{
std::cerr << "Failed to save vertex ao to: " << config.output_filename << std::endl;
}
}
if (config.use_viewer){
//
// Visualize results
//
std::cerr << "Launch viewer ... \n" << std::endl;
bake::view(scene.meshes, scene.num_meshes, scene.instances, scene.num_instances, vertex_ao, scene_bbox_min, scene_bbox_max);
}
for (size_t i = 0; i < scene.num_instances; ++i) {
delete [] vertex_ao[i];
}
delete [] vertex_ao;
destroy_ao_samples( ao_samples );
delete scene_memory;
return 1;
}
