void GameLayer::enterRoomCallback()
{
CCLog("select room----------------- %d",_dataManager->ret);
switch (_dataManager->ret) {
case 0:
{
if (NULL == _gameLayer)
{
_gameLayer = KCGameLayer::create();
_gameLayer->retain();
}
else
{
_gameLayer->initUI();
}
showLayer(_gameLayer);
break;
}
default:
{
_hallLayer->setEnableRoom(true);
switch (_dataManager->err) {
case 0:
{
Alert::create(ALERTTEXT_UNKNOWN)->show();
break;
}
case 1:
{
Alert::create(ALERTTEXT_LEVEL)->show();
exitRoom();
break;
}
case 2:
{ Alert::create(ALERTTEXT_GOLD)->show();
exitRoom();
break;
}
case 3:
{
Alert::create(ALERTTEXT_ROOM)->show();
break;
}
case 4:
{
Alert::create(ALERTTEXT_NO_ROOM)->show();
break;
}
default:
{
break;
}
}
break;
}
}
}
int
main(int argc, char **argv)
{
int ix; /*index for nx*/
int iy; /*index for ny*/
int nx; /*number of sampels in horizon*/
int ny; /*number of sampels in horizon*/
float xmin,xmax;
float ymin,ymax;
float zmin,zmax;
float ***databot; /*data for plotting*/
float ***datatop;
float ***emisbot; /*color on top horizon*/
float ***emistop; /*color right above base horizon*/
float v0;
int verbose; /*if =1 print some useful information*/
float eyez;
int ihz; /*index for interfaces*/
int *ntris; /*number of triangles*/
int nt; /*number of samples in each ray*/
int iray; /*index for nrays*/
int it; /*index for nt*/
int iw,iwf,nwf;
int is,ns; /*number of sources*/
float q0[4];
char *rayfile=""; /*ray file*/
char *wffile="";
char *sttfile="";
FILE *rayfp=NULL;
FILE *wffp=NULL;
FILE *sttfp=NULL;
Layer *horz;
Layer *ray;
Layer *wf;
float vmin=99999.0;
float vmax=0.0;
float tt; /*debugging information in the ray file*/
int itri;
char names[10];
int iflag; /*flag: =1 means ray effective*/
float emission[4];
float tmax=0.0,tmin=FLT_MAX;
float ***stt=NULL;
float **ttt=NULL;
int ntr;
/* hook up getpar */
initargs(argc,argv);
requestdoc(1);
/* get parameters */
if (!getparint("verbose",&verbose)) verbose=0;
/******************************************
Read model parameters from hzfile
******************************************/
fread(&nhz,sizeof(int),1,stdin);
fread(&nx,sizeof(int),1,stdin);
fread(&ny,sizeof(int),1,stdin);
fread(&xmin,sizeof(float),1,stdin);
fread(&xmax,sizeof(float),1,stdin);
fread(&ymin,sizeof(float),1,stdin);
fread(&ymax,sizeof(float),1,stdin);
fread(&zmin,sizeof(float),1,stdin);
fread(&zmax,sizeof(float),1,stdin);
if (verbose)
fprintf(stderr,"xmin=%f\nxmax=%f\nymin=%f\nymax=%f\nzmin=%f\nzmax=%f\n",
xmin,xmax,ymin,ymax,zmin,zmax);
if (getparstring("rayfile",&rayfile))
if ((rayfp=fopen(rayfile,"r"))==NULL)
err("Can not open rayfile %s",rayfile);
if (getparstring("wffile",&wffile))
if ((wffp=fopen(wffile,"r"))==NULL)
err("Can not open wffile %s",wffile);
if (getparstring("sttfile",&sttfile))
if ((sttfp=fopen(sttfile,"r"))==NULL)
err("Can not open sttfile %s",sttfile);
if (!getparfloat("tbs",&tbs)) tbs=0.8;
if (!getparint("hue",&glb_hue)) glb_hue=1; /*1 for glb_hue*/
if (verbose)
warn("nhz=%d, nx=%d, ny=%d\n",nhz,nx,ny);
glb_on_or_off=(enum On_or_Off *)ealloc1int(3*nhz+6);
for (ihz=0;ihz<nhz;ihz++) glb_on_or_off[ihz]=ON;
horz=(Layer *)alloc1float(sizeof(Layer)*(nhz+1));
/*********************************************************
Do not use GLUT_INDEX, which gives no image;
GLUT_SINGLE will cause redrawing every time you retate it;
*********************************************************/
glutInit(&argc, argv);
glutInitWindowSize(768,768);
glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH);
glutCreateWindow("viewer3");
glutDisplayFunc(redraw);
glutIdleFunc(NULL);
if (!getparfloat("q",q0)){
q0[0]=-0.6;
q0[1]=0.05;
q0[2]=-0.06;
q0[3]=0.8;
}
checkpars();
normalize_quat(q0);
curquat[0]=q0[0];
curquat[1]=q0[1];
curquat[2]=q0[2];
curquat[3]=q0[3];
glutReshapeFunc(myReshape);
glutVisibilityFunc(vis);
glutMouseFunc(mouse);
glutMotionFunc(motion);
glutCreateMenu(controlLights);
glutAddMenuEntry("Quit",-1);
glutAddMenuEntry("Full Screen",0);
glutAddMenuEntry("White/Color Rays",1);
glutAddMenuEntry("Plot Rays",2);
glutAddMenuEntry("Surface Traveltimes",3);
glutAddMenuEntry("Wired or Solid WFs",4);
glutAddMenuEntry("Plot Wavefronts",5);
glutAddMenuEntry("TRI or TETRA or LAYER or HORZ",6);
for (ihz=0;ihz<nhz;ihz++) {
sprintf(names,"Layer %d",ihz+1);
glutAddMenuEntry(names,ihz+7);
}
glutAttachMenu(GLUT_RIGHT_BUTTON);
glShadeModel(GL_SMOOTH);
glEnable(GL_DEPTH_TEST);
glEnable(GL_LIGHTING);
eyez=25;
glMatrixMode(GL_PROJECTION);
gluPerspective(
40.0, /*fovy: view angle in y direction*/
1.0, /*aspect: ratio of width (x) to y (height)*/
eyez-DIAMETER, /*near clipping plane*/
eyez+DIAMETER); /*far clipping plane*/
glMatrixMode(GL_MODELVIEW);
gluLookAt(
0.0, 0.0, eyez, /*(eyex,eyey,eyez): the eye position*/
0.0, 0.0, 0.0, /*(centerx,centery,centerz): the center*/
0.0, 1.0, 0.0); /*(upx,upy,upz): the up direction*/
glPushMatrix();
/*the order that tetramod uses is like this*/
for (ihz=0;ihz<nhz;ihz++) {
fprintf(stderr,"reading horizon information %d\n",ihz);
/**********************************************************
input the horizon information from file hzfile:
**********************************************************/
horz[ihz].x=ealloc2float(nx,ny);
horz[ihz].y=ealloc2float(nx,ny);
horz[ihz].z=ealloc2float(nx,ny);
horz[ihz].v0=ealloc2float(nx,ny);
horz[ihz].v1=ealloc2float(nx,ny);
fprintf(stderr,"read horz[%d].x...\n",ihz);
if (fread(horz[ihz].x[0],sizeof(float),nx*ny,
stdin)!=nx*ny)
err("Can not read x to stdin");
fprintf(stderr,"read horz[%d].y...\n",ihz);
if (fread(horz[ihz].y[0],sizeof(float),nx*ny,
stdin)!=nx*ny)
err("Can not read y to stdin");
fprintf(stderr,"read horz[%d].z...\n",ihz);
if (fread(horz[ihz].z[0],sizeof(float),nx*ny,
stdin)!=nx*ny)
err("Can not read z to stdin");
fprintf(stderr,"read horz[%d].v0...\n",ihz);
if (fread(horz[ihz].v0[0],sizeof(float),nx*ny,stdin)!=
nx*ny)
err("Can not read v0 to stdin");
fprintf(stderr,"read horz[%d].v1...\n",ihz);
if (fread(horz[ihz].v1[0],sizeof(float),nx*ny,stdin)!=
nx*ny)
err("Can not read v1 to stdin");
for (iy=0;iy<ny;iy++) {
for (ix=0;ix<nx;ix++) {
vmin=MIN(vmin,horz[ihz].v0[iy][ix]);
vmax=MAX(vmax,horz[ihz].v0[iy][ix]);
vmin=MIN(vmin,horz[ihz].v1[iy][ix]);
vmax=MAX(vmax,horz[ihz].v1[iy][ix]);
}
}
}
if (verbose)
fprintf(stderr,"vmin=%f, vmax=%f\n",vmin,vmax);
horz[nhz].x=ealloc2float(nx,ny);
horz[nhz].y=ealloc2float(nx,ny);
horz[nhz].z=ealloc2float(nx,ny);
fprintf(stderr,"assign horz[%d].x,y,z\n",nhz);
for (ix=0;ix<nx;ix++) {
for (iy=0;iy<ny;iy++) {
horz[nhz].x[iy][ix]=horz[nhz-1].x[iy][ix];
horz[nhz].y[iy][ix]=horz[nhz-1].y[iy][ix];
horz[nhz].z[iy][ix]=zmax;
}
}
databot=ealloc3float(3,nx,ny);
emisbot=ealloc3float(4,nx,ny);
datatop=ealloc3float(3,nx,ny);
emistop=ealloc3float(4,nx,ny);
for (ihz=0;ihz<nhz;ihz++) {
fprintf(stderr,"assigning datatop for ihz=%d\n",ihz);
for (ix=0;ix<nx;ix++) {
for (iy=0;iy<ny;iy++) {
datatop[iy][ix][0]=(
(horz[ihz].x[iy][ix]-xmin)/
(xmax-xmin)-0.5)*DIAMETER;
datatop[iy][ix][1]=-(
(horz[ihz].y[iy][ix]-ymin)/
(ymax-ymin)-0.5)*DIAMETER;
datatop[iy][ix][2]=(
(horz[ihz].z[iy][ix]-zmin)/
(zmax-zmin)-0.5)*DIAMETER;
v0=horz[ihz].v0[iy][ix];
vEmission(v0,vmin,vmax,emistop[iy][ix]);
}
}
fprintf(stderr,"assigning databot for ihz=%d\n",ihz);
for (ix=0;ix<nx;ix++) {
for (iy=0;iy<ny;iy++) {
databot[iy][ix][0]=(
(horz[ihz+1].x[iy][ix]-xmin)
/(xmax-xmin)-0.5)*DIAMETER;
databot[iy][ix][1]=-(
(horz[ihz+1].y[iy][ix]-ymin)
/(ymax-ymin)-0.5)*DIAMETER;
databot[iy][ix][2]=(
(horz[ihz+1].z[iy][ix]-zmin)
/(zmax-zmin)-0.5)*DIAMETER;
v0=horz[ihz].v1[iy][ix];
vEmission(v0,vmin,vmax,emisbot[iy][ix]);
}
}
showLayer(ihz,databot,datatop,nx,ny,emisbot,emistop);
showHorz(ihz,datatop,nx,ny,emistop);
showTetra(ihz,databot,datatop,nx,ny,emisbot,emistop);
showTri(ihz,datatop,nx,ny,emistop);
}
free3float(databot);
free3float(datatop);
free3float(emisbot);
free3float(emistop);
/*******************************************************************
The ray positions are generated by sutetraray, named by rayfile.
This part will be ignored if rayfile not specified.
********************************************************************/
if (rayfp!=NULL) {
fscanf(rayfp,
"%d =Number of shots\n",&ns);
fprintf(stderr,"ns=%d\n",ns);
if (ns<=0 || ns>100) {
ns=0;
rayfp=NULL;
}
ray=(Layer *)alloc1float(sizeof(Layer)*ns);
tmax=0.0;
for (is=0;is<ns;is++) {
fscanf(rayfp,
"%d =Maximum number of segments\n",&nt);
fprintf(stderr,"%d =Maximum number of segments\n",nt);
fscanf(rayfp,
"%d =Number of rays\n",&ray[is].nrays);
fprintf(stderr,"%d =Number of rays\n",ray[is].nrays);
ray[is].x=ealloc2float(ray[is].nrays,nt);
ray[is].y=ealloc2float(ray[is].nrays,nt);
ray[is].z=ealloc2float(ray[is].nrays,nt);
ray[is].v0=ealloc2float(ray[is].nrays,nt);
ray[is].nseg=ealloc1int(ray[is].nrays);
for (iray=0;iray<ray[is].nrays;iray++) {
fscanf(rayfp,"%d=nseg %f=ttotal\n",&ray[is].nseg[iray],&tt);
if (nt<ray[is].nseg[iray]) err("nt should >=ray[is].nseg[iray]");
for (it=0;it<ray[is].nseg[iray];it++) {
fscanf(rayfp,"%f %f %f %f %f\n",
&ray[is].x[it][iray],
&ray[is].y[it][iray],
&ray[is].z[it][iray],
&ray[is].v0[it][iray],&tt);
tmax=MAX(tmax,ray[is].v0[it][iray]);
}
ray[is].z[ray[is].nseg[iray]-1][iray]=
MAX(0.001,ray[is].z[ray[is].nseg[iray]-1][iray]);
for (it=0;it<ray[is].nseg[iray];it++) {
ray[is].x[it][iray]=((ray[is].x[it][iray]-xmin)/
(xmax-xmin)-0.5)*DIAMETER;
ray[is].y[it][iray]=-((ray[is].y[it][iray]-ymin)/
(ymax-ymin)-0.5)*DIAMETER;
ray[is].z[it][iray]=((ray[is].z[it][iray]-zmin)/
(zmax-zmin)-0.5)*DIAMETER;
}
}
}
fclose(rayfp);
/*white rays*/
glNewList(nhz*4+3,GL_COMPILE);
emission[0]=emission[1]=emission[2]=emission[3]=1.0;
glMaterialfv(GL_FRONT_AND_BACK,GL_EMISSION,emission);
for (is=0;is<ns;is++) {
for (iray=0;iray<ray[is].nrays;iray++) {
iflag=0;
glBegin(GL_LINE_STRIP);
for (it=0;it<ray[is].nseg[iray];it++) {
if (fabs(ray[is].x[it][iray])<RADIUS &&
fabs(ray[is].y[it][iray])<RADIUS &&
fabs(ray[is].z[it][iray])<RADIUS) {
glVertex3f(ray[is].x[it][iray],ray[is].y[it][iray],
ray[is].z[it][iray]);
iflag=1;
} else if (iflag) break; /*once good, now bad*/
}
glEnd();
}
}
glEndList();
/*colored rays*/
glNewList(nhz*4+4,GL_COMPILE);
for (is=0;is<ns;is++) {
for (iray=0;iray<ray[is].nrays;iray++) {
iflag=0;
glBegin(GL_LINE_STRIP);
for (it=0;it<ray[is].nseg[iray];it++) {
if (fabs(ray[is].x[it][iray])<RADIUS &&
fabs(ray[is].y[it][iray])<RADIUS &&
fabs(ray[is].z[it][iray])<RADIUS) {
tEmission(
ray[is].v0[it][iray],
0.0, /*tmin*/
tmax,
emission);
glMaterialfv(GL_FRONT_AND_BACK,GL_EMISSION,emission);
glVertex3f(
ray[is].x[it][iray],
ray[is].y[it][iray],
ray[is].z[it][iray]);
iflag=1;
} else if (iflag) break; /*once good, now bad*/
}
glEnd();
}
}
glEndList();
}
/*************************************************************
Plot the wavefront if it is given. If the wffile does not
contain effective data, ntris may be wild. In this case, do
thing about the wavefront.
*************************************************************/
if (wffp!=NULL) {
fscanf(wffp,"%d = nwf2dump\n",&nwf);
fprintf(stderr,"nwf2dump=%d\n",nwf);
if (nwf>200) wffp=NULL;
}
if (wffp!=NULL) {
emission[0]=1.0;
emission[1]=1.0;
emission[2]=0.0;
emission[3]=1.0;
wf=(Layer *)alloc1float(sizeof(Layer)*nwf);
ntris=ealloc1int(sizeof(int)*nwf);
for (iwf=0;iwf<nwf;iwf++) {
if (1!=fscanf(wffp,"%d = ntris\n",&ntris[iwf])) {
nwf=iwf;
break;
}
if (ntris[iwf]==0) {
nwf=iwf;
break;
}
if (verbose)
warn("ntris=%d of nwf=%d\n",ntris[iwf],nwf);
wf[iwf].x=ealloc2float(3,ntris[iwf]);
wf[iwf].y=ealloc2float(3,ntris[iwf]);
wf[iwf].z=ealloc2float(3,ntris[iwf]);
for (it=0;it<ntris[iwf];it++) {
fscanf(wffp,"%f %f %f %f %f %f %f %f %f\n",
wf[iwf].x[it], wf[iwf].y[it], wf[iwf].z[it],
wf[iwf].x[it]+1,wf[iwf].y[it]+1,wf[iwf].z[it]+1,
wf[iwf].x[it]+2,wf[iwf].y[it]+2,wf[iwf].z[it]+2);
}
fprintf(stderr,"Totally read in %d wavefront triangles\n",ntris[iwf]);
for (it=0;it<ntris[iwf];it++) {
for (iw=0;iw<3;iw++) {
wf[iwf].x[it][iw]=((wf[iwf].x[it][iw]-xmin)/
(xmax-xmin)-0.5)*DIAMETER;
wf[iwf].y[it][iw]=-((wf[iwf].y[it][iw]-ymin)/
(ymax-ymin)-0.5)*DIAMETER;
wf[iwf].z[it][iw]=((wf[iwf].z[it][iw]-zmin)/
(zmax-zmin)-0.5)*DIAMETER;
}
}
}
fclose(wffp);
fprintf(stderr,"Click right MB to get menu\n");
fprintf(stderr,"Click left MB and drag to rotate\n");
fprintf(stderr,"Press shift and push left MB to scale\n");
glNewList(nhz*4+6,GL_COMPILE);
glMaterialfv(GL_FRONT_AND_BACK,GL_EMISSION,emission);
for (iwf=0;iwf<nwf;iwf++) {
for (itri=0;itri<ntris[iwf];itri++) {
glBegin(GL_LINE_LOOP);
if (fabs(wf[iwf].x[itri][0])<RADIUS &&
fabs(wf[iwf].y[itri][0])<RADIUS &&
fabs(wf[iwf].z[itri][0])<RADIUS &&
fabs(wf[iwf].x[itri][1])<RADIUS &&
fabs(wf[iwf].y[itri][1])<RADIUS &&
fabs(wf[iwf].z[itri][1])<RADIUS &&
fabs(wf[iwf].x[itri][2])<RADIUS &&
fabs(wf[iwf].y[itri][2])<RADIUS &&
fabs(wf[iwf].z[itri][2])<RADIUS) {
glVertex3f(wf[iwf].x[itri][0],
wf[iwf].y[itri][0],
wf[iwf].z[itri][0]);
glVertex3f(wf[iwf].x[itri][1],
wf[iwf].y[itri][1],
wf[iwf].z[itri][1]);
glVertex3f(wf[iwf].x[itri][2],
wf[iwf].y[itri][2],
wf[iwf].z[itri][2]);
} else {
fprintf(stderr,"warning: some triangles ignored\n");
glEnd();
break;
}
glEnd();
}
}
glEndList();
/*solid wavefronts*/
glNewList(nhz*4+7,GL_COMPILE);
glMaterialfv(GL_FRONT_AND_BACK,GL_EMISSION,emission);
for (iwf=0;iwf<nwf;iwf++) {
for (itri=0;itri<ntris[iwf];itri++) {
glBegin(GL_TRIANGLE_STRIP);
if (fabs(wf[iwf].x[itri][0])<RADIUS &&
fabs(wf[iwf].y[itri][0])<RADIUS &&
fabs(wf[iwf].z[itri][0])<RADIUS &&
fabs(wf[iwf].x[itri][1])<RADIUS &&
fabs(wf[iwf].y[itri][1])<RADIUS &&
fabs(wf[iwf].z[itri][1])<RADIUS &&
fabs(wf[iwf].x[itri][2])<RADIUS &&
fabs(wf[iwf].y[itri][2])<RADIUS &&
fabs(wf[iwf].z[itri][2])<RADIUS) {
glVertex3f(wf[iwf].x[itri][0],
wf[iwf].y[itri][0],
wf[iwf].z[itri][0]);
glVertex3f(wf[iwf].x[itri][1],
wf[iwf].y[itri][1],
wf[iwf].z[itri][1]);
glVertex3f(wf[iwf].x[itri][2],
wf[iwf].y[itri][2],
wf[iwf].z[itri][2]);
} else {
fprintf(stderr,"warning: some triangles ignored\n");
glEnd();
break;
}
glEnd();
}
}
glEndList();
}
/*surface traveltimes*/
if (sttfp!=NULL) {
fscanf(sttfp,"%d = ntris\n",&ntr);
fprintf(stderr,"ntr=%d\n",ntr);
if (ntr>2000) sttfp=NULL;
}
if (sttfp!=NULL && ntr>0) {
stt=ealloc3float(3,3,ntr);
ttt=ealloc2float(3,ntr);
tmax=0.0;
tmin=1.0e+10;
for (itri=0;itri<ntr;itri++) {
fscanf(sttfp,"%f %f %f %f %f %f %f %f %f %f %f %f\n",
&stt[itri][0][0],
&stt[itri][0][1],
&stt[itri][0][2],
&ttt[itri][0],
&stt[itri][1][0],
&stt[itri][1][1],
&stt[itri][1][2],
&ttt[itri][1],
&stt[itri][2][0],
&stt[itri][2][1],
&stt[itri][2][2],
&ttt[itri][2]);
tmax=MAX(tmax,ttt[itri][0]);
tmax=MAX(tmax,ttt[itri][1]);
tmax=MAX(tmax,ttt[itri][2]);
tmin=MIN(tmin,ttt[itri][0]);
tmin=MIN(tmin,ttt[itri][1]);
tmin=MIN(tmin,ttt[itri][2]);
stt[itri][0][0]=((stt[itri][0][0]-xmin)/
(xmax-xmin)-0.5)*DIAMETER;
stt[itri][0][1]=-((stt[itri][0][1]-ymin)/
(ymax-ymin)-0.5)*DIAMETER;
stt[itri][0][2]=((stt[itri][0][2]-zmin)/
(zmax-zmin)-0.5)*DIAMETER;
stt[itri][1][0]=((stt[itri][1][0]-xmin)/
(xmax-xmin)-0.5)*DIAMETER;
stt[itri][1][1]=-((stt[itri][1][1]-ymin)/
(ymax-ymin)-0.5)*DIAMETER;
stt[itri][1][2]=((stt[itri][1][2]-zmin)/
(zmax-zmin)-0.5)*DIAMETER;
stt[itri][2][0]=((stt[itri][2][0]-xmin)/
(xmax-xmin)-0.5)*DIAMETER;
stt[itri][2][1]=-((stt[itri][2][1]-ymin)/
(ymax-ymin)-0.5)*DIAMETER;
stt[itri][2][2]=((stt[itri][2][2]-zmin)/
(zmax-zmin)-0.5)*DIAMETER;
}
}
tmax=MAX(tmax,tmin+0.01);
glNewList(nhz*4+5,GL_COMPILE);
for (itri=0;itri<ntr;itri++) {
glBegin(GL_TRIANGLE_STRIP);
tEmission(ttt[itri][0],tmin,tmax,emission);
glMaterialfv(GL_FRONT_AND_BACK,GL_EMISSION,emission);
glVertex3fv(stt[itri][0]);
tEmission(ttt[itri][1],tmin,tmax,emission);
glMaterialfv(GL_FRONT_AND_BACK,GL_EMISSION,emission);
glVertex3fv(stt[itri][1]);
tEmission(ttt[itri][2],tmin,tmax,emission);
glMaterialfv(GL_FRONT_AND_BACK,GL_EMISSION,emission);
glVertex3fv(stt[itri][2]);
glEnd();
}
glEndList();
glutMainLoop();
return 0;
}
bool PreviewWindow::onNextFrameAvailableHW(const void* frame,
nsecs_t timestamp,
V4L2Camera* camera_dev)
{
int res;
V4L2BUF_t * pv4l2_buf = (V4L2BUF_t *)frame;
Mutex::Autolock locker(&mObjectLock);
if (!isPreviewEnabled() || mPreviewWindow == NULL)
{
return true;
}
/* Make sure that preview window dimensions are OK with the camera device */
if (adjustPreviewDimensions(camera_dev) || mShouldAdjustDimensions)
{
ALOGD("%s: Adjusting preview windows %p geometry to %dx%d",
__FUNCTION__, mPreviewWindow, mPreviewFrameWidth,
mPreviewFrameHeight);
res = mPreviewWindow->set_buffers_geometryex(mPreviewWindow,
mPreviewFrameWidth,
mPreviewFrameHeight,
HWC_FORMAT_DEFAULT,
mScreenID);
if (res != NO_ERROR) {
ALOGE("%s: Error in set_buffers_geometry %d -> %s",
__FUNCTION__, -res, strerror(-res));
mShouldAdjustDimensions = true;
return false;
}
mPreviewWindow->perform(mPreviewWindow, NATIVE_WINDOW_SETPARAMETER, HWC_LAYER_SETFORMAT, mLayerFormat);
mShouldAdjustDimensions = false;
mPreviewWindow->set_crop(mPreviewWindow,
mRectCrop.left, mRectCrop.top, mRectCrop.right, mRectCrop.bottom);
mNewCrop = false;
ALOGV("first hw: [%d, %d, %d, %d]", mRectCrop.left,
mRectCrop.top,
mRectCrop.right,
mRectCrop.bottom);
}
libhwclayerpara_t overlay_para;
overlay_para.bProgressiveSrc = 1;
overlay_para.bTopFieldFirst = 1;
overlay_para.pVideoInfo.frame_rate = 25000;
overlay_para.top_y = (unsigned int)pv4l2_buf->addrPhyY;
overlay_para.top_c = (unsigned int)pv4l2_buf->addrPhyY + mPreviewFrameWidth * mPreviewFrameHeight;
overlay_para.bottom_y = 0;
overlay_para.bottom_c = 0;
overlay_para.number = 0;
if (mOverlayFirstFrame)
{
ALOGV("first frame true");
overlay_para.first_frame_flg = 1;
mOverlayFirstFrame = false;
}
else
{
overlay_para.first_frame_flg = 0;
}
// ALOGV("addrY: %x, addrC: %x, WXH: %dx%d", overlay_para.top_y, overlay_para.top_c, mPreviewFrameWidth, mPreviewFrameHeight);
if (mNewCrop)
{
mPreviewWindow->set_crop(mPreviewWindow,
mRectCrop.left, mRectCrop.top, mRectCrop.right, mRectCrop.bottom);
mNewCrop = false;
}
res = mPreviewWindow->perform(mPreviewWindow, NATIVE_WINDOW_SETPARAMETER, HWC_LAYER_SETFRAMEPARA, (uint32_t)&overlay_para);
if (res != OK)
{
ALOGE("NATIVE_WINDOW_SETPARAMETER failed");
return false;
}
if (mLayerShowHW == 0)
{
showLayer(true);
}
return true;
}
void HtmHelper::showTopLayer( HtmCortex *ctx )
{
HtmLayer *layer = ctx -> getLayer( ctx -> getLayerCount() - 1 );
showLayer( "Top layer" , layer );
}
void GameLayer::onClickBackEvent()
{
_hallLayer->_roomView->display();
showLayer(_hallLayer);
}
void UICtrl::onEnter(){
Layer::onEnter();
auto vSize = Director::getInstance()->getVisibleSize();
playLayer = Layer::create();
playLayer->setCascadeOpacityEnabled(true);
playLayer->setOpacity(GLubyte(255*0.6));
addChild(playLayer,10);
auto stopButton = Sprite::create("stopButton.png");
stopButton->setPosition(vSize);
stopButton->setAnchorPoint(Vec2(1.0f,1.0f));
playLayer->addChild(stopButton);
auto leftButton = Sprite::create("leftButton.png");
leftButton->setPosition(Vec2(0,0));
leftButton->setAnchorPoint(Vec2(0,0));
playLayer->addChild(leftButton);
auto rightButton = Sprite::create("rightButton.png");
rightButton->setPosition(Vec2(100,0));
rightButton->setAnchorPoint(Vec2(0,0));
playLayer->addChild(rightButton);
moveButton = Sprite::create("moveButton2.png");
moveButton->setPosition(Vec2(780,0));
moveButton->setAnchorPoint(Vec2(1,0));
playLayer->addChild(moveButton);
NotificationCenter::getInstance()->addObserver(this,
callfuncO_selector(UICtrl::showBuff), strShowBuff, NULL);
NotificationCenter::getInstance()->addObserver(this,
callfuncO_selector(UICtrl::hideBuff), strHideBuff, NULL);
NotificationCenter::getInstance()->addObserver(this,
callfuncO_selector(UICtrl::dieShow), strDieShow, NULL);
auto hitButton = Sprite::create("hitButton.png");
hitButton->setPosition(Vec2(870,0));
hitButton->setAnchorPoint(Vec2(1,0));
playLayer->addChild(hitButton);
auto jumpButton = Sprite::create("jumpButton.png");
jumpButton->setPosition(Vec2(960,0));
jumpButton->setAnchorPoint(Vec2(1,0));
playLayer->addChild(jumpButton);
stopLayer = Layer::create();
stopLayer->setCascadeOpacityEnabled(true);
stopLayer->setOpacity(GLubyte(255*0.75));
stopLayer->setScale(0.5);
addChild(stopLayer,8);
stopLayer->setVisible(false);
auto node = CSLoader::createNode("GameStop.csb");
stopLayer->addChild(node);
auto backButton = dynamic_cast<ui::Button*>(node->getChildByName("backButton"));
backButton->addClickEventListener([=](Ref* pSender){
hideLayer();
});
auto restartButton = dynamic_cast<ui::Button*>(node->getChildByName("restartButton"));
restartButton->addClickEventListener([=](Ref* pSender){
Hero::heroLife = 10;
ShareData::getInstance()->heroScore = 0;
Director::getInstance()->replaceScene(MainScene::createScene());
Director::getInstance()->resume();
});
auto quitButton = dynamic_cast<ui::Button*>(node->getChildByName("quitButton"));
quitButton->addClickEventListener([=](Ref* pSender){
Director::getInstance()->replaceScene(StartScene::createScene());
Director::getInstance()->resume();
});
listener = EventListenerTouchOneByOne::create();
listener->onTouchBegan = [=](Touch* touch, Event* e){
if( stopButton->getBoundingBox().containsPoint(touch->getLocation())){
showLayer();
}else if( leftButton->getBoundingBox().containsPoint(touch->getLocation())){
NotificationCenter::getInstance()->postNotification(strLeftButtonDown);
}else if( rightButton->getBoundingBox().containsPoint(touch->getLocation())){
NotificationCenter::getInstance()->postNotification(strRightButtonDown);
}else if( moveButton->getBoundingBox().containsPoint(touch->getLocation())){
NotificationCenter::getInstance()->postNotification(strQuickMove);
}else if( hitButton->getBoundingBox().containsPoint(touch->getLocation())){
NotificationCenter::getInstance()->postNotification(strHeroShoot);
}else if( jumpButton->getBoundingBox().containsPoint(touch->getLocation())){
NotificationCenter::getInstance()->postNotification(strJumpButtonDown);
}
return true;
};
listener->onTouchEnded = [=](Touch* touch, Event* e){
if( leftButton->getBoundingBox().containsPoint(touch->getLocation())){
NotificationCenter::getInstance()->postNotification(strLeftButtonUp);
}else if( rightButton->getBoundingBox().containsPoint(touch->getLocation())){
NotificationCenter::getInstance()->postNotification(strRightButtonUp);
}
};
listener->setSwallowTouches(true);
_eventDispatcher->addEventListenerWithSceneGraphPriority(listener,this);
dieLayer = Layer::create();
addChild(dieLayer);
dieLayer->setVisible(false);
auto dieSprite = Sprite::create("die.png");
dieSprite->setPosition(vSize.width/2,vSize.height/2+60);
dieLayer->addChild(dieSprite);
ui::Button* restart = ui::Button::create("continue.png");
restart->setPosition(Vec2(vSize.width/2,vSize.height/2-60));
restart->addClickEventListener([=](Ref* pSender){
Hero::heroLife = 10;
ShareData::getInstance()->heroScore = 0;
ShareData::getInstance()->rankScore = 0;
MainScene::level = 1;
Director::getInstance()->replaceScene(MainScene::createScene());
SimpleAudioEngine::getInstance()->resumeBackgroundMusic();
Director::getInstance()->resume();
});
dieLayer->addChild(restart);
}
