// This test is intended to verify that proper synchronization is done when
// rendering into an FBO.
TEST_F(SurfaceTextureFBOTest, BlitFromCpuFilledBufferToFbo) {
const int texWidth = 64;
const int texHeight = 64;
ASSERT_EQ(NO_ERROR, native_window_set_buffers_geometry(mANW.get(),
texWidth, texHeight, HAL_PIXEL_FORMAT_RGBA_8888));
ASSERT_EQ(NO_ERROR, native_window_set_usage(mANW.get(),
GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN));
android_native_buffer_t* anb;
ASSERT_EQ(NO_ERROR, native_window_dequeue_buffer_and_wait(mANW.get(),
&anb));
ASSERT_TRUE(anb != NULL);
sp<GraphicBuffer> buf(new GraphicBuffer(anb, false));
// Fill the buffer with green
uint8_t* img = NULL;
buf->lock(GRALLOC_USAGE_SW_WRITE_OFTEN, (void**)(&img));
fillRGBA8BufferSolid(img, texWidth, texHeight, buf->getStride(), 0, 255,
0, 255);
buf->unlock();
ASSERT_EQ(NO_ERROR, mANW->queueBuffer(mANW.get(), buf->getNativeBuffer(),
-1));
ASSERT_EQ(NO_ERROR, mST->updateTexImage());
glBindFramebuffer(GL_FRAMEBUFFER, mFbo);
drawTexture();
glBindFramebuffer(GL_FRAMEBUFFER, 0);
for (int i = 0; i < 4; i++) {
SCOPED_TRACE(String8::format("frame %d", i).string());
ASSERT_EQ(NO_ERROR, native_window_dequeue_buffer_and_wait(mANW.get(),
&anb));
ASSERT_TRUE(anb != NULL);
buf = new GraphicBuffer(anb, false);
// Fill the buffer with red
ASSERT_EQ(NO_ERROR, buf->lock(GRALLOC_USAGE_SW_WRITE_OFTEN,
(void**)(&img)));
fillRGBA8BufferSolid(img, texWidth, texHeight, buf->getStride(), 255, 0,
0, 255);
ASSERT_EQ(NO_ERROR, buf->unlock());
ASSERT_EQ(NO_ERROR, mANW->queueBuffer(mANW.get(),
buf->getNativeBuffer(), -1));
ASSERT_EQ(NO_ERROR, mST->updateTexImage());
drawTexture();
EXPECT_TRUE(checkPixel( 24, 39, 255, 0, 0, 255));
}
glBindFramebuffer(GL_FRAMEBUFFER, mFbo);
EXPECT_TRUE(checkPixel( 24, 39, 0, 255, 0, 255));
}
TEST_F(SurfaceTextureGLToGLTest, TexturingFromPreRotatedGLFilledBuffer) {
enum { texWidth = 64 };
enum { texHeight = 16 };
// This test requires 3 buffers to complete run on a single thread.
mST->setDefaultMaxBufferCount(3);
// Set the transform hint.
mST->setTransformHint(NATIVE_WINDOW_TRANSFORM_ROT_90);
// Set the default buffer size.
mST->setDefaultBufferSize(texWidth, texHeight);
// Do the producer side of things
EXPECT_TRUE(eglMakeCurrent(mEglDisplay, mProducerEglSurface,
mProducerEglSurface, mProducerEglContext));
ASSERT_EQ(EGL_SUCCESS, eglGetError());
// This is needed to ensure we pick up a buffer of the correct size and the
// new rotation hint.
eglSwapBuffers(mEglDisplay, mProducerEglSurface);
glClearColor(0.6, 0.6, 0.6, 0.6);
glClear(GL_COLOR_BUFFER_BIT);
glEnable(GL_SCISSOR_TEST);
glScissor(24, 4, 1, 1);
glClearColor(1.0, 0.0, 0.0, 1.0);
glClear(GL_COLOR_BUFFER_BIT);
eglSwapBuffers(mEglDisplay, mProducerEglSurface);
// Do the consumer side of things
EXPECT_TRUE(eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface,
mEglContext));
ASSERT_EQ(EGL_SUCCESS, eglGetError());
glDisable(GL_SCISSOR_TEST);
// Skip the first frame, which was empty
ASSERT_EQ(NO_ERROR, mST->updateTexImage());
ASSERT_EQ(NO_ERROR, mST->updateTexImage());
glClearColor(0.2, 0.2, 0.2, 0.2);
glClear(GL_COLOR_BUFFER_BIT);
glViewport(0, 0, texWidth, texHeight);
drawTexture();
EXPECT_TRUE(checkPixel( 0, 0, 153, 153, 153, 153));
EXPECT_TRUE(checkPixel(63, 0, 153, 153, 153, 153));
EXPECT_TRUE(checkPixel(63, 15, 153, 153, 153, 153));
EXPECT_TRUE(checkPixel( 0, 15, 153, 153, 153, 153));
EXPECT_TRUE(checkPixel(24, 4, 255, 0, 0, 255));
EXPECT_TRUE(checkPixel(25, 5, 153, 153, 153, 153));
EXPECT_TRUE(checkPixel(23, 3, 153, 153, 153, 153));
EXPECT_TRUE(checkPixel(45, 13, 153, 153, 153, 153));
EXPECT_TRUE(checkPixel(12, 8, 153, 153, 153, 153));
}
TEST_F(SurfaceTextureGLToGLTest, TexturingFromUserSizedGLFilledBuffer) {
enum { texWidth = 64 };
enum { texHeight = 64 };
// This test requires 3 buffers to complete run on a single thread.
mST->setDefaultMaxBufferCount(3);
// Set the user buffer size.
native_window_set_buffers_user_dimensions(mANW.get(), texWidth, texHeight);
// Do the producer side of things
EXPECT_TRUE(eglMakeCurrent(mEglDisplay, mProducerEglSurface,
mProducerEglSurface, mProducerEglContext));
ASSERT_EQ(EGL_SUCCESS, eglGetError());
// This is needed to ensure we pick up a buffer of the correct size.
eglSwapBuffers(mEglDisplay, mProducerEglSurface);
glClearColor(0.6, 0.6, 0.6, 0.6);
glClear(GL_COLOR_BUFFER_BIT);
glEnable(GL_SCISSOR_TEST);
glScissor(4, 4, 1, 1);
glClearColor(1.0, 0.0, 0.0, 1.0);
glClear(GL_COLOR_BUFFER_BIT);
eglSwapBuffers(mEglDisplay, mProducerEglSurface);
// Do the consumer side of things
EXPECT_TRUE(eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface,
mEglContext));
ASSERT_EQ(EGL_SUCCESS, eglGetError());
glDisable(GL_SCISSOR_TEST);
// Skip the first frame, which was empty
ASSERT_EQ(NO_ERROR, mST->updateTexImage());
ASSERT_EQ(NO_ERROR, mST->updateTexImage());
glClearColor(0.2, 0.2, 0.2, 0.2);
glClear(GL_COLOR_BUFFER_BIT);
glViewport(0, 0, texWidth, texHeight);
drawTexture();
EXPECT_TRUE(checkPixel( 0, 0, 153, 153, 153, 153));
EXPECT_TRUE(checkPixel(63, 0, 153, 153, 153, 153));
EXPECT_TRUE(checkPixel(63, 63, 153, 153, 153, 153));
EXPECT_TRUE(checkPixel( 0, 63, 153, 153, 153, 153));
EXPECT_TRUE(checkPixel( 4, 4, 255, 0, 0, 255));
EXPECT_TRUE(checkPixel( 5, 5, 153, 153, 153, 153));
EXPECT_TRUE(checkPixel( 3, 3, 153, 153, 153, 153));
EXPECT_TRUE(checkPixel(45, 52, 153, 153, 153, 153));
EXPECT_TRUE(checkPixel(12, 36, 153, 153, 153, 153));
}
/*
Tests that the pixels inside rect in image all have the given color.
*/
bool GuiTester::isFilled(const QImage image, const QRect &rect, const QColor &color)
{
for (int y = rect.top(); y <= rect.bottom(); ++y)
for (int x = rect.left(); x <= rect.right(); ++x) {
const QColor pixel = image.pixel(x, y);
if (checkPixel(pixel, color) == false) {
// qDebug()<< "Wrong pixel value at" << x << y << pixel.red() << pixel.green() << pixel.blue();
return false;
}
}
return true;
}
/*
Tests that stuff is painted to the pixels inside rect.
This test fails if any lines in the given direction have pixels
of only one color.
*/
bool GuiTester::isContent(const QImage image, const QRect &rect, Directions directions)
{
if (directions & Horizontal) {
for (int y = rect.top(); y <= rect.bottom(); ++y) {
QColor currentColor = image.pixel(rect.left(), y);
bool fullRun = true;
for (int x = rect.left() + 1; x <= rect.right(); ++x) {
if (checkPixel(image.pixel(x, y), currentColor) == false) {
fullRun = false;
break;
}
}
if (fullRun) {
// qDebug() << "Single-color line at horizontal line " << y << currentColor;
return false;
}
}
return true;
}
if (directions & Vertical) {
for (int x = rect.left(); x <= rect.right(); ++x) {
QRgb currentColor = image.pixel(x, rect.top());
bool fullRun = true;
for (int y = rect.top() + 1; y <= rect.bottom(); ++y) {
if (checkPixel(image.pixel(x, y), currentColor) == false) {
fullRun = false;
break;
}
}
if (fullRun) {
// qDebug() << "Single-color line at vertical line" << x << currentColor;
return false;
}
}
return true;
}
return false; // shut the compiler up.
}
/**
* @brief conv2d methods defines a convolution operations
* @param _input
* @param _kernel
* @param dst
*/
void conv2d(Mat _input,Mat _kernel,Mat &_out)
{
_image_height=_input.rows;
_image_width =_input.cols;
_kernel_height=_kernel.rows;
_kernel_width=_kernel.cols;
_image_channels=_input.channels ();
_kernel_channels=_kernel.channels ();
//dst.create (_image_height,_image_width,_input.type ());
for(int y=0;y<_image_height;y++)
{
for(int x=0;x<_image_width;x++)
{
//performs computation for pixels in the valid range
Point p=Point(x,y);
//local variable used to store convolution sum
float value=0;
//loop over the rows of the pixel neighborhood
//loop over the columns of the pixels neighborhood
for(int i=0;i<_kernel_height;i++)
for(int j=0;j<_kernel_width;j++)
{
Point pixel=Point(y+i-(_kernel_height/2),(x+j-(_kernel_width/2)));
//condition defines pixels lying within the image borders
bool flag=checkPixel (pixel);
if(flag==true)
{
T val=getPixelValue(_input,pixel);
value=value+val;
}
}
//setting the result in the destination matrix
setPixelValue (_out,Point(x,y),value);
}
}
}
TArray<FVector> PrivateLeapImage::TrackFromLeapImage(const int32 SrcWidth, const int32 SrcHeight, uint8* imageBuffer, const uint8 brightnessThresholdIn, const uint8 brightnessThresholdOut)
{
// Initialize search
uint8* SrcPtr = NULL;
FVector blob;
int stackLimit;
TArray<FVector> blobs2D;
std::vector<uint8> checkPixel(SrcWidth*SrcHeight);
for (int32 x = 0; x < SrcHeight * SrcWidth; x++)
checkPixel[x] = 0;
pixelsFound = 0;
pixelLimit = 400;
uint8 Value;
int32 blobIndex = -1;
for (int32 y = 0; y<SrcHeight; y++)
{
// DestPtr = &MipData[(SrcHeight - 1 - y) * SrcWidth * sizeof(uint8)];
for (int32 x = 0; x<SrcWidth; x++)
{
SrcPtr = (&imageBuffer[y * SrcWidth + x]);
Value = *SrcPtr;
if ((Value > brightnessThresholdIn) && (checkPixel[y * SrcWidth + x] == 0)) {
pixelsFound = 0;
stackLimit = 1;
blob = FindBlob(SrcWidth, SrcHeight, y * SrcWidth + x, checkPixel, 0, imageBuffer, &stackLimit, brightnessThresholdIn, brightnessThresholdOut);
if (stackLimit == 2) {
UE_LOG(LeapPluginLog, Warning, TEXT("Blob too large!"));
}
if ((blob != FVector(0.f, 0.f, 0.f)) && (stackLimit == 1)) {
blobIndex++;
blobs2D.Add(FVector(-blob.X / blob.Z, -blob.Y / blob.Z, 1.f));
}
}
}
}
return blobs2D;
}
int main()
{
int arrayTwo[25344],temp2[25344],Npixels=25344;
uchar numbers[25344];
int indices[25344];
int pixelClass[144][176];
int *temp3;
uchar *arrayOne;
temp3 = (int*)pixelClass;
//initialize indices
for (int i=0;i<25344;i++)
{
indices[i]=i;
temp3[i]=0;
}
//read image
Mat image=imread("distance4.png",0);
cvtColor(image,image2,CV_GRAY2RGB);
//merge sort pixel depth values
arrayOne = image.data;
originalImage= image.data;
for (int i=0;i<25344;i++)
{
numbers[i]=arrayOne[i];
}
mergeSort(numbers,indices,arrayTwo, temp2, 25344);
/*
for (int i = 0; i < 25344; i++)
{
{//cout<<"ha"<<i<<" "<<indices[i]<<" ";
cout<<int(numbers[i])<<" ";}
}
*/
int xmax,xmin,ymax,ymin,zmax,zmin,objectNo,j2;
objectNo=1;
//run through pixels considering the closest pixel first (check this)
for (int i=0;i<Npixels;i++)
{
//if pixel is not classified as object yet, seed the pixel
xmax=0;xmin=imageWidth-1;ymax=0;ymin=imageHeight-1;zmax=0;zmin=255,j2=0;
//if (i>25270) {cout<<"man"<<indices[i]/imageWidth<<" "<<indices[i]%imageWidth;cin>>temp2[2];}
if (pixelClass[indices[i]/imageWidth][indices[i]%imageWidth]==0 && numbers[i]<thresh2 && numbers[i]>thresh3)
{
//cout<<objectNo<<" "<<indices[i]%imageWidth<<" "<<indices[i]/imageWidth<<" "<<i;cin>>temp2[2];
checkPixel(indices[i]%imageWidth,indices[i]/imageWidth,pixelClass,xmax,xmin,ymax,ymin,zmax,zmin,objectNo,j2);
//Store details of segmented object location,width,hieght and depth of bb
objects[objectNo][0]=xmin;objects[objectNo][1]=xmax;objects[objectNo][2]=ymin;objects[objectNo][3]=ymax;
objects[objectNo][4]=zmin;objects[objectNo][5]=zmax;
if (j2>1500)
{
//cout<<xmin<<" ";
objectNo++;
rectangle(image2, cvPoint(xmin,ymin), cvPoint(xmax,ymax), CV_RGB( rand()&255, rand()&255, rand()&255 ), 1);
//imwrite("answer.bmp",image2);cin>>temp2[2];
}
}
}
imwrite("answer.bmp",image2);
return 0;
}//end main2
TEST_F(SurfaceTextureGLToGLTest, TexturingFromGLFilledRGBABufferPow2) {
const int texWidth = 64;
const int texHeight = 64;
mST->setDefaultBufferSize(texWidth, texHeight);
// This test requires 3 buffers to complete run on a single thread.
mST->setDefaultMaxBufferCount(3);
// Do the producer side of things
EXPECT_TRUE(eglMakeCurrent(mEglDisplay, mProducerEglSurface,
mProducerEglSurface, mProducerEglContext));
ASSERT_EQ(EGL_SUCCESS, eglGetError());
// This is needed to ensure we pick up a buffer of the correct size.
eglSwapBuffers(mEglDisplay, mProducerEglSurface);
glClearColor(0.6, 0.6, 0.6, 0.6);
glClear(GL_COLOR_BUFFER_BIT);
glEnable(GL_SCISSOR_TEST);
glScissor(4, 4, 4, 4);
glClearColor(1.0, 0.0, 0.0, 1.0);
glClear(GL_COLOR_BUFFER_BIT);
glScissor(24, 48, 4, 4);
glClearColor(0.0, 1.0, 0.0, 1.0);
glClear(GL_COLOR_BUFFER_BIT);
glScissor(37, 17, 4, 4);
glClearColor(0.0, 0.0, 1.0, 1.0);
glClear(GL_COLOR_BUFFER_BIT);
eglSwapBuffers(mEglDisplay, mProducerEglSurface);
// Do the consumer side of things
EXPECT_TRUE(eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface,
mEglContext));
ASSERT_EQ(EGL_SUCCESS, eglGetError());
glDisable(GL_SCISSOR_TEST);
// Skip the first frame, which was empty
ASSERT_EQ(NO_ERROR, mST->updateTexImage());
ASSERT_EQ(NO_ERROR, mST->updateTexImage());
glClearColor(0.2, 0.2, 0.2, 0.2);
glClear(GL_COLOR_BUFFER_BIT);
glViewport(0, 0, texWidth, texHeight);
drawTexture();
EXPECT_TRUE(checkPixel( 0, 0, 153, 153, 153, 153));
EXPECT_TRUE(checkPixel(63, 0, 153, 153, 153, 153));
EXPECT_TRUE(checkPixel(63, 63, 153, 153, 153, 153));
EXPECT_TRUE(checkPixel( 0, 63, 153, 153, 153, 153));
EXPECT_TRUE(checkPixel( 4, 7, 255, 0, 0, 255));
EXPECT_TRUE(checkPixel(25, 51, 0, 255, 0, 255));
EXPECT_TRUE(checkPixel(40, 19, 0, 0, 255, 255));
EXPECT_TRUE(checkPixel(29, 51, 153, 153, 153, 153));
EXPECT_TRUE(checkPixel( 5, 32, 153, 153, 153, 153));
EXPECT_TRUE(checkPixel(13, 8, 153, 153, 153, 153));
EXPECT_TRUE(checkPixel(46, 3, 153, 153, 153, 153));
EXPECT_TRUE(checkPixel(30, 33, 153, 153, 153, 153));
EXPECT_TRUE(checkPixel( 6, 52, 153, 153, 153, 153));
EXPECT_TRUE(checkPixel(55, 33, 153, 153, 153, 153));
EXPECT_TRUE(checkPixel(16, 29, 153, 153, 153, 153));
EXPECT_TRUE(checkPixel( 1, 30, 153, 153, 153, 153));
EXPECT_TRUE(checkPixel(41, 37, 153, 153, 153, 153));
EXPECT_TRUE(checkPixel(46, 29, 153, 153, 153, 153));
EXPECT_TRUE(checkPixel(15, 25, 153, 153, 153, 153));
EXPECT_TRUE(checkPixel( 3, 52, 153, 153, 153, 153));
}
/**
* Add error checking.
*
* orig - buffered tiff elevation model
* minNorthing - ulNorthing
* minEasting - ulEasting
*/
int findTreeTops(float **orig, double * mpsData, int imageLength, int imageWidth, double ulEasting, double ulNorthing,
int run_range3, float range3_min, float range3_max,
int run_range5, float range5_min, float range5_max,
int run_range7, float range7_min, float range7_max,
int run_range9, float range9_min, float range9_max,
int run_range11, float range11_min, float range11_max,
SHPHandle hshp, DBFHandle hdbf, int smooth_type, int add_noise)
{
puts("findTreeTops");
int i, j, length, width;
float **gridded;
// dimensions of gridded
length = imageLength + 4;
width = imageWidth + 4;
gridded = smoothAndPad(orig, imageLength, imageWidth, smooth_type);
if(!gridded)
return 0;
if (add_noise) {
for(i = 1; i < length - 1; i++)
for(j = 1; j < width - 1 ; j++)
gridded[i][j] += box_muller(0,1)*0.001;
}
//determine if necessary
extrapolateEdges(gridded, length, width);
puts("Checking pixels.");
for(j = 2; j < width-2; j++)//each col
{
for(i = 2; i < length-2; i++) //each row
{
float height = gridded[i][j];
// 3 = 1 + 2
if(i >= 3 && j >= 3 && i < length-3 && j < width-3 && run_range3 && height >= range3_min && height < range3_max)
{
checkPixel(gridded, orig, i, j, 3, 9, mpsData, ulEasting, ulNorthing, hshp, hdbf);
}
// 4 = 2 + 2 = half_window+buffer
else if(i >= 4 && j >= 4 && i < length-4 && j < width-4 && run_range5 && height >= range5_min && height < range5_max)
{
checkPixel(gridded, orig, i, j, 5, 25, mpsData, ulEasting, ulNorthing, hshp, hdbf);
}
else if(i >= 5 && j >= 5 && i < length-5 && j < width-5 && run_range7 && height >= range7_min && height < range7_max)
{
checkPixel(gridded, orig, i, j, 7, 49, mpsData, ulEasting, ulNorthing, hshp, hdbf);
}
else if(i >= 6 && j >= 6 && i < length-6 && j < width-6 && run_range9 && height >= range9_min && height < range9_max)
{
checkPixel(gridded, orig, i, j, 9, 81, mpsData, ulEasting, ulNorthing, hshp, hdbf);
}
else if(i >= 7 && j >= 7 && i < length-7 && j < width-7 && run_range11 && height >= range11_min && height < range11_max)
{
checkPixel(gridded, orig, i, j, 11, 121, mpsData, ulEasting, ulNorthing, hshp, hdbf);
}
}
}
freef2d(gridded, length);
freef2d(orig, imageLength);
return 1;
}
int map (struct DIVERSsysteme *systeme,struct typeFORthreads *online,struct PACKbouton *bouton ,struct PACKobjet *objet,
struct PERSO *perso,struct DIVERSinventaire *inventaire,struct DIVERSdeplacement *deplacement,
struct DIVERStemps *temps,struct DIVERSui *ui,struct DIVERSchat *chat,struct DIVERScraft *craft,
struct PACKrecompense *recompense,struct typeFORevent *FORevent,struct TIR *TIR)
{
int index;
chargement(systeme);
#if CHEAT == 1
for (index = 0 ; index < TAILLESAC ; index++)
{
videemplacement(&FORevent->objet->sac1[index]);
}
for (index = 0 ; index < 10 ; index++)
{
insertionsac(objet, 0);
insertionsac(objet, 2);
insertionsac(objet, 7);
}
insertionsac(objet, 3);
insertionsac(objet, 1);
insertionsac(objet, 4);
insertionsac(objet, 5);
insertionsac(objet, 6);
insertionsac(objet, 8);
insertionsac(objet, 9);
#endif
struct DONJON dj0;
initdonjon(&dj0, systeme);
LoadDonjon(&dj0, "dj0");
systeme->djisloaded = true;
online->jeuxACTIF = 1;
for(index = 0 ; index < MAX_JOUEURS ; index++)
{
online->joueurs[index].ppseudo.x = 20000;
online->joueurs[index].ppseudo.y = 20000;
online->joueurs[index].position.w = 0;
online->joueurs[index].position.h = 0;
}
checkandrefreshstuff(perso, objet, systeme, ui);
checkinventaire(objet, inventaire);
glMatrixMode( GL_PROJECTION );
glLoadIdentity();
gluOrtho2D(0,screenw,0,screenh);
glMatrixMode( GL_MODELVIEW );
glLoadIdentity();
/*#############################################################################################################################################################
##################### Boucle De Jeu ##################### #
######################################################################################################################################################################*/
systeme->continuer = 1;
while (systeme->continuer == 1)
{
temps->tpact = SDL_GetTicks();
if (temps->tpact - temps->tpapr >= 15) /*15 ms*/
{
temps->tpapr = temps->tpact;
temps->i++;
/*sichronisation des données*/
sinchronisation(craft, systeme, online, perso, &dj0);
SyncMob(&dj0, perso);
/*calcul direction joueur client*/
deplacement->direction.direction = directionperso(&deplacement->direction);
/*deplacement*/
checkPixel(&dj0.map, perso, systeme);
move_map(perso, &deplacement->direction, &dj0.origin);
/*gestion des dégats*/
hitboxplayer (&dj0, perso, systeme);
/*recupération coordonées souris*/
SDL_GetMouseState(&systeme->pointeur.pos.x, &systeme->pointeur.pos.y);
systeme->pointeur.pos.y = (systeme->pointeur.pos.y - screenh + systeme->pointeur.pos.h) * -1;
/*gestion de l'ui*/
gestionui(systeme, ui, craft, bouton, chat, inventaire, objet, perso);
/*detection des combats*/
// detectioncombat(monstre, inventaire, ui, deplacement, objet, perso, systeme, recompense, false);
/*gestion des evenement*/
boucleevent(&online->chat.lancermessage, FORevent, TIR);
/*gestion du chat*/
gestionchat(chat, systeme, online);
if (TIR->letirdemander == true)
{
gestiontir(TIR, systeme, perso, &dj0);
}
COMBATgestionprojectile (TIR, &dj0);
/*##################################################################################################################################################################################
##################### AFFICHAGE ##################### #
##################################################################################################################################################################################*/
/*effacage de l'écran*/
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) ;
/*affichage de la carte*/
draw_pict(&dj0.map.pict);
for (index=0 ; index<dj0.nombremonstre ; index++)
{
if(dj0.mob[index].BarreDeVie->life > 0)
{
turn_draw_hookpict(dj0.mob[index].angle, &dj0.mob[index].hookpict, &dj0.map.pict.pos);
CalculerBarreDeVie(dj0.mob[index].BarreDeVie->baselife , dj0.mob[index].BarreDeVie->life, 68);
setPos2rect(&dj0.mob[index].BarreDeVie->pBG, dj0.mob[index].hookpict.pict.pos.x-1 + ((dj0.mob[index].hookpict.pict.pos.w-68)/2),
dj0.mob[index].hookpict.pict.pos.y + dj0.mob[index].hookpict.pict.pos.h+4);
setPos4(&dj0.mob[index].BarreDeVie->pbarre, dj0.mob[index].hookpict.pict.pos.x + ((dj0.mob[index].hookpict.pict.pos.w-68)/2),
dj0.mob[index].hookpict.pict.pos.y + dj0.mob[index].hookpict.pict.pos.h+5,
CalculerBarreDeVie(dj0.mob[index].BarreDeVie->baselife , dj0.mob[index].BarreDeVie->life, 68), 5);
draw(systeme->BGnoir, &dj0.mob[index].BarreDeVie->pBG);
draw(systeme->BGblanc, &dj0.mob[index].BarreDeVie->pbarre);
}
}
/*affichage des joueurs*/
afficherJOUEURS(perso, deplacement, systeme, online, temps);
BattleDraw_Projectile(TIR, &dj0);
/*affichage du chat*/
if (ui->chat_open == true)
{
afficherCHAT(chat, ui, online->chat.lenbuffer, systeme);
}
/*affichage de l'inventaire*/
else if (ui->inventaire_open == true)
{
afficherINVENTAIRE(inventaire, ui, objet, systeme);
}
/*affichage de l'interface utilisateur*/
afficherUI(online->isonline, ui, bouton, temps, perso, inventaire, systeme, recompense, objet);
/*affichage de l'interface de crafting*/
if (ui->craft_open == true)
{
afficherCRAFT(craft, ui, bouton, objet, inventaire, systeme);
}
/*affichage du pointeur*/
afficherPOINTEUR(systeme, objet);
/*rendu éran*/
glFlush();
glFinish();
SDL_GL_SwapWindow(systeme->screen);
}
else
{
SDL_Delay(5);
}
/*###########################################################################################################################
##################### Frame Par Secondes ##################### #
###########################################################################################################################*/
if (temps->tpact - temps->tpap >= 1000)
{
temps->temptotal++;
/*if it's the first second of this player*/
if (temps->temptotal == 5)
{
char texte[2548] = "\nprisonnier : \n salut ... \n ça tombe bien,\n j'avais besoin d'un coup de main !\n tiens ! prend ce lance pierre et vas nous chercher\nquelques rat !\n\n\n\n\n\n\n\n\n\n\n\n\n\n APPUIE SUR ENTRÉE POUR CONTINUER";
ui->dialogue_text.texture = fenetredialogue(screenw*0.4, screenh*0.8, &ui->dialogue_back.pos, &ui->dialogue_text.pos, texte, BLANC, systeme);
ui->dialogueactif = 1;
insertionsac(objet, 3);
}
if (temps->temptotal - temps->oldipourregen >= 3)
{
if (perso->life < perso->lifemax)
{
perso->life += REGEN;
perso->life += perso->regenlife;
if (perso->life > perso->lifemax)
{
perso->life = perso->lifemax;
}
temps->oldipourregen = temps->temptotal;
}
}
else
{
if (perso->life < perso->lifemax)
{
perso->life += perso->regenlife;
if (perso->life > perso->lifemax)
{
perso->life = perso->lifemax;
}
}
}
if (temps->temptotal - temps->tpspoursave >= 30)
{
sauvegardetout(systeme->sauvegarde, dj0.map.pict.pos, perso, temps->temptotal, 0, objet->sac1, TAILLESAC, ui);
temps->tpspoursave = temps->temptotal;
}
sprintf(temps->StringI, "IPS => %d", temps->i);
sprintf(perso->slife, "vie : %0.0f/%d", perso->life, perso->lifemax);
sprintf(temps->stringtempstotal, "age du personnage : %dj %dh %dmin %dsec", calcultempsjours(temps->temptotal), calcultempsheures(temps->temptotal), calcultempsminutes(temps->temptotal), calcultempssecondes(temps->temptotal));
temps->fps.texture = imprime (temps->StringI, screenw, BLANC, systeme, NULL, NULL);
perso->tlife.texture = imprime (perso->slife, screenw, BLANC, systeme, NULL, NULL);
temps->temps.texture = imprime (temps->stringtempstotal, screenw, BLANC, systeme, NULL, NULL);
for(index = 0; index < 10 ; index++)
{
if(online->chat.schat[index][0] != '\0')
{
chat->pstringchat[index].y = (screenh*0.5)+(online->chat.poschat[index]*(screenh*0.047));
SDL_DestroyTexture(chat->tstringchat[index]);
// chat->tstringchat[index] = imprime(online->chat.schat[index], screenw, BLANC, systeme, NULL, NULL);
}
}
temps->i = 0;
temps->tpap = temps->tpact;
}
}
/*###########################################################################################################################
#
##################### Fin de Fonction ##################### #
#
###########################################################################################################################*/
sauvegardetout(systeme->sauvegarde, dj0.map.pict.pos, perso, temps->temptotal, 0, objet->sac1, TAILLESAC, ui);
return 1;
}
void runTest()
{
// Firstly ensure that no errors have been hit.
EXPECT_GL_NO_ERROR();
GLint viewportSize[4];
glGetIntegerv(GL_VIEWPORT, viewportSize);
// Clear to green. Might be a scissored clear, if scissorSize != window size
glClearColor(0, 1, 0, 1);
glClear(GL_COLOR_BUFFER_BIT);
// Draw a red quad centered in the middle of the viewport, with dimensions 25% of the size of the viewport.
drawQuad(mProgram, "position", 0.5f, 0.25f);
GLint centerViewportX = viewportSize[0] + (viewportSize[2] / 2);
GLint centerViewportY = viewportSize[1] + (viewportSize[3] / 2);
GLint redQuadLeftSideX = viewportSize[0] + viewportSize[2] * 3 / 8;
GLint redQuadRightSideX = viewportSize[0] + viewportSize[2] * 5 / 8;
GLint redQuadTopSideY = viewportSize[1] + viewportSize[3] * 3 / 8;
GLint redQuadBottomSideY = viewportSize[1] + viewportSize[3] * 5 / 8;
// The midpoint of the viewport should be red.
checkPixel(centerViewportX, centerViewportY, true);
// Pixels just inside the red quad should be red.
checkPixel(redQuadLeftSideX, redQuadTopSideY, true);
checkPixel(redQuadLeftSideX, redQuadBottomSideY - 1, true);
checkPixel(redQuadRightSideX - 1, redQuadTopSideY, true);
checkPixel(redQuadRightSideX - 1, redQuadBottomSideY - 1, true);
// Pixels just outside the red quad shouldn't be red.
checkPixel(redQuadLeftSideX - 1, redQuadTopSideY - 1, false);
checkPixel(redQuadLeftSideX - 1, redQuadBottomSideY, false);
checkPixel(redQuadRightSideX, redQuadTopSideY - 1, false);
checkPixel(redQuadRightSideX, redQuadBottomSideY, false);
// Pixels just within the viewport shouldn't be red.
checkPixel(viewportSize[0], viewportSize[1], false);
checkPixel(viewportSize[0], viewportSize[1] + viewportSize[3] - 1, false);
checkPixel(viewportSize[0] + viewportSize[2] - 1, viewportSize[1], false);
checkPixel(viewportSize[0] + viewportSize[2] - 1, viewportSize[1] + viewportSize[3] - 1, false);
}
