void clearscreen(){
int x,y;
for (x=0; x<750; x++){
for (y=0; y<450; y++){
location = (x+vinfo.xoffset) * (vinfo.bits_per_pixel/8) +
(y+vinfo.yoffset) * finfo.line_length;
*(fbp + location) = 255; // blue
*(fbp + location + 1) = 248; // green
*(fbp + location + 2) = 224; // red
*(fbp + location + 3) = 0; // transparency
}
for (y=450; y<500; y++){
location = (x+vinfo.xoffset) * (vinfo.bits_per_pixel/8) +
(y+vinfo.yoffset) * finfo.line_length;
*(fbp + location) = 255; // blue
*(fbp + location + 1) = 144; // green
*(fbp + location + 2) = 30; // red
*(fbp + location + 3) = 0; // transparency
}
}
draw_object(14,38,ship,380,10);
if (isRight)
draw_object(14, size_y, plane_right, 10, coor_y);
else
draw_object(14, size_y, plane_left, 10, coor_y);
}
void draw_objects(HWND hWnd)
{
PAINTSTRUCT ps;
HDC hdc;
WORD t;
int a=-1;
SCROLLINFO si;
ZeroMemory(&si, sizeof(si));
si.cbSize = sizeof(si);
si.fMask = SIF_POS;
GetScrollInfo(ghWndDesign, SB_HORZ, &si);
SX=-si.nPos;
GetScrollInfo(ghWndDesign, SB_VERT, &si);
SY=-si.nPos;
hdc = BeginPaint (hWnd, &ps);
for (t=0;t<GLOBAL.objects;t++)
{
draw_object(hdc,t);
// draw_connections(hdc,t);
draw_captions(hdc,t);
if (objects[t]==actobject) a=t;
}
// for (t=0;t<GLOBAL.objects;t++) draw_captions(hdc,t);
if (a!=-1) { draw_object(hdc,a); draw_connections(hdc,a); draw_captions(hdc,a); }
for (t=0;t<GLOBAL.objects;t++) draw_connections(hdc,t);
EndPaint( hWnd, &ps );
}
void arkanoid::Game::init_game_settings(){
nodelay(stdscr, TRUE);
getmaxyx(stdscr, actual_max_row, actual_max_col);
stop = false;
dr_counter = 0;
is_ball_moving = false;
ticks = 0;
if(level_nr < 50)
level_nr++;
bar_speed = 4;
if(rand() % 2 == 0)
col_mod = -1;
else
col_mod = 1;
row_mod = -1;
draw_border();
load_level();
draw_object(bar);
draw_object(ball1);
draw_health();
draw_level_nr();
}
/*! free popup event */
void event_freepu(void) {
int i;
switch(buf[4]) {
case PUL_ALERT :
if(_app)
menu_tnormal(adr_menu, T_FICHIER, 0);
else {
win[WINDACC].w_bar[T_FICHIER + 3].ob_state |= SELECTED;
draw_object(T_FICHIER + 3, WINDACC);
}
big_alert(2, ALERT, "", TRUE);
if(_app)
menu_tnormal(adr_menu, T_FICHIER, 1);
else {
win[WINDACC].w_bar[T_FICHIER + 3].ob_state &= ~SELECTED;
draw_object(T_FICHIER + 3, WINDACC);
}
break;
case PUL_WMENU :
if(_app)
menu_tnormal(adr_menu, T_FENETRES, 0);
else {
win[WINDACC].w_bar[T_FENETRES + 3].ob_state |= SELECTED;
draw_object(T_FENETRES + 3, WINDACC);
}
if(win[WINDMENU].w_hg <= ZERO) {
win[WINDMENU].w_pal =(Palette *)malloc(work_display.n_color * sizeof(Palette));
for(i = 0 ; i < work_display.n_color ; i++) {
win[WINDMENU].w_pal[i][0] = work_display.palette[i][0];
win[WINDMENU].w_pal[i][1] = work_display.palette[i][1];
win[WINDMENU].w_pal[i][2] = work_display.palette[i][2];
}
open_window(WINDMENU, WTYP_PICT, WATR_CURRB,
bureau.xd +(bureau.wd / 5), bureau.yd +(bureau.hd / 5), 320, 150,
100, 100, 200, 200, 16, 16,
WFARROW, THIN_CROSS,
winicn, ZERO, close_wmenu, get_string(TIT_MENU), "",
(long) bureau.wd,(long) bureau.hd,
TRUE, FALSE, W_MENU,
10, BLACK);
}
else {
buf[3] = win[WINDMENU].w_hg;
(*win[WINDMENU].w_top)();
}
if(_app)
menu_tnormal(adr_menu, T_FENETRES, 1);
else {
win[WINDACC].w_bar[T_FENETRES + 3].ob_state &= ~SELECTED;
draw_object(T_FENETRES + 3, WINDACC);
}
break;
} /* end switch case */
} /* event_freepu */
void draw_game(Game *g, BITMAP *scr) {
draw_object(&(g->player), scr, g->player.x, g->player.y);
for(Object *o = g->asteroids; o; o = o->next)
draw_object(o, scr, g->player.x, g->player.y);
for(Object *o = g->shot; o; o = o->next)
draw_object(o, scr, g->player.x, g->player.y);
for(Object *o = g->particles; o; o = o->next)
draw_object(o, scr, g->player.x, g->player.y);
}
void draw_dilldallscene(object* room, object *sphere, object *sphere_copy, float time, float flash, float flash2){
glPushAttrib(GL_ALL_ATTRIB_BITS);
glClearColor(1,1,1,0);
glClear(GL_DEPTH_BUFFER_BIT|GL_COLOR_BUFFER_BIT);
glMatrixMode(GL_TEXTURE);
glLoadIdentity();
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(90, ASPECT, 1.f, 500);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glFogi(GL_FOG_MODE, GL_LINEAR);
glFogfv(GL_FOG_COLOR,black_color);
glFogf(GL_FOG_START, 100.f);
glFogf(GL_FOG_END, 250.f);
glEnable(GL_FOG);
gluLookAt(
sin(time)*90,-50,cos(time)*90,
0,-30,0,
0,1,0
);
set_light(0, (float)sin(time*5)*50,0,(float)cos(time*5)*50,TRUE);
glEnable(GL_LIGHTING);
glEnable(GL_DEPTH_TEST);
glPushMatrix();
glTranslatef(100,0,-100);
draw_object(room);
glPopMatrix();
glPushMatrix();
glTranslatef(0,-30+ sin(time*flash)*flash*20+flash2,0);
glScalef(0.7f,0.7f,0.7f);
glRotatef(time*55,1,0,1);
glRotatef(time*55,1,0,0);
glRotatef(time*55.2f,0,1,0);
glRotatef(time*55,0,0,1);
glRotatef(time*75,1,0,0);
glRotatef(time*55.2f,0,1,0);
blob_distort(sphere, sphere_copy, vector_make((float)sin(time),time,-time), vector_make(
(float)(1+sin(time))*0.1f,
(float)(1+sin(time))*0.1f,
(float)(1+sin(time))*0.1f
),vector_make(0.3f,0.3f,0.3f) );
draw_object(sphere_copy);
glPopMatrix();
glPopAttrib();
}
/*! Free form */
void formulaire(void) {
OBJECT *adr;
int quit = FALSE;
char *adr_bakrsc = 0L; /* ptr form state */
MFDB img;
img.fd_addr = NULL;
if(_app)
menu_tnormal(adr_menu, T_FICHIER, 0); /* Inverser titre */
else {
win[WINDACC].w_bar[T_FICHIER + 3].ob_state |= SELECTED;
draw_object(T_FICHIER + 3, WINDACC);
}
wind_update(BEG_MCTRL); /* Bloquer menu */
adr = ir_trindex[FORMULAIRE];
if(work_display.n_color >= 16) {
adr->ob_spec.obspec.interiorcol = 8;
adr->ob_spec.obspec.fillpattern = 7;
adr[TXT1].ob_spec.tedinfo->te_color = 8;
adr[TXT1].ob_spec.tedinfo->te_color |= 7 << 4;
adr[TXT1].ob_spec.tedinfo->te_color |=(1 << 8);
adr[TXT2].ob_spec.tedinfo->te_color = 8;
adr[TXT2].ob_spec.tedinfo->te_color |= 7 << 4;
adr[TXT2].ob_spec.tedinfo->te_color |=(1 << 8);
}
bak_rsc(adr, &adr_bakrsc);
formm_draw(adr, TXT1, TRUE, &img);
do {
if(dialog(DLG_FORM, adr, FALSE, FALSE, BLANK, &img, TRUE)) {
switch(object) {
case P_CONFIRME :
quit = TRUE;
break;
case P_ANNULE :
quit = TRUE;
res_rsc(adr, &adr_bakrsc);
break;
}
}
} while(NOT quit);
formm_undraw(adr, &img);
if(adr_bakrsc) /* Si état formulaire sauvegardé */
free(adr_bakrsc);
wind_update(END_MCTRL); /* Débloquer menu */
if(_app)
menu_tnormal(adr_menu, T_FICHIER, 1); /* Inverser titre */
else {
win[WINDACC].w_bar[T_FICHIER + 3].ob_state &= ~SELECTED;
draw_object(T_FICHIER + 3, WINDACC);
}
} /* end of formulaire() */
void arkanoid::Game::update_bar_position(){
float xdiff;
Drawable *bar = &drawed[drawed.size() - 2];
Drawable *ball = &drawed[drawed.size() - 1];
if(g_input == KEY_LEFT){
if(bar->d_start_col > bar_speed){
erase_object(*bar);
bar->d_start_col -= bar_speed;
bar->d_end_col -= bar_speed;
draw_object(*bar);
if(!is_ball_moving){
erase_object(*ball);
ball->d_start_col -= bar_speed;
ball->d_end_col -= bar_speed;
draw_object(*ball);
}
} else {
if(bar->d_start_col > 1){
erase_object(*bar);
bar->d_start_col --;
bar->d_end_col --;
draw_object(*bar);
if(!is_ball_moving){
erase_object(*ball);
ball->d_start_col --;
ball->d_end_col --;
draw_object(*ball);
}
}
}
} else if(g_input == KEY_RIGHT){
if(bar->d_end_col < default_max_col - bar_speed - 2){
erase_object(*bar);
bar->d_start_col += bar_speed;
bar->d_end_col += bar_speed;
draw_object(*bar);
if(!is_ball_moving){
erase_object(*ball);
ball->d_start_col += bar_speed;
ball->d_end_col += bar_speed;
draw_object(*ball);
}
} else {
if(bar->d_end_col < default_max_col - 2){
erase_object(*bar);
bar->d_start_col ++;
bar->d_end_col ++;
draw_object(*bar);
if(!is_ball_moving){
erase_object(*ball);
ball->d_start_col ++;
ball->d_end_col ++;
draw_object(*ball);
}
}
}
}
}
void Instructions()
{
cls();
draw_object ("instructions.txt", 0x0A);
while(true)
{
int input1;
cin >> input1;
//if the player presses 1...
//bring to difficulty screen
if(input1 == yes)
{
Beep (1350,150);
gameLoop();
break;
}
//if the player presses 2...
if(input1 == no)
{
Beep (1350,150);
cout << "Thank you for playing! ! !" << endl;
g_quitGame = true;
break;
}
}
}
void Smoke::draw_objects(Worker &worker)
{
auto &data = frame_data_[frame_data_index_];
auto cmd = data.worker_cmds[worker.index_];
VkCommandBufferInheritanceInfo inherit_info = {};
inherit_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO;
inherit_info.renderPass = render_pass_;
inherit_info.framebuffer = worker.fb_;
VkCommandBufferBeginInfo begin_info = {};
begin_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
begin_info.flags = VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT;
begin_info.pInheritanceInfo = &inherit_info;
vk::BeginCommandBuffer(cmd, &begin_info);
vk::CmdSetViewport(cmd, 0, 1, &viewport_);
vk::CmdSetScissor(cmd, 0, 1, &scissor_);
vk::CmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline_);
meshes_->cmd_bind_buffers(cmd);
for (int i = worker.object_begin_; i < worker.object_end_; i++) {
auto &obj = sim_.objects()[i];
draw_object(obj, data, cmd);
}
vk::EndCommandBuffer(cmd);
}
/***********************************
FUNCTION: my_display
ARGS: none
RETURN: none
DOES: main drawing function
************************************/
void my_display(void) {
/* clear the buffer */
/* NEW: now we have to clear depth as well */
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT) ;
glMatrixMode(GL_MODELVIEW) ;
glLoadIdentity();
gluLookAt(0.0, 5.0, 25.0, // x,y,z coord of the camera
0.0, 0.0, 0.0, // x,y,z coord of the origin
0.0, 1.0, 0.0); // the direction of up (default is y-axis)
glRotatef(theta_y,0,1,0);
glRotatef(theta_x,1,0,0);
draw_object(crt_shape);
/* buffer is ready */
glutSwapBuffers();
return ;
}
// TODO Either fix lighting or just give up
void draw_object_with_lighting(object_t* o, uint32_t x, uint32_t y)
{
if(is_lit(o))
{
draw_object(o, x, y);
}
}
int drawPlane(int coor_y, bool isRight) {
int size_x = 14, size_y=24;
if (isRight) {
draw_object(size_x, size_y, plane_right, 10, coor_y);
usleep(1000);
removePlane(size_x, size_y, 10, coor_y);
coor_y+=1;
} else {
draw_object(size_x, size_y, plane_left,10,coor_y);
usleep(1000);
removePlane(size_x, size_y, 10, coor_y);
coor_y-=1;
}
return coor_y;
}
//function to display gameover screen
void gameover()
{
cls();
//show gameover screen
draw_object ("dead.txt", 0x0C);
colour(0x0A);
highscore(score);
cout << endl << "Enter 1 to replay" << endl;
cout << "Enter 2 to return to Main Menu" << endl;
int inputGO = 0;
cin.clear();
cin >> inputGO;
//reset the game
if (inputGO == 1)
{
Beep (2000,200);
init();
mainLoop();
}
if (inputGO == 2)
{
Beep (1350,150);
init();
gameLoop();
}
}
/* Puts robot in (0,0)
*
*
* LOGS the movement
*/
void move_robot_origin()
{
draw_info(ENERGY,ENERGY_STAT, 0, 0, DIRECTION);
draw_log("--Ir al origen ");
draw_robot(0, 0, DIRECTION);
origin();
BOARD[X][Y] = EMPTY;
if( is_station_below )
{
BOARD[X][Y] = STATION;
draw_object(X, Y, 's');
is_station_below=0;
}
X=0;
Y=0;
if( DIRECTION == UP)
{
BOARD[X][Y] = UROBOT;
}
else if( DIRECTION == DOWN)
{
BOARD[X][Y] = DROBOT;
}
else if( DIRECTION == RIGHT)
{
BOARD[X][Y] = RROBOT;
}
else if( DIRECTION == LEFT)
{
BOARD[X][Y] = LROBOT;
}
}
/*! Display info about BIG */
void aff_infos(void) {
OBJECT *adr;
int quit = FALSE, index, tit, menuf = FALSE;
MFDB img;
if(buf[0] == BEV_WMENU) {
index = buf[5];
tit = buf[3];
menuf = TRUE;
}
if(_app)
menu_tnormal(adr_menu, T_BUREAU, 0); /* Inverser titre */
wind_update(BEG_MCTRL); /* Bloquer menu */
adr = ir_trindex[INFOS];
if(work_display.n_color >= 16) {
adr->ob_spec.obspec.interiorcol = 8;
adr->ob_spec.obspec.fillpattern = 7;
}
formm_draw(adr, BLANK, FALSE, &img);
do {
dialog(DLG_FORM, adr, FALSE, FALSE, BLANK, &img, FALSE);
if(object == INF_SORTIE)
quit = TRUE;
} while(NOT quit);
formm_undraw(adr, &img);
wind_update(END_MCTRL); /* Débloquer menu */
if(_app)
menu_tnormal(adr_menu, T_BUREAU, 1); /* Inverser titre */
if(menuf) {
win[index].w_bar[tit].ob_state &= ~SELECTED;
draw_object(tit, index);
}
} /* endof aff_infos() */
void drawstimuli(Map m, Sensor s) {
TCOD_list_t stims = sensor_consume_stimuli(s);
unsigned char *tiles;
mapVec pos, size, oldPt, delta;
unsigned char visflags;
if(TCOD_list_size(stims) > 0) {
TCOD_console_print_left(NULL, 0, 10, TCOD_BKGND_NONE, " ");
}
for(int i = 0; i < TCOD_list_size(stims); i++) {
//this is a very naive approach that completely ignores the possibility of overdraw and 'forgets' object positions
Stimulus st = TCOD_list_get(stims, i);
stimtype type = stimulus_type(st);
TCOD_console_print_left(NULL, i*2, 10, TCOD_BKGND_NONE, "s%i", type);
switch(type) {
case StimTileLitChange:
case StimTileVisChange:
//redraw all tiles
tiles = stimulus_tile_sight_change_get_new_tiles(st);
pos = stimulus_tile_sight_change_get_position(st);
size = stimulus_tile_sight_change_get_size(st);
drawtiles(m, tiles, s, pos, size);
break;
case StimObjLitChange:
case StimObjVisChange:
//redraw object
draw_object(st);
break;
case StimObjMoved:
visflags = stimulus_obj_sight_change_get_new_flags(st);
pos = stimulus_obj_sight_change_get_position(st);
delta = stimulus_obj_moved_get_dir(st);
oldPt = mapvec_subtract(pos, delta);
TCOD_console_print_left(NULL, oldPt.x*2, oldPt.y, TCOD_BKGND_NONE, "x");
draw_object(st);
TCOD_console_print_left(NULL, 0, 15, TCOD_BKGND_NONE, "got move");
break;
case StimGeneric:
default:
TCOD_console_print_left(NULL, i*9, 16, TCOD_BKGND_NONE, "generic %d", i);
break;
}
stimulus_free(st);
}
TCOD_list_delete(stims);
}
void hw2_draw(void)
{
//If something failed there's no point even attempting to render anything.
if(!init_done)
return;
//Clear depth buffer.
glClear(GL_DEPTH_BUFFER_BIT);
//Render the object.
draw_object();
}
//function to render items
void renderpickup (item &bonus)
{
if (check == 0)
{
if (bonus.ID == 1 && elapsedTime >= 16 && checker[0] == 0)
{
draw_object ("item1.txt", 0x0A, bonus.loc.X, bonus.loc.Y);
}
else if (bonus.ID == 2 && elapsedTime >= 24 && checker[1] == 0)
{
draw_object ("item2.txt", 0x0D, bonus.loc.X, bonus.loc.Y);
}
else if (bonus.ID == 3 && elapsedTime >= 33 && checker[2] == 0)
{
draw_object ("item3.txt", 0x0C, bonus.loc.X, bonus.loc.Y);
}
}
else
{
if (bonus.ID == 1 && elapsedTime >= 47 && checker[0] == 0)
{
draw_object ("item1.txt", 0x0A, bonus.loc.X, bonus.loc.Y);
}
else if (bonus.ID == 2 && elapsedTime >= 55 && checker[1] == 0)
{
draw_object ("item2.txt", 0x0D, bonus.loc.X, bonus.loc.Y);
}
else if (bonus.ID == 3 && elapsedTime >= 64 && checker[2] == 0)
{
draw_object ("item3.txt", 0x0C, bonus.loc.X, bonus.loc.Y);
}
}
}
gboolean
draw_cb (GtkWidget * w, cairo_t * cr, gpointer data)
{
int i, j;
for (j = 0; j < GAME_HEIGHT; j++) {
for (i = 0; i < GAME_WIDTH; i++) {
draw_object (i, j, arena[i][j], cr);
}
}
draw_bubble (cr);
return TRUE;
}
void* threadHandler(void *threadArgs) {
while (isExploded()==0) { // harusnya ini kondisi tertembak
coor_y = drawPlane(coor_y,isRight);
if(coor_y > (750-size_y*5)-10 && isRight) {
isRight = false;
}
else if(coor_y < 10 && !isRight) {
isRight = true;
}
}
coor_y = drawPlane(coor_y,isRight);
usleep(1);
draw_object(13,14,explosion,coor_x,coor_y);
usleep(100000);
return NULL;
}
static void draw(void) {
static int first_call = TRUE;
static GLint display_list = 0;
if (first_call) {
first_call = FALSE;
display_list = glGenLists(1);
glNewList(display_list, GL_COMPILE_AND_EXECUTE);
draw_frame();
draw_object();
glEndList();
}
else {
glCallList(display_list);
}
}
void Scene::draw_octree(Octree &oct,bool testcollision,std::list<Object*> &drawn) {
if(oct.objects.size()!=0) {
std::list<Object*>::iterator it;
for(it=oct.objects.begin();it!=oct.objects.end();it++) {
Object *o=*it;
if(!o->has_been_drawn && o->enable_draw()) {
o->update_matrices(&perspective,&camera);
draw_object(o);
drawn.push_back(o);
o->has_been_drawn=true;
}
}
} else {
if(testcollision) {
Octree_Collisions col = oct.frustum_collision(frustum);
if(col==FULL_IN) {
for(int i=0;i<8;i++) {
if(oct.nodes[i]!=NULL) {
draw_octree(*oct.nodes[i],false,drawn);
}
}
} else if(col==IN) {
for(int i=0;i<8;i++) {
if(oct.nodes[i]!=NULL) {
draw_octree(*oct.nodes[i],true,drawn);
}
}
}
} else {
for(int i=0;i<8;i++) {
if(oct.nodes[i]!=NULL) {
draw_octree(*oct.nodes[i],false,drawn);
}
}
}
}
}
void Hologram::draw_objects(Worker &worker)
{
auto &data = frame_data_[frame_data_index_];
auto cmd = data.worker_cmds[worker.index_];
VkCommandBufferInheritanceInfo inherit_info = {};
inherit_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO;
inherit_info.renderPass = render_pass_;
inherit_info.framebuffer = worker.fb_;
VkCommandBufferBeginInfo begin_info = {};
begin_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
begin_info.flags = VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT;
begin_info.pInheritanceInfo = &inherit_info;
vk::BeginCommandBuffer(cmd, &begin_info);
vk::CmdSetViewport(cmd, 0, 1, &viewport_);
vk::CmdSetScissor(cmd, 0, 1, &scissor_);
vk::CmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline_);
meshes_->cmd_bind_buffers(cmd);
for (int i = worker.object_begin_; i < worker.object_end_; i++) {
auto &obj = sim_.objects()[i];
draw_object(obj, data, cmd);
}
vk::EndCommandBuffer(cmd);
if (!use_push_constants_) {
// This flush is not technically required, but it helps API tracing tools track changes in
// mapped memory blocks like this one.
VkMappedMemoryRange range = {};
range.sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE;
range.pNext = nullptr;
range.memory = frame_data_mem_;
range.offset = (data.base - frame_data_[0].base) + sim_.objects()[worker.object_begin_].frame_data_offset;
range.size = aligned_object_data_size * (worker.object_end_ - worker.object_begin_);
vk::FlushMappedMemoryRanges(dev_, 1, &range);
}
}
bool arkanoid::Game::load_level(){
unsigned br_count = 0;
for(int k = 1; k < alevel->brick_nr; k++){
for(int i = 1; i < arkanoid::Level::map_num_rows; i+= arkanoid::Brick::height){
for(int j = 1; j < arkanoid::Level::map_num_cols; j+= arkanoid::Brick::width){
if(alevel->M[i][j] == k){
if(k == 1)
bricks.push_back(WinningBrick(i,j));
else
bricks.push_back(NormalBrick(i,j));
draw_object(bricks[br_count]);
br_count++;
}
}
}
}
}
void monster::draw(WINDOW *w, int plx, int ply, bool inv)
{
int x = SEEX + posx - plx;
int y = SEEY + posy - ply;
nc_color color = type->color;
// see if it's possible to draw a graphical sprite
if(type->sprite) {
if(draw_object(w, x, y, type->sprite)) return;
}
if (friendly != 0 && !inv)
mvwputch_hi(w, y, x, color, type->sym);
else if (inv)
mvwputch_inv(w, y, x, color, type->sym);
else {
color = color_with_effects();
mvwputch(w, y, x, color, type->sym);
}
}
/* draw the the AR objects */
static int draw( ObjectData_T *object, int objectnum )
{
int i;
double gl_para[16];
glClearDepth( 1.0 );
glClear(GL_DEPTH_BUFFER_BIT);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
glEnable(GL_LIGHTING);
/* calculate the viewing parameters - gl_para */
for( i = 0; i < objectnum; i++ ) {
if( object[i].visible == 0 ) continue;
argConvGlpara(object[i].trans, gl_para);
draw_object( object[i].id, gl_para, object[i].collide );
}
glDisable( GL_LIGHTING );
glDisable( GL_DEPTH_TEST );
return(0);
}
static void draw ( void ) {
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
glPushMatrix();
glTranslatef( 0.0, 0.0, -10.0 );
glScalef( Scale*WindH/WindW, Scale, Scale );
glTranslatef(2.5*WindW/WindH*sin(step*1.11),2.5*cos(step*1.25*1.11),0);
glRotatef(step*100,1,0,0);
glRotatef(step*95,0,1,0);
glRotatef(step*90,0,0,1);
seno=(sin(step)+1.0/3.0)*(4.0/5.0)*Magnitude;
draw_object();
glPopMatrix();
glFlush();
glutSwapBuffers();
}
unsigned arkanoid::Game::update_scene(){
if(is_scrsize_changed()){
delete_border();
for(unsigned i = 0; i < drawed.size(); i++){
erase_object(drawed[i]);
}
getmaxyx(stdscr, actual_max_row, actual_max_col);
draw_border();
for(unsigned i = 0; i < drawed.size(); i++){
draw_object(drawed[i]);
}
draw_health();
draw_level_nr();
}
update_bar_position();
return update_ball_position();
}
/*TODO add on*/
void my_display() {
// clear all pixels, reset depth
glClear(GL_COLOR_BUFFER_BIT |GL_DEPTH_BUFFER_BIT );
// init to identity
glLoadIdentity() ;
gluLookAt(x_camera, y_camera, z_camera, // x,y,z coord of the camera
0.0, 0.0, 0.0, // x,y,z LookAt
0.0, 1.0, 0.0); // the direction of Up (default is y-axis)
draw_axes();
draw_object(crt_shape);
// this buffer is ready
glutSwapBuffers();
}