int main(){
float value;
do {
scanf ("%f", &value);
printf("roof: %f\n", roof(value));
} while (value!=-99);
return 0;
}
void GameBoard::initializeGL( QGLWidget & target ) {
QImage wall( "textures/wall.jpg" );
this->wallTexture = target.bindTexture( wall );
QImage grass( "textures/grass.jpg" );
this->grassTexture = target.bindTexture( grass );
QImage roof( "textures/roof.jpg" );
this->roofTexture = target.bindTexture( roof );
QImage tiles( "textures/tiles.jpg" );
this->ghostsStartTexture = target.bindTexture( tiles );
QImage dot( "textures/dot.png" );
this->dotTexture = target.bindTexture( dot );
this->staticList = glGenLists( 1 );
glNewList( this->staticList, GL_COMPILE );
{
for ( int y = 0; y < this->height; ++y ) {
for ( int x = 0; x < this->width; ++x ) {
if ( GameBoard::Wall == this->blocks[ y ][ x ] ) {
this->addWallBlock( x, y );
}
else if ( GameBoard::Path == this->blocks[ y ][ x ] ) {
this->addGrassBlock( x, y );
}
else if ( GameBoard::Dot == this->blocks[ y ][ x ] ) {
this->addGrassBlock( x, y );
}
else if ( GameBoard::Powerup == this->blocks[ y ][ x ] ) {
this->addGrassBlock( x, y );
}
else if ( GameBoard::Teleport1 == this->blocks[ y ][ x ] ) {
this->addGrassBlock( x, y );
}
else if ( GameBoard::PlayerStart == this->blocks[ y ][ x ] ) {
this->addGrassBlock( x, y );
}
else if ( GameBoard::PlayerWall == this->blocks[ y ][ x ] ) {
this->addFloorBlock( x, y, this->roofTexture, this->defaultMaterial );
}
else if ( GameBoard::GhostsStart == this->blocks[ y ][ x ] ) {
this->addFloorBlock(
x, y, this->ghostsStartTexture, this->defaultMaterial
);
}
}
}
}
glEndList();
this->dotList = glGenLists( 1 );
this->dotQuadric = gluNewQuadric();
gluQuadricTexture( this->dotQuadric, true );
glNewList( this->dotList, GL_COMPILE );
{
glBindTexture( GL_TEXTURE_2D, this->dotTexture );
gluSphere( this->dotQuadric, 0.1f, 360 / 30, 180 / 30 );
}
glEndList();
}
static void wall() {
//left column
left();
//center
center();
//right column
right();
//roof
roof();
}
unsigned long long
checksum_path (const char *path)
{
unsigned long long csum = 0;
unsigned long long *nums = 0;
int len = 0;
int cnt = 0;
len = roof (strlen (path), sizeof (csum));
cnt = len / sizeof (csum);
nums = __builtin_alloca (len);
memset (nums, 0, len);
strcpy ((char *)nums, path);
while (cnt) {
csum ^= *nums;
nums++;
cnt--;
}
return csum;
}
static void make_building(GeomVertexAdapter & geom,
double height,
double shadow_angle,
double shadow_length,
double opacity,
F1 const& face_func,
F2 const& frame_func,
F3 const& roof_func,
F4 const& shadow_func)
{
path_type frame(path_type::types::LineString);
path_type roof(path_type::types::Polygon);
std::deque<segment_t> face_segments;
double ring_begin_x, ring_begin_y;
double x0 = 0;
double y0 = 0;
double x,y;
geom.rewind(0);
for (unsigned cm = geom.vertex(&x, &y); cm != SEG_END;
cm = geom.vertex(&x, &y))
{
if (cm == SEG_MOVETO)
{
frame.move_to(x,y);
ring_begin_x = x;
ring_begin_y = y;
}
else if (cm == SEG_LINETO)
{
frame.line_to(x,y);
face_segments.emplace_back(x0,y0,x,y);
}
else if (cm == SEG_CLOSE)
{
frame.close_path();
if (!face_segments.empty())
{
face_segments.emplace_back(x0, y0, ring_begin_x, ring_begin_y);
}
}
x0 = x;
y0 = y;
}
if (shadow_length > 0)
{
shadow_angle = util::normalize_angle(shadow_angle * (M_PI / 180.0));
for (auto const& seg : face_segments)
{
double dx = std::get<2>(seg) - std::get<0>(seg);
double dy = std::get<3>(seg) - std::get<1>(seg);
double seg_normal_angle = std::atan2(-dx, -dy);
double angle_diff = std::abs(seg_normal_angle - shadow_angle);
double min_angle_diff = std::min((2 * M_PI) - angle_diff, angle_diff);
if (min_angle_diff <= (M_PI / 2.0))
{
path_type shadow(path_type::types::Polygon);
shadow.move_to(std::get<0>(seg), std::get<1>(seg));
shadow.line_to(std::get<2>(seg), std::get<3>(seg));
shadow.line_to(std::get<2>(seg) + shadow_length * std::cos(shadow_angle),
std::get<3>(seg) - shadow_length * std::sin(shadow_angle));
shadow.line_to(std::get<0>(seg) + shadow_length * std::cos(shadow_angle),
std::get<1>(seg) - shadow_length * std::sin(shadow_angle));
shadow_func(shadow);
}
}
}
if (opacity > 0)
{
for (auto const& seg : face_segments)
{
path_type faces(path_type::types::Polygon);
faces.move_to(std::get<0>(seg),std::get<1>(seg));
faces.line_to(std::get<2>(seg),std::get<3>(seg));
faces.line_to(std::get<2>(seg),std::get<3>(seg) - height);
faces.line_to(std::get<0>(seg),std::get<1>(seg) - height);
face_func(faces);
frame.move_to(std::get<0>(seg),std::get<1>(seg));
frame.line_to(std::get<0>(seg),std::get<1>(seg) - height);
}
geom.rewind(0);
for (unsigned cm = geom.vertex(&x, &y); cm != SEG_END;
cm = geom.vertex(&x, &y))
{
if (cm == SEG_MOVETO)
{
frame.move_to(x,y - height);
roof.move_to(x,y - height);
}
else if (cm == SEG_LINETO)
{
frame.line_to(x,y - height);
roof.line_to(x,y - height);
}
else if (cm == SEG_CLOSE)
{
frame.close_path();
roof.close_path();
}
}
frame_func(frame);
roof_func(roof);
}
}
void agg_renderer<T>::process(building_symbolizer const& sym,
mapnik::feature_impl & feature,
proj_transform const& prj_trans)
{
typedef coord_transform<CoordTransform,geometry_type> path_type;
typedef agg::renderer_base<agg::pixfmt_rgba32> ren_base;
typedef agg::renderer_scanline_aa_solid<ren_base> renderer;
agg::rendering_buffer buf(current_buffer_->raw_data(),width_,height_, width_ * 4);
agg::pixfmt_rgba32 pixf(buf);
ren_base renb(pixf);
color const& fill_ = sym.get_fill();
unsigned r=fill_.red();
unsigned g=fill_.green();
unsigned b=fill_.blue();
unsigned a=fill_.alpha();
renderer ren(renb);
agg::scanline_u8 sl;
ras_ptr->reset();
ras_ptr->gamma(agg::gamma_power());
double height = 0.0;
expression_ptr height_expr = sym.height();
if (height_expr)
{
value_type result = boost::apply_visitor(evaluate<Feature,value_type>(feature), *height_expr);
height = result.to_double() * scale_factor_;
}
for (unsigned i=0;i<feature.num_geometries();++i)
{
geometry_type const& geom = feature.get_geometry(i);
if (geom.size() > 2)
{
boost::scoped_ptr<geometry_type> frame(new geometry_type(LineString));
boost::scoped_ptr<geometry_type> roof(new geometry_type(Polygon));
std::deque<segment_t> face_segments;
double x0 = 0;
double y0 = 0;
double x,y;
geom.rewind(0);
for (unsigned cm = geom.vertex(&x, &y); cm != SEG_END;
cm = geom.vertex(&x, &y))
{
if (cm == SEG_MOVETO)
{
frame->move_to(x,y);
}
else if (cm == SEG_LINETO || cm == SEG_CLOSE)
{
frame->line_to(x,y);
face_segments.push_back(segment_t(x0,y0,x,y));
}
x0 = x;
y0 = y;
}
std::sort(face_segments.begin(),face_segments.end(), y_order);
std::deque<segment_t>::const_iterator itr=face_segments.begin();
std::deque<segment_t>::const_iterator end=face_segments.end();
for (; itr!=end; ++itr)
{
boost::scoped_ptr<geometry_type> faces(new geometry_type(Polygon));
faces->move_to(itr->get<0>(),itr->get<1>());
faces->line_to(itr->get<2>(),itr->get<3>());
faces->line_to(itr->get<2>(),itr->get<3>() + height);
faces->line_to(itr->get<0>(),itr->get<1>() + height);
path_type faces_path (t_,*faces,prj_trans);
ras_ptr->add_path(faces_path);
ren.color(agg::rgba8(int(r*0.8), int(g*0.8), int(b*0.8), int(a * sym.get_opacity())));
agg::render_scanlines(*ras_ptr, sl, ren);
ras_ptr->reset();
//
frame->move_to(itr->get<0>(),itr->get<1>());
frame->line_to(itr->get<0>(),itr->get<1>()+height);
}
geom.rewind(0);
for (unsigned cm = geom.vertex(&x, &y); cm != SEG_END;
cm = geom.vertex(&x, &y))
{
if (cm == SEG_MOVETO)
{
frame->move_to(x,y+height);
roof->move_to(x,y+height);
}
else if (cm == SEG_LINETO || cm == SEG_CLOSE)
{
frame->line_to(x,y+height);
roof->line_to(x,y+height);
}
}
path_type path(t_,*frame,prj_trans);
agg::conv_stroke<path_type> stroke(path);
stroke.width(scale_factor_);
ras_ptr->add_path(stroke);
ren.color(agg::rgba8(int(r*0.8), int(g*0.8), int(b*0.8), int(a * sym.get_opacity())));
agg::render_scanlines(*ras_ptr, sl, ren);
ras_ptr->reset();
path_type roof_path (t_,*roof,prj_trans);
ras_ptr->add_path(roof_path);
ren.color(agg::rgba8(r, g, b, int(a * sym.get_opacity())));
agg::render_scanlines(*ras_ptr, sl, ren);
}
}
}
void agg_renderer<T>::process(building_symbolizer const& sym,
Feature const& feature,
proj_transform const& prj_trans)
{
typedef coord_transform2<CoordTransform,geometry_type> path_type;
typedef coord_transform3<CoordTransform,geometry_type> path_type_roof;
typedef agg::renderer_base<agg::pixfmt_rgba32_plain> ren_base;
typedef agg::renderer_scanline_aa_solid<ren_base> renderer;
agg::rendering_buffer buf(pixmap_.raw_data(),width_,height_, width_ * 4);
agg::pixfmt_rgba32_plain pixf(buf);
ren_base renb(pixf);
color const& fill_ = sym.get_fill();
unsigned r=fill_.red();
unsigned g=fill_.green();
unsigned b=fill_.blue();
unsigned a=fill_.alpha();
renderer ren(renb);
agg::scanline_u8 sl;
ras_ptr->reset();
ras_ptr->gamma(agg::gamma_linear());
double height = sym.height() * scale_factor_;
for (unsigned i=0;i<feature.num_geometries();++i)
{
geometry_type const& geom = feature.get_geometry(i);
if (geom.num_points() > 2)
{
boost::scoped_ptr<geometry_type> frame(new geometry_type(LineString));
boost::scoped_ptr<geometry_type> roof(new geometry_type(Polygon));
std::deque<segment_t> face_segments;
double x0(0);
double y0(0);
unsigned cm = geom.vertex(&x0,&y0);
for (unsigned j=1;j<geom.num_points();++j)
{
double x(0);
double y(0);
cm = geom.vertex(&x,&y);
if (cm == SEG_MOVETO)
{
frame->move_to(x,y);
}
else if (cm == SEG_LINETO)
{
frame->line_to(x,y);
face_segments.push_back(segment_t(x0,y0,x,y));
}
x0 = x;
y0 = y;
}
std::sort(face_segments.begin(),face_segments.end(), y_order);
std::deque<segment_t>::const_iterator itr=face_segments.begin();
for (;itr!=face_segments.end();++itr)
{
boost::scoped_ptr<geometry_type> faces(new geometry_type(Polygon));
faces->move_to(itr->get<0>(),itr->get<1>());
faces->line_to(itr->get<2>(),itr->get<3>());
faces->line_to(itr->get<2>(),itr->get<3>() + height);
faces->line_to(itr->get<0>(),itr->get<1>() + height);
path_type faces_path (t_,*faces,prj_trans);
ras_ptr->add_path(faces_path);
ren.color(agg::rgba8(int(r*0.8), int(g*0.8), int(b*0.8), int(a * sym.get_opacity())));
agg::render_scanlines(*ras_ptr, sl, ren);
ras_ptr->reset();
frame->move_to(itr->get<0>(),itr->get<1>());
frame->line_to(itr->get<0>(),itr->get<1>()+height);
}
geom.rewind(0);
for (unsigned j=0;j<geom.num_points();++j)
{
double x,y;
unsigned cm = geom.vertex(&x,&y);
if (cm == SEG_MOVETO)
{
frame->move_to(x,y+height);
roof->move_to(x,y+height);
}
else if (cm == SEG_LINETO)
{
frame->line_to(x,y+height);
roof->line_to(x,y+height);
}
}
path_type path(t_,*frame,prj_trans);
agg::conv_stroke<path_type> stroke(path);
ras_ptr->add_path(stroke);
ren.color(agg::rgba8(int(r*0.8), int(g*0.8), int(b*0.8), int(255 * sym.get_opacity())));
agg::render_scanlines(*ras_ptr, sl, ren);
ras_ptr->reset();
path_type roof_path (t_,*roof,prj_trans);
ras_ptr->add_path(roof_path);
ren.color(agg::rgba8(r, g, b, int(a * sym.get_opacity())));
agg::render_scanlines(*ras_ptr, sl, ren);
}
}
}
void make_building(geometry::polygon<double> const& poly, double height, F1 const& face_func, F2 const& frame_func, F3 const& roof_func)
{
path_type frame(path_type::types::LineString);
path_type roof(path_type::types::Polygon);
std::deque<segment_t> face_segments;
double ring_begin_x, ring_begin_y;
double x0 = 0;
double y0 = 0;
double x,y;
geometry::polygon_vertex_adapter<double> va(poly);
va.rewind(0);
for (unsigned cm = va.vertex(&x, &y); cm != SEG_END;
cm = va.vertex(&x, &y))
{
if (cm == SEG_MOVETO)
{
frame.move_to(x,y);
ring_begin_x = x;
ring_begin_y = y;
}
else if (cm == SEG_LINETO)
{
frame.line_to(x,y);
face_segments.emplace_back(x0,y0,x,y);
}
else if (cm == SEG_CLOSE)
{
frame.close_path();
if (!face_segments.empty())
{
face_segments.emplace_back(x0, y0, ring_begin_x, ring_begin_y);
}
}
x0 = x;
y0 = y;
}
std::sort(face_segments.begin(),face_segments.end(), y_order);
for (auto const& seg : face_segments)
{
path_type faces(path_type::types::Polygon);
faces.move_to(std::get<0>(seg),std::get<1>(seg));
faces.line_to(std::get<2>(seg),std::get<3>(seg));
faces.line_to(std::get<2>(seg),std::get<3>(seg) + height);
faces.line_to(std::get<0>(seg),std::get<1>(seg) + height);
face_func(faces);
//
frame.move_to(std::get<0>(seg),std::get<1>(seg));
frame.line_to(std::get<0>(seg),std::get<1>(seg)+height);
}
va.rewind(0);
for (unsigned cm = va.vertex(&x, &y); cm != SEG_END;
cm = va.vertex(&x, &y))
{
if (cm == SEG_MOVETO)
{
frame.move_to(x,y+height);
roof.move_to(x,y+height);
}
else if (cm == SEG_LINETO)
{
frame.line_to(x,y+height);
roof.line_to(x,y+height);
}
else if (cm == SEG_CLOSE)
{
frame.close_path();
roof.close_path();
}
}
frame_func(frame);
roof_func(roof);
}
int main()
{
WORKING_DIR=SDL_GetBasePath();
WORKING_DIR=WORKING_DIR.substr(0,WORKING_DIR.find_last_of("/\\"));
WORKING_DIR=WORKING_DIR.substr(0,WORKING_DIR.find_last_of("/\\"));
WORKING_DIR=WORKING_DIR.substr(0,WORKING_DIR.find_last_of("/\\"));
#ifdef __gnu_linux__
WORKING_DIR+="/";
#elif __WIN32
WORKING_DIR+="\\";
#endif
std::cout<< WORKING_DIR<<std::endl;
SDL_Window *mainwindow; /* Our window handle */
SDL_GLContext maincontext; /* Our opengl context handle */
Mix_Chunk *pong = NULL;
Mix_Chunk *pong2 = NULL;
Mix_Chunk *pong3 = NULL;
if( SDL_Init( SDL_INIT_VIDEO| SDL_INIT_AUDIO ) < 0 )
{
sdldie("SDL could not initialize! SDL Error: %s\n");
}
else
{
//Use OpenGL 3.3 core
SDL_GL_SetAttribute( SDL_GL_CONTEXT_MAJOR_VERSION, 3 );
SDL_GL_SetAttribute( SDL_GL_CONTEXT_MINOR_VERSION, 3 );
SDL_GL_SetAttribute( SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE );
//Create window
mainwindow = SDL_CreateWindow( "pong", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, screenWidth, screenHeight, SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN |SDL_WINDOW_RESIZABLE );
if( mainwindow == NULL )
{
sdldie("Unable to create window");
}
else
{
//Create context
maincontext = SDL_GL_CreateContext( mainwindow );
if( maincontext == NULL ){
sdldie("OpenGL context could not be created! SDL Error: %s\n");
}
else
{
//Initialize GLEW
glewExperimental = GL_TRUE;
GLenum glewError = glewInit();
if( glewError != GLEW_OK )
{
std::cout<<"Error initializing GLEW! %s\n"<<glewGetErrorString( glewError );
}
//Use Vsync
if( SDL_GL_SetSwapInterval( 1 ) < 0 )
{
std::cout<<"Warning: Unable to set VSync! SDL Error: %s\n"<<SDL_GetError();
}
SDL_DisplayMode current;
int should_be_zero = SDL_GetCurrentDisplayMode(0, ¤t); //@HACK:should check for multiple monitors
if(should_be_zero != 0)
sdldie("Could not get display mode for video display");
screenWidth=(3.0f/4.0f)*current.w;
screenHeight=(3.0f/4.0f)*current.h;
(*(int*)(&originalScreenHeight))=screenHeight;
(*(int*)(&originalScreenWidth))=screenWidth;
}
}
}
//Initialize SDL_mixer
if( Mix_OpenAudio( 44100, MIX_DEFAULT_FORMAT, 2, 2048 ) < 0 ) {
std::cout<<"SDL_mixer could not initialize! SDL_mixer Error: "<<Mix_GetError();
return 1;
}
//Load sound effects
pong = Mix_LoadWAV(WORKING_DIR_FILE("assets/sounds/pong.wav"));
if( pong == NULL ) {
std::cout<< "Failed to load scratch sound effect! SDL_mixer Error: "<<Mix_GetError();
return 1;
}
pong2 = Mix_LoadWAV(WORKING_DIR_FILE("assets/sounds/pong2.wav"));
if( pong2 == NULL ) {
std::cout<< "Failed to load scratch sound effect! SDL_mixer Error: "<<Mix_GetError();
return 1;
}
pong3 = Mix_LoadWAV(WORKING_DIR_FILE("assets/sounds/pong3.wav"));
if( pong3 == NULL ) {
std::cout<< "Failed to load scratch sound effect! SDL_mixer Error: "<<Mix_GetError();
return 1;
}
glEnable(GL_DEPTH_TEST);
glViewport(0, 0, screenWidth, screenHeight);
/* Clear our buffer with a red background */
glClearColor ( 1.0, 0.0, 0.0, 1.0 );
glClear ( GL_COLOR_BUFFER_BIT );
/* Swap our back buffer to the front */
SDL_GL_SwapWindow(mainwindow);
/* Wait 2 seconds */
SDL_Delay(100);
/* Same as above, but green */
glClearColor ( 0.0, 1.0, 0.0, 1.0 );
glClear ( GL_COLOR_BUFFER_BIT );
SDL_GL_SwapWindow(mainwindow);
SDL_Delay(100);
/* Same as above, but blue */
glClearColor ( 0.0, 0.0, 1.0, 1.0 );
glClear ( GL_COLOR_BUFFER_BIT );
SDL_GL_SwapWindow(mainwindow);
SDL_Delay(100);
GLfloat vertices[] = {
0.5f, 0.5f, 0.0f, // Top Right
0.5f, -0.5f, 0.0f, // Bottom Right
-0.5f, -0.5f, 0.0f, // Bottom Left
-0.5f, 0.5f, 0.0f, // Top Left
};
GLuint indices[] = { // Note that we start from 0!
0, 1, 3, // First Triangle
1, 2, 3 // Second Triangle
};
std::vector<Vertex> vertices2;
std::vector<GLuint> indices2;
{
for(unsigned int i=0;i<(sizeof(vertices)/sizeof(vertices[0]));i+=3){
Vertex aux;
aux.position={vertices[i+0],vertices[i+1],vertices[i+2]};
vertices2.push_back(aux);
}
for(unsigned int i=0;i<(sizeof(indices)/sizeof(indices[0]));i++){
indices2.push_back(indices[i]);
}
}
Sprite sprite(vertices2,indices2);
GLfloat quadVertices[] = { // Vertex attributes for a quad that fills the entire screen in Normalized Device Coordinates.
// Positions // TexCoords
-1.0f, 1.0f, 0.0f, 1.0f,
-1.0f, -1.0f, 0.0f, 0.0f,
1.0f, -1.0f, 1.0f, 0.0f,
-1.0f, 1.0f, 0.0f, 1.0f,
1.0f, -1.0f, 1.0f, 0.0f,
1.0f, 1.0f, 1.0f, 1.0f
};
// Setup cube VAO
GLuint quadVAO, quadVBO;
glGenVertexArrays(1, &quadVAO);
glGenBuffers(1, &quadVBO);
glBindVertexArray(quadVAO);
glBindBuffer(GL_ARRAY_BUFFER, quadVBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(quadVertices), quadVertices, GL_STATIC_DRAW);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(GLfloat), (GLvoid*)0);
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(GLfloat), (GLvoid*)(2 * sizeof(GLfloat)));
glBindVertexArray(0);
unsigned int points_p1=0,points_p2=0;
bool first_point_p1=true,first_point_p2=true;
GameObject player1(&sprite,{0.0f,2.0f});
GameObject player2(&sprite,{0.0f,2.0f});
GameObject ball(&sprite,{0.0f,0.0f});
Entity roof(&sprite);
Entity floor(&sprite);
GameObject leftwall(&sprite,{0.0f,0.0f});
GameObject rightwall(&sprite,{0.0f,0.0f});
{
player1.entity.setPos({-0.95f,0.0f});
player2.entity.setPos({0.95f,0.0f});
ball.entity.setPos({0.0f,8.0f});
roof.setPos({-1.0f,1.10f});
floor.setPos({-1.0f,-1.10f});
roof.scale({4.0f,1.0f});
floor.scale({4.0f,1.0f});
leftwall.entity.setPos({-1.0f,0.0f});
rightwall.entity.setPos({1.0f,0.0f});
leftwall.entity.scale({0.025f,2.0f});
rightwall.entity.scale({0.025f,2.0f});
player1.entity.scale({0.025f, 0.49f});
player2.entity.scale({0.025f, 0.49f});
ball.entity.scale({0.0625f,0.0625f});
ball.entity.order(SCALE,ROTATE,TRANSLATE);
}
std::vector<CollisionChecker> collisions;
{
collisions.push_back(CollisionChecker(&player1.entity,&roof));
collisions.push_back(CollisionChecker(&player1.entity,&floor));
collisions.push_back(CollisionChecker(&player2.entity,&roof));
collisions.push_back(CollisionChecker(&player2.entity,&floor));
}
CollisionChecker ball_floor(&ball.entity,&floor);
CollisionChecker ball_roof(&ball.entity,&roof);
CollisionChecker ball_p1(&ball.entity,&player1.entity);
CollisionChecker ball_p2(&ball.entity,&player2.entity);
CollisionChecker ball_leftwall(&ball.entity,&leftwall.entity);
CollisionChecker ball_rightwall(&ball.entity,&rightwall.entity);
SDL_StartTextInput();
bool quit = false;
bool started=false;
glm::vec2 p1_speed_gain(0.0f,0.0f);
glm::vec2 p2_speed_gain(0.0f,0.0f);
unsigned int i=0;
Uint32 lastFrame=0;
Uint32 deltaTime=0;
float framerate=0.0f;
float dt;
framebuffer fb(originalScreenWidth,originalScreenHeight);
Shader shader(WORKING_DIR_FILE("assets/shaders/shader.vert"),WORKING_DIR_FILE("assets/shaders/shader.frag"));
Shader fb_shader(WORKING_DIR_FILE("assets/shaders/framebuffer_shader.vert"),WORKING_DIR_FILE("assets/shaders/framebuffer_shader.frag"));
while(!quit)
{
SDL_PumpEvents();
Uint32 currentFrame = SDL_GetTicks();//miliseconds
deltaTime = currentFrame - lastFrame;
lastFrame = currentFrame;
dt = deltaTime/1000.0f;
framerate += 1000.0f/deltaTime;
p1_speed_gain={0.0f,0.0f};
p2_speed_gain={0.0f,0.0f};
{
const Uint8 *keystates = SDL_GetKeyboardState( NULL );
quit = keystates[SDL_GetScancodeFromKey(SDLK_q)] || SDL_QuitRequested();
started = started || keystates[SDL_GetScancodeFromKey(SDLK_SPACE)];
if(started){
if(keystates[SDL_GetScancodeFromKey(SDLK_w )])
{
player1.move( dt );
p1_speed_gain={ 0.0f , 1.0f };
}
if(keystates[SDL_GetScancodeFromKey(SDLK_s )])
{
player1.move(-dt );
p1_speed_gain={ 0.0f ,-1.0f };
}
if(keystates[SDL_GetScancodeFromKey(SDLK_UP )])
{
player2.move( dt );
p2_speed_gain={ 0.0f , 1.0f };
}
if(keystates[SDL_GetScancodeFromKey(SDLK_DOWN)])
{
player2.move(-dt );
p2_speed_gain={ 0.0f ,-1.0f };
}
if(keystates[SDL_GetScancodeFromKey(SDLK_j)])
{
player1.entity.rotate(15.0f );
}
do_ball_movement(ball,dt);
}
}
{
unsigned int size=collisions.size();
for(unsigned int i=0;i<size;i++)
{
if(collisions[i].checkCollision())
handleCollision(collisions[i]);
}
}
{
glm::vec3 pos=ball.entity.position;
glm::vec3 oldpos=ball.entity.oldPosition;
if(ball_floor.checkCollision()){
handleCollision(ball_floor);
ball.speed=glm::normalize(glm::reflect(glm::vec2(pos.x-oldpos.x,pos.y-oldpos.y),glm::vec2(0.0f,1.0f)))*glm::length(ball.speed);
Mix_PlayChannel( -1, pong2, 0 );
}
if(ball_roof.checkCollision()){
handleCollision(ball_roof);
ball.speed=glm::normalize(glm::reflect(glm::vec2(pos.x-oldpos.x,pos.y-oldpos.y),glm::vec2(0.0f,-1.0f)))*glm::length(ball.speed);
Mix_PlayChannel( -1, pong2, 0 );
}
if(ball_p1.checkCollision()){
handleCollision(ball_p1);
ball.speed=glm::normalize(glm::reflect(glm::vec2(pos.x-oldpos.x,pos.y-oldpos.y),glm::vec2(1.0f,0.0f)) + p1_speed_gain)
*
(glm::length(ball.speed)+glm::length(p1_speed_gain));
Mix_PlayChannel( -1, pong, 0 );
}
if(ball_p2.checkCollision()){
handleCollision(ball_p2);
ball.speed=glm::normalize(glm::reflect(glm::vec2(pos.x-oldpos.x,pos.y-oldpos.y),glm::vec2(-1.0f,0.0f)) + p2_speed_gain)
*
(glm::length(ball.speed)+glm::length(p2_speed_gain));
Mix_PlayChannel( -1, pong, 0 );
}
if(ball_leftwall.checkCollision()){
points_p2++;
ball.entity.setPos({0.0f,8.0f});//scale adjusted due the order it uses...
ball.speed={0.0f,0.0f};
Mix_PlayChannel( -1, pong3, 0 );
}
if(ball_rightwall.checkCollision()){
points_p1++;
ball.entity.setPos({0.0f,8.0f});
ball.speed={0.0f,0.0f};
Mix_PlayChannel( -1, pong3, 0 );
}
if(((ball.speed.y/ball.speed.x)>3.0f) || ((ball.speed.y/ball.speed.x)<-3.0f)){
ball.speed.y/=2.0f;
ball.speed.x*=4.0f;
}
}
if(i==100){
i=0;
framerate/=100.0f;
std::cout<<framerate<<std::endl;
std::cout<<points_p1<<'-'<<points_p2<<std::endl;
framerate=0.0f;
}
i+=1;
shader.Use();
fb.bind();
glViewport(0,0,originalScreenWidth,originalScreenHeight);
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
glEnable(GL_DEPTH_TEST);
glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
glm::mat4 projection;//= glm::ortho(-1.0f,1.0f,-1.0f,1.0f,0.0f,1.0f);
GLint projection_uniform=glGetUniformLocation(shader.Program, "projection");
glUniformMatrix4fv(projection_uniform, 1, GL_FALSE, glm::value_ptr(projection));
glm::vec2 position;
position=glm::vec2(-3.0f*1.06255f*0.125f,0.0f);
if(points_p1>=5 || points_p2>=5){
drawdigit(-1,&shader,position,{0.125f,0.125f},DIGIT_TOP|DIGIT_MIDDLE|DIGIT_TOPLEFT|DIGIT_TOPRIGHT|DIGIT_BOTTOMLEFT);
position+=glm::vec2(1.0625f*0.125f,0.0f);
drawdigit((points_p1>=5)?1:2,&shader,position,{0.125f,0.125f});
position+=glm::vec2(1.0625f*0.125f,0.0f);
position+=glm::vec2(1.0625f*0.125f,0.0f);
drawdigit(-1,&shader,position,{0.125f,0.125f},DIGIT_TOPLEFT |DIGIT_BOTTOMLEFT |DIGIT_BOTTOMLEFT_MIDDLE|
DIGIT_TOPRIGHT|DIGIT_BOTTOMRIGHT|DIGIT_BOTTOMRIGHT_MIDDLE);
position+=glm::vec2(1.0625f*0.125f,0.0f);
drawdigit(-1,&shader,position,{0.125f,0.125f},DIGIT_TOPMIDDLE|DIGIT_BOTTOMMIDDLE);
position+=glm::vec2(1.0625f*0.125f,0.0f);
drawdigit(-1,&shader,position,{0.125f,0.125f},DIGIT_BOTTOMLEFT |DIGIT_TOPLEFT|DIGIT_TOPLEFT_BOTTOMRIGHT|
DIGIT_BOTTOMRIGHT|DIGIT_TOPRIGHT);
position+=glm::vec2(1.0625f*0.125f,0.0f);
drawdigit(5,&shader,position,{0.125f,0.125f});
started=false;
}
player1.entity.draw(&shader);
player2.entity.draw(&shader);
if(started) ball.entity.draw(&shader);
roof.draw(&shader);
floor.draw(&shader);
leftwall.entity.draw(&shader);
rightwall.entity.draw(&shader);
unsigned int aux=points_p2;
position=glm::vec2(0.25f,0.5f);
//NOTE: when one of the points hits 20 I should put a you win screen
first_point_p2=points_p2? false:true;
while((aux/10) || (aux%10) || first_point_p2){
drawdigit(aux%10,&shader,position,{0.125f,0.125f});
position.x-=1.5f*0.125f;
aux=aux/10;
first_point_p2=false;//endless loop if I dont
}
aux=points_p1;
position={-0.25f,0.5f};
first_point_p1=points_p1? false:true;
while((aux/10) || (aux%10) || first_point_p1){
drawdigit(aux%10,&shader,position,{0.125f,0.125f});
position.x-=1.5f*0.125f;
aux=aux/10;
first_point_p1=false;
}
fb.unbind();
SDL_GetWindowSize(mainwindow,&screenWidth,&screenHeight);
glViewport(0,0,screenWidth,screenHeight);
glClearColor(0.0f, 0.0f, 0.1f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT);
glDisable(GL_DEPTH_TEST);
fb_shader.Use();
glm::mat4 screenscaler;
float aspectRatio=(float)screenWidth/(float)screenHeight;
float inverseAspectRatio=(float)screenHeight/(float)screenWidth;
if(aspectRatio>1.0f)
screenscaler = glm::perspective(radians(59.2f),aspectRatio,0.1f,1.0f);
else
screenscaler = glm::perspective(radians(59.2f),inverseAspectRatio,0.1f,1.0f);
GLint model_uniform=glGetUniformLocation(fb_shader.Program, "model");
glUniformMatrix4fv(model_uniform, 1, GL_FALSE, glm::value_ptr(screenscaler));
glBindVertexArray(quadVAO);//should scale the scale to the % of resolution
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, fb.texture);
glDrawArrays(GL_TRIANGLES, 0, 6);
glBindTexture(GL_TEXTURE_2D,0);
glBindVertexArray(0);
SDL_Delay(1);
SDL_GL_SwapWindow(mainwindow);
if(points_p1>=5 || points_p2>=5){
points_p1=0;
points_p2=0;
ball.speed={0.0f,0.0f};
SDL_Delay(3000);
}
}
DESTRUCTOR(fb);
DESTRUCTOR(shader);
DESTRUCTOR(fb_shader);
Mix_FreeChunk(pong);
Mix_FreeChunk(pong2);
Mix_FreeChunk(pong3);
SDL_GL_DeleteContext(maincontext);
SDL_DestroyWindow(mainwindow);
SDL_Quit();
return 0;
}
