Ejemplo n.º 1
0
void init_screen()
{
	void *host_addr = memalign(1024 * 1024, 1024 * 1024);
	assert(host_addr != NULL);

	context = realityInit(0x10000, 1024 * 1024, host_addr);
	assert(context != NULL);

	assert(videoGetState(0, 0, &state) == 0);
	assert(state.state == 0);

	assert(videoGetResolution(state.displayMode.resolution, &res) == 0);

	memset(&vconfig, 0, sizeof(VideoConfiguration));
	vconfig.resolution = state.displayMode.resolution;
	vconfig.format = VIDEO_BUFFER_FORMAT_XRGB;
	vconfig.pitch = res.width * 4;

	assert(videoConfigure(0, &vconfig, NULL, 0) == 0);
	assert(videoGetState(0, 0, &state) == 0);

	s32 buffer_size = 4 * res.width * res.height;

	gcmSetFlipMode(GCM_FLIP_VSYNC);
	makeBuffer(0, buffer_size);
	makeBuffer(1, buffer_size);

	gcmResetFlipStatus();
	flip(1);
}
Ejemplo n.º 2
0
NoRSX::NoRSX(int id_type){
	buffer_type = screen_type = id_type;
	currentBuffer = 0;
	
	switch(id_type){
		case RESOLUTION_1920x1080: {
			width=1920;height=1080;
		} break;
		case RESOLUTION_1280x720: {
			width=1280;height=720;
		} break;
		case RESOLUTION_720x576: {
			width=720;height=576;
		} break;
		case RESOLUTION_720x480: {
			width=720;height=480;
		} break;
		default:
			width=720;height=480;
		  break;
	}
	buffers[0].width=width;buffers[0].height=height;
	buffers[1].width=width;buffers[1].height=height;
	buffer = makeMemBuffer(width,height,&buffer_size);

	for(int i=0;i<2;i++)
		makeBuffer(&buffers[i],width,height,a);
	flip();
}
Ejemplo n.º 3
0
NoRSX::NoRSX(){
	currentBuffer = 0;
	getResolution(&width,&height);
	for(int i=0;i<2;i++)
		makeBuffer(&buffers[i],width,height,a);
	flip();
}
Ejemplo n.º 4
0
/* internal engine routines */
static void *
_output_setup(int w, int h)
{
   Render_Engine *re;
   int i;
   u16 width, height;
   DATA32 *image_data = NULL;
   int image_size;

   printf ("_output_setup called : %dx%d\n", w, h);
   re = calloc(1, sizeof(Render_Engine));
   if (!re)
     return NULL;

   /* Allocate a 1Mb buffer, alligned to a 1Mb boundary
    * to be our shared IO memory with the RSX. */
   re->host_addr = memalign (1024 * 1024, HOST_SIZE);
   if (re->host_addr == NULL)
     {
        free (re);
        return NULL;
     }
   re->context = initScreen (re->host_addr, HOST_SIZE);
   if (re->context == NULL)
     {
        free (re->host_addr);
        free (re);
        return NULL;
     }
   width = w;
   height = h;
   setResolution (re->context, &width, &height);
   re->currentBuffer = 0;
   re->width = width;
   re->height = height;

   for (i = 0; i < MAX_BUFFERS; i++)
     makeBuffer (&re->buffers[i], width, height, i);

   flipBuffer(re->context, MAX_BUFFERS - 1);

   re->tb = evas_common_tilebuf_new(w, h);

   /* in preliminary tests 16x16 gave highest framerates */
   evas_common_tilebuf_set_tile_size(re->tb, TILESIZE, TILESIZE);

   /* Allocate our memaligned backbuffer */
   image_size = ((w * h * sizeof(u32)) + 0xfffff) & - 0x100000;
   image_data = memalign (1024 * 1024, image_size);
   re->rgba_image = (RGBA_Image *)evas_cache_image_data(evas_common_image_cache_get(),
                                                        w, h, image_data, 1, EVAS_COLORSPACE_ARGB8888);
   gcmMapMainMemory(image_data, image_size, &re->rgba_image_offset);

   return re;
}
Ejemplo n.º 5
0
NoRSX::NoRSX() : EventHandler(){
	currentBuffer = 0;
	buffer_type = screen_type = 0;
	host_addr = memalign(1024*1024, HOST_SIZE);
	getResolution(&width,&height);
	context = initScreen(host_addr, HOST_SIZE,0, width, height);
	for(int i=0;i<2;i++)
		makeBuffer(&buffers[i],width,height,i);
	buffer = makeMemBuffer(width,height,&buffer_size);
	flip(context, 0);
	setRenderTarget(context, &buffers[currentBuffer]);
	RegisterCallBack(EVENT_SLOT0);
}
Ejemplo n.º 6
0
// Initilize everything. You can probally skip over this function.
void init_screen() {
	// Allocate a 1Mb buffer, alligned to a 1Mb boundary to be our shared IO memory with the RSX.
	void *host_addr = memalign(1024*1024, 1024*1024);
	assert(host_addr != NULL);

	// Initilise Reality, which sets up the command buffer and shared IO memory
	context = realityInit(0x10000, 1024*1024, host_addr); 
	assert(context != NULL);

	VideoState state;
	assert(videoGetState(0, 0, &state) == 0); // Get the state of the display
	assert(state.state == 0); // Make sure display is enabled

	// Get the current resolution
	assert(videoGetResolution(state.displayMode.resolution, &res) == 0);
	
	// Configure the buffer format to xRGB
	VideoConfiguration vconfig;
	memset(&vconfig, 0, sizeof(VideoConfiguration));
	vconfig.resolution = state.displayMode.resolution;
	vconfig.format = VIDEO_BUFFER_FORMAT_XRGB;
	vconfig.pitch = res.width * 4;

	assert(videoConfigure(0, &vconfig, NULL, 0) == 0);
	assert(videoGetState(0, 0, &state) == 0); 

	s32 buffer_size = 4 * res.width * res.height; // each pixel is 4 bytes
	printf("buffers will be 0x%x bytes\n", buffer_size);
	
	gcmSetFlipMode(GCM_FLIP_VSYNC); // Wait for VSYNC to flip

	// Allocate two buffers for the RSX to draw to the screen (double buffering)
	makeBuffer(0, buffer_size);
	makeBuffer(1, buffer_size);

	gcmResetFlipStatus();
	flip(1);
}
Ejemplo n.º 7
0
void writeMatch(refMatch match)
{ refBuffer buffer = makeBuffer(stdout, 0);
  writeFormat(buffer, "[Match");
  writeBlank(buffer);
  writingObject(buffer, leftLayer(match));
  writeBlank(buffer);
  writingObject(buffer, leftType(match));
  writeBlank(buffer);
  writingObject(buffer, rightLayer(match));
  writeBlank(buffer);
  writingObject(buffer, rightType(match));
  writeChar(buffer, ']');
  writeBuffer(buffer);
  free(buffer); }
Ejemplo n.º 8
0
static void setupBuffers(void){
    GLfloat g_vertex_buffer_data[] = {
       -0.5f, -0.5f, 0.0f,
       0.5, -0.5, 0.0f,
       0.5f, 0.5f, 0.0f,

       0.5f, 0.5f, 0.0f,
       -0.5f, 0.5f, 0.0f,
       -0.5f, -0.5f, 0.0f
    };

    g_resources.vertex_buffer = makeBuffer(
        GL_ARRAY_BUFFER,
        g_vertex_buffer_data,
        sizeof(g_vertex_buffer_data)
    );
}
Ejemplo n.º 9
0
NoRSX::NoRSX(int id_type) : EventHandler(){
	buffer_type = screen_type = id_type;
	currentBuffer = 0;
	host_addr = memalign(1024*1024, HOST_SIZE);
	
	switch(id_type){
		case RESOLUTION_1920x1080: {
			width=1920;height=1080;
			buffers[0].width=1920;buffers[0].height=1080;
			buffers[1].width=1920;buffers[1].height=1080;
		} break;
		case RESOLUTION_1280x720: {
			width=1280;height=720;
			buffers[0].width=1280;buffers[0].height=720;
			buffers[1].width=1280;buffers[1].height=720;
		} break;
		case RESOLUTION_720x576: {
			width=720;height=576;
			buffers[0].width=720;buffers[0].height=576;
			buffers[1].width=720;buffers[1].height=576;
		} break;
		case RESOLUTION_720x480: {
			width=720;height=480;
			buffers[0].width=720;buffers[0].height=480;
			buffers[1].width=720;buffers[1].height=480;
		} break;
		default:
			getResolution(&width,&height);
			buffers[0].width=width;buffers[0].height=height;
			buffers[1].width=width;buffers[1].height=height;
		  break;
	}
	context = initScreen(host_addr, HOST_SIZE, id_type, width, height);

	for(int i=0;i<2;i++)
		makeBuffer(&buffers[i],width,height,i);
		
	buffer = makeMemBuffer(width,height,&buffer_size);
	flip(context, 0);
	setRenderTarget(context, &buffers[0]);
	RegisterCallBack(EVENT_SLOT0);
}
Ejemplo n.º 10
0
static void setupDynamicBuffers(){
  GLfloat x_translation = sin(angle)/2.0f;
  GLfloat triangleVertices[] = {
          //left triangle
  -0.5 + x_translation, 0.5, 0.0,
  0.0  + x_translation, 0.5, 0.0,
  -0.5 + x_translation, -0.5, 0.0,
  //right triangle
  0.0 + x_translation, 0.5, 0.0,
  0.0 + x_translation, -0.5, 0.0,
  -0.5 + x_translation, -0.5, 0.0
  };

  angle += 0.01;

  g_resources.vertex_buffer = makeBuffer(
      GL_ARRAY_BUFFER,
      triangleVertices,
      sizeof(triangleVertices)
  );
}
Ejemplo n.º 11
0
int
startScreen ()
{
  int i;
  int ret;

  /* Allocate a 1Mb buffer, alligned to a 1Mb boundary * to be our shared IO
   * memory with the RSX. */
  host_addr = memalign (1024 * 1024, HOST_SIZE);
  ret = initScreen (host_addr, HOST_SIZE);
  if (ret) {
    return 0;
  }

  getResolution (&width, &height);
  for (i = 0; i < MAX_BUFFERS; i++)
    makeBuffer (&buffers[i], width, height, i);

  flip (context, MAX_BUFFERS - 1);
  return 1;

}
Ejemplo n.º 12
0
//--------------------------------------------------------------
void testApp::setup(){
	ofBackground(255,255,255);
	ofSetFrameRate(30);
	
    // video setup
    camWidth 		= 320;	// try to grab at this size. 
	camHeight 		= 240;
	
	//vidGrabber.videoSettings();
	vidGrabber.listDevices();
    
	vidGrabber.setVerbose(true);
	vidGrabber.initGrabber(camWidth,camHeight);
	//interp.reset(ofPoint(100, ofGetHeight()/2), ofPoint(ofGetWidth()-100, ofGetHeight()/2));	
    
    int fps = 30;
    
    currentBuffer = -1;
    makeBuffer(ofGetWidth()/2,ofGetHeight()/2);
    
    
    currentSource = 0;
    
    cam.execute("http://148.61.142.228/axis-cgi/mjpg/video.cgi?resolution="+ ofToString(camWidth) + "x" + ofToString(camHeight),camWidth,camHeight);
	videoTexture0.allocate(camWidth,camHeight, GL_RGBA) ;//GL_RGBA);

    
	//interp.insert(ofPoint(ofGetWidth()/2,0));//ofGetHeight()/2));
	
	
    //	frameByframe = false;

	/*
	fingerMovie.loadMovie("movies/fingers.mov");
	fingerMovie.play();
	 */
}
Ejemplo n.º 13
0
//float color [] = {1.0f, 0.0f, 0.0f, 1.0f};
void setupVBO(){
  //pVertices=makeBuffer(pvertices, platformVertexCount, sizeof(float)*4);

  //pColors=makeBuffer(color, 1, sizeof(float));

  for(int i=0; i<loaded.size(); i++){
    loaded[i].vertices=makeBuffer(&(loaded[i]).w[0], loaded[i].count*3, sizeof(float)*4);
    loaded[i].normals=makeBuffer(&(loaded[i]).n[0], loaded[i].count*3, sizeof(float)*4);
    loaded[i].texCoords=makeBuffer(&(loaded[i]).tc[0], loaded[i].count*3, sizeof(float)*2);
  }

  for(int i=0; i<model.size(); i++){
    model[i].vertices=makeBuffer(&(model[i]).w[0], model[i].count*3, sizeof(float)*4);
    model[i].normals=makeBuffer(&(model[i]).n[0], model[i].count*3, sizeof(float)*4);
    model[i].texCoords=makeBuffer(&(model[i]).tc[0], model[i].count*3, sizeof(float)*2);
  }
  //cout<<"Size of loaded: "<<loaded.size()<<endl;
}
Ejemplo n.º 14
0
/* The main function for running the ECG program. */
int runECG() {
	openFile();

	//printf("Peak nr.   Line        R peak\n");
	buffered_filtered_data = makeBuffer(SIZE_FILTERED_DATA);
	buffered_raw_data = makeBuffer(SIZE_RAW_DATA);
	buffered_LP_data = makeBuffer(SIZE_LP_DATA);
	buffered_HP_data = makeBuffer(SIZE_HP_DATA);
	buffered_derivative_square_data = makeBuffer(SIZE_DERIVATIVESQUARE_DATA);
	buffered_peak_lines = makeBuffer(SIZE_PEAKS);
	initQRS();
	while (getFilePointer() != EOF) {
		insert(&buffered_filtered_data, filter());
		detectPeaks();
		line++;
	}

	freeBuffers(&buffered_raw_data, &buffered_LP_data, &buffered_HP_data,
			&buffered_derivative_square_data, &buffered_filtered_data,
			&buffered_peak_lines);
	return 0;
}
Ejemplo n.º 15
0
int
main (s32 argc, const char* argv[])
{
  gcmContextData *context;
  void *host_addr = NULL;
  rsxBuffer buffers[MAX_BUFFERS];
  int currentBuffer = 0;
  padInfo padinfo;
  padData paddata;
  u16 width;
  u16 height;
  int frame = 0;
  int i;

  /* Allocate a 1Mb buffer, alligned to a 1Mb boundary
   * to be our shared IO memory with the RSX. */
  host_addr = memalign (1024*1024, HOST_SIZE);
  context = initScreen (host_addr, HOST_SIZE);
  ioPadInit (7);

  getResolution(&width, &height);
  for (i = 0; i < MAX_BUFFERS; i++)
    makeBuffer (&buffers[i], width, height, i);

  flip(context, MAX_BUFFERS - 1);

  DEBUG ("Starting Cairo test\n");

  while (1) {
    ioPadGetInfo (&padinfo);
    for(i = 0; i < MAX_PADS; i++) {
        if(padinfo.status[i]) {
            ioPadGetData (i, &paddata);
            if(paddata.BTN_START) {
              goto end;
            }
        }
    }

    setRenderTarget(context, &buffers[currentBuffer]);

    DEBUG ("Drawing frame %d\n", frame);
    waitFlip ();
    drawFrame (&buffers[currentBuffer], frame++); /* Draw into the unused buffer */
    flip (context, buffers[currentBuffer].id); /* Flip buffer onto screen */

    currentBuffer++;
    if (currentBuffer >= MAX_BUFFERS)
      currentBuffer = 0;
  }

 end:

  gcmSetWaitFlip(context);
  for (i = 0; i < MAX_BUFFERS; i++)
    rsxFree (buffers[i].ptr);

  rsxFinish (context, 1);
  free (host_addr);
  ioPadEnd();

  return 0;
}
Ejemplo n.º 16
0
//--------------------------------------------------------------
void testApp::keyPressed  (int key){
   
	if(key == '!' || key == '@' || key == '#' || key == '$') {
        thisKey = key;
        return;
    } 
    
    if(key == 'o') {
        float o = xform[currentBuffer].getOpacity();
        xform[currentBuffer].setOpacity(CLAMP(o+0.1,0,1));
        return;
    } else if(key == 'O') {
        float o = xform[currentBuffer].getOpacity();
        xform[currentBuffer].setOpacity(CLAMP(o-0.1,0,1));
        return;
    }
    
    if(key == '\'') {
        currentSource ^= 1;
    }
    
    if (key == 's' || key == 'S'){
		vidGrabber.videoSettings();
	}
    if(key == 'Q') {
        int i = 120;
        buffers[currentBuffer]->resize(i);
        return;
    }
    
    if(key == 'q') {
        int r = 10;
        buffers[currentBuffer]->resize(r);
        return;
    }


    if(key == ' ') {
        buffers[currentBuffer]->setBufferMode(VB_BUFFERING);
    }
    
    if(key == 'p') {
        buffers[currentBuffer]->setBufferMode(VB_PASSTHROUGH);
    }

    
    if(key == 'R') {
        buffers[currentBuffer]->clear();
    }
    
    if(key == '1') {
        buffers[currentBuffer]->setLoopState(OF_LOOP_NONE);
    } else if(key == '2') {
        buffers[currentBuffer]->setLoopState(OF_LOOP_NORMAL);
    } else if(key == '3') {
        buffers[currentBuffer]->setLoopState(OF_LOOP_PALINDROME);
    }
    
    if(key == 'q') {
        buffers[currentBuffer]->setLoopPointsStart( buffers[currentBuffer]->getLoopPointsStart()-1 );
    } else if(key == 'w') {
        buffers[currentBuffer]->setLoopPointsStart( buffers[currentBuffer]->getLoopPointsStart()+1 );
    } else if(key == 'e') {
        buffers[currentBuffer]->setLoopPointsEnd( buffers[currentBuffer]->getLoopPointsEnd()-1 );
    } else if(key == 'r') {
        buffers[currentBuffer]->setLoopPointsEnd( buffers[currentBuffer]->getLoopPointsEnd()+1 );
    }
    
    

    
    if(key == 'n') {
        makeBuffer(mouseX,mouseY);
    }
    
    
    if(key == '<') {
        currentBuffer = MAX(0, currentBuffer-1);
    } else if(key == '>') {
        currentBuffer = (currentBuffer + 1) % buffers.size();
    }
    
    
/*
	switch(key){
        case 'f':
            frameByframe=!frameByframe;
            fingerMovie.setPaused(frameByframe);
        break;
        case OF_KEY_LEFT:
            fingerMovie.previousFrame();
        break;
        case OF_KEY_RIGHT:
            fingerMovie.nextFrame();
        break;
        case '0':
            fingerMovie.firstFrame();
        break;
    }
	*/
}
Ejemplo n.º 17
0
/*
 * Processes received authentication tokens as well as supplies the
 * response token.
 */
int ne_sspi_authenticate(void *context, const char *base64Token, char **responseToken)
{
    SecBufferDesc outBufferDesc;
    SecBuffer outBuffer;
    int status;
    SECURITY_STATUS securityStatus;
    ULONG contextFlags;

    SSPIContext *sspiContext;
    if (initialized <= 0) {
        return -1;
    }

    status = getContext(context, &sspiContext);
    if (status) {
        return status;
    }

    /* TODO: Not sure what flags should be set. joe: this needs to be
     * driven by the ne_auth interface; the GSSAPI code needs similar
     * flags. */
    contextFlags = ISC_REQ_CONFIDENTIALITY | ISC_REQ_MUTUAL_AUTH;

    initSingleEmptyBuffer(&outBufferDesc, &outBuffer);
    status = makeBuffer(&outBufferDesc, sspiContext->maxTokenSize);
    if (status) {
        return status;
    }

    if (base64Token) {
        SecBufferDesc inBufferDesc;
        SecBuffer inBuffer;

        if (!sspiContext->continueNeeded) {
            freeBuffer(&outBufferDesc);
            NE_DEBUG(NE_DBG_HTTPAUTH, "sspi: Got an unexpected token.\n");
            return -1;
        }

        initSingleEmptyBuffer(&inBufferDesc, &inBuffer);

        status = base64ToBuffer(base64Token, &inBufferDesc);
        if (status) {
            freeBuffer(&outBufferDesc);
            return status;
        }

        securityStatus =
            initializeSecurityContext(&sspiContext->credentials,
                                      &(sspiContext->context),
                                      sspiContext->serverName, contextFlags,
                                      &inBufferDesc, &(sspiContext->context),
                                      &outBufferDesc);
        if (securityStatus == SEC_E_OK)
        {
            sspiContext->authfinished = 1;
        }
        freeBuffer(&inBufferDesc);
    } else {
        if (sspiContext->continueNeeded) {
            freeBuffer(&outBufferDesc);
            NE_DEBUG(NE_DBG_HTTPAUTH, "sspi: Expected a token from server.\n");
            return -1;
        }
        if (sspiContext->authfinished && (sspiContext->credentials.dwLower || sspiContext->credentials.dwUpper)) {
            if (sspiContext->authfinished)
            {
                freeBuffer(&outBufferDesc);
                sspiContext->authfinished = 0;
                NE_DEBUG(NE_DBG_HTTPAUTH,"sspi: failing because starting over from failed try.\n");
                return -1;
            }
            sspiContext->authfinished = 0;
        }

        /* Reset any existing context since we are starting over */
        resetContext(sspiContext);

        if (acquireCredentialsHandle
            (&sspiContext->credentials, sspiContext->mechanism) != SEC_E_OK) {
                freeBuffer(&outBufferDesc);
                NE_DEBUG(NE_DBG_HTTPAUTH,
                    "sspi: acquireCredentialsHandle failed.\n");
                return -1;
        }

        securityStatus =
            initializeSecurityContext(&sspiContext->credentials, NULL,
                                      sspiContext->serverName, contextFlags,
                                      NULL, &(sspiContext->context),
                                      &outBufferDesc);
    }

    if (securityStatus == SEC_I_COMPLETE_AND_CONTINUE
        || securityStatus == SEC_I_COMPLETE_NEEDED) {
        SECURITY_STATUS compleStatus =
            pSFT->CompleteAuthToken(&(sspiContext->context), &outBufferDesc);

        if (compleStatus != SEC_E_OK) {
            freeBuffer(&outBufferDesc);
            NE_DEBUG(NE_DBG_HTTPAUTH, "sspi: CompleteAuthToken failed.\n");
            return -1;
        }
    }

    if (securityStatus == SEC_I_COMPLETE_AND_CONTINUE
        || securityStatus == SEC_I_CONTINUE_NEEDED) {
        sspiContext->continueNeeded = 1;
    } else {
        sspiContext->continueNeeded = 0;
    }

    if (!(securityStatus == SEC_I_COMPLETE_AND_CONTINUE
          || securityStatus == SEC_I_COMPLETE_NEEDED
          || securityStatus == SEC_I_CONTINUE_NEEDED
          || securityStatus == SEC_E_OK)) {
        NE_DEBUG(NE_DBG_HTTPAUTH,
                 "sspi: initializeSecurityContext [failed] [%x].\n",
                 securityStatus);
        freeBuffer(&outBufferDesc);
        return -1;
    }

    *responseToken = ne_base64(outBufferDesc.pBuffers->pvBuffer,
                               outBufferDesc.pBuffers->cbBuffer);
    freeBuffer(&outBufferDesc);

    return 0;
}
Ejemplo n.º 18
0
//Procedura tworz¹ca bufory VBO zawieraj¹ce dane z tablic opisuj¹cych rysowany obiekt.
void setupVBO() {
	bufTexCoords = makeBuffer(texCoords, vertexCount, sizeof(float)* 2);
	bufVertices = makeBuffer(vertices, vertexCount, sizeof(float)* 4); //Wspó³rzêdne wierzcho³ków
	bufColors = makeBuffer(colors, vertexCount, sizeof(float)* 4);//Kolory wierzcho³ków
	bufNormals = makeBuffer(normals, vertexCount, sizeof(float)* 4);//Wektory normalne wierzcho³ków
}
Ejemplo n.º 19
0
s32 main(s32 argc, const char* argv[])
{
  gcmContextData *context;
  void *host_addr = NULL;
  rsxBuffer buffers[MAX_BUFFERS];
  int currentBuffer = 0;
  padInfo padinfo ;
  padData paddata ;
  u16 width;
  u16 height;
  int i;
  long frame = 0; /* to keep track of how many frames we have rendered */

  atexit(unload_modules);
  if(sysModuleLoad(SYSMODULE_FS) != 0)
    return 0;
  else
    module_flag |= 1;

  if(sysModuleLoad(SYSMODULE_PNGDEC) != 0)
    return 0;
  else
    module_flag |= 2;

  /* Allocate a 1Mb buffer, alligned to a 1Mb boundary
   * to be our shared IO memory with the RSX. */
  host_addr = memalign ( 1024*1024, HOST_SIZE ) ;
  context = screenInit ( host_addr, HOST_SIZE ) ;
  getResolution( &width, &height ) ;
  for (i = 0; i < MAX_BUFFERS; i++)
    makeBuffer( &buffers[i], width, height, i ) ;
  flip( context, MAX_BUFFERS - 1 ) ;
  setRenderTarget(context, &buffers[currentBuffer]) ;

  sysUtilRegisterCallback(SYSUTIL_EVENT_SLOT0, eventHandler, NULL);

  ioPadInit(7) ;

  /* png bitmap buffer */
  pngData png1;

#if USE_PNG_FROM_FILE == true
  const char *filename = PNG_FILE;
  /* load png from file */
  pngLoadFromFile(filename, &png1);
#endif
#if USE_PNG_FROM_FILE == false
  /* load png from memory */
  pngLoadFromBuffer((void *)psl1ght_png, psl1ght_png_size, &png1);
#endif

  /* Ok, everything is setup. Now for the main loop. */
  exitapp = 1;
  while(exitapp)
  {
    /* Check the pads. */
    ioPadGetInfo(&padinfo);
    for(i=0; i<MAX_PADS; i++){
      if(padinfo.status[i]){
        ioPadGetData(i, &paddata);

        if(paddata.BTN_CROSS){
          exitapp = 0;
          goto end;
        }
      }
    }

    waitFlip(); // Wait for the last flip to finish, so we can draw to the old buffer
    drawFrame(&buffers[currentBuffer], frame++); // Draw into the unused buffer

    if(png1.bmp_out)
    {
      static int x=0, y=0, dx=2, dy=2;
  
      u32 *scr = (u32 *)buffers[currentBuffer].ptr;
      u32 *png= (void *)png1.bmp_out;
      int n, m;
  
      /* update x, y coordinates */
      x+=dx;
      y+=dy;
  
      /* */
      if(x < 0)
      {
        x=0;
        dx=1;
      }

      /* screen width to png width */
      if(x > (buffers[currentBuffer].width - png1.width))
      {
        x=(buffers[currentBuffer].width - png1.width);
        dx=-2;
      }
  
      /* */
      if(y < 0)
      {
        y=0;
        dy=1;
      }

      /* screen height to png height */
      if(y > (buffers[currentBuffer].height - png1.height))
      {
        y = (buffers[currentBuffer].height - png1.height);
        dy=-2;
      }

      /* update screen buffer from coordinates */
      scr += y * buffers[currentBuffer].width + x;                     
  
      // draw PNG
      for(n=0;n<png1.height;n++)
      {
        if((y+n)>=buffers[currentBuffer].height) break;
        for(m=0;m<png1.width;m++)
        {
          if((x+m)>=buffers[currentBuffer].width) break;
          scr[m]=png[m];
        }
        png+=png1.pitch>>2;
        scr+=buffers[currentBuffer].width;
      }
    }

    flip(context, buffers[currentBuffer].id); /* Flip buffer onto screen */

    currentBuffer = !currentBuffer;
    setRenderTarget(context, &buffers[currentBuffer]) ; /* change buffer */

    sysUtilCheckCallback(); /* check user attention span */
  }

 end:

  gcmSetWaitFlip(context);
  for (i=0; i < MAX_BUFFERS; i++)
    rsxFree (buffers[i].ptr);
  rsxFinish (context, 1);
  free (host_addr);
  ioPadEnd();

  return 0;
}
Ejemplo n.º 20
0
void meshModels::cacheCylinder(float vertsX[], float vertsY[], float depth)
{
	dir = TRUE;
	cacheEndCap( vertsX, vertsY, 0.0f);
	dir = FALSE;
	cacheEndCap( vertsX, vertsY, depth);
	dir = FALSE;

	// objects to build our vertices in
	vertex_t vertA, vertB, vertC;
	polygon_t poly;
	int i = 0;
	int j;
	int faceCount;

	// find out how many verts we have
	int vcount = model.verts.size();
	int endGon = vcount; // and saving the starting vertice index for later

	//record all three points as a triangle in our structure
	poly.a = vcount;
	poly.b = vcount +1;
	poly.c = vcount +2;

	// we need to start with two verts because then 
	//we only need to add 2 verts to get 2 new triangles in the for loop

	// build our first vertex
	vertA.x = vertsX[i];
	vertA.y = vertsY[i];
	vertA.z = 0.0f;
	// push it into our array
	model.verts.reserve(poly.a);
	model.verts.push_back(vertA);

	//build our third vertex
	vertB.x = vertsX[i];
	vertB.y = vertsY[i];
	vertB.z = depth;
	// push it into our array
	model.verts.reserve(poly.b);
	model.verts.push_back(vertB);
	
	i++;

	// build a cylinder 2 triangles at a time
	for( j = 0; j < 62; ++j)
	{
		// ensure our array iterator is not too large
		if(i>=32)
			i = 0;

		//record all three points as a triangle in our structure
		poly.a = vcount;
		poly.b = vcount +1;
		poly.c = vcount +2;

		//build our second vertex
		vertC.x = vertsX[i];
		vertC.y = vertsY[i];
		vertC.z = 0.0f;
		// push it into our array
		model.verts.reserve(poly.c);
		model.verts.push_back(vertC);


		// record the triangle
		model.polys.reserve(j);
		model.polys.push_back(poly);

		faceCount = model.polys.size()-1;

		calculateFaceNormal(faceCount);

		j++; // advance to the next polygon
	
		// vertex A is really the old vertex b so lets record the change here
		poly.a = poly.b;

		vertB.x = vertsX[i];
		vertB.y = vertsY[i];
		vertB.z = depth;
		poly.b = model.verts.size(); // set the iterator for the new vertex
		model.verts.reserve(poly.b);
		model.verts.push_back(vertB);

		// VertC is the same and remains unchanged
		// lets store our triangle
		model.polys.reserve(j);
		model.polys.push_back(poly);

		faceCount = model.polys.size()-1;

		calculateFaceNormal(faceCount);

		vcount = vcount +2;
		i++;
	}

	// add our last two triangles using existing verts
	poly.a = model.verts.size() - 2;
	poly.b = model.verts.size() - 1;
	poly.c = endGon;

	model.polys.reserve(vcount);
	model.polys.push_back(poly);

	faceCount = model.polys.size()-1;
	calculateFaceNormal(faceCount);

	// add our last two triangles using existing verts
	poly.a = model.verts.size() - 1;
	poly.b = endGon + 1;
	poly.c = endGon;

	model.polys.reserve(vcount + 1);
	model.polys.push_back(poly);

	faceCount = model.polys.size()-1;
	calculateFaceNormal(faceCount);

	normalizeVerts();

	makeShader();
	makeBuffer();
}
Ejemplo n.º 21
0
RecordBuffer* DbCreatorsList::getList(thread_db* tdbb, jrd_rel* relation)
{
	fb_assert(relation);
	fb_assert(relation->rel_id == rel_sec_db_creators);

	RecordBuffer* buffer = getData(relation);
	if (buffer)
	{
		return buffer;
	}

	RefPtr<IAttachment> att;
	RefPtr<ITransaction> tra;
	const char* dbName = tdbb->getDatabase()->dbb_config->getSecurityDatabase();
	if (!openDb(dbName, att, tra))
	{
		// In embedded mode we are not raising any errors - silent return
		if (MasterInterfacePtr()->serverMode(-1) < 0)
			return makeBuffer(tdbb);

		(Arg::Gds(isc_crdb_nodb) << dbName).raise();
	}

	Message gr;
	Field<ISC_SHORT> uType(gr);
	Field<Varying> u(gr, MAX_SQL_IDENTIFIER_LEN);

	FbLocalStatus st;
	RefPtr<IResultSet> curs(att->openCursor(&st, tra, 0,
		"select RDB$USER_TYPE, RDB$USER from RDB$DB_CREATORS",
		SQL_DIALECT_V6, NULL, NULL, gr.getMetadata(), NULL, 0));

	if (st->getState() & IStatus::STATE_ERRORS)
	{
		if (!fb_utils::containsErrorCode(st->getErrors(), isc_dsql_relation_err))
			check("IAttachment::openCursor", &st);

		// isc_dsql_relation_err when opening cursor - i.e. table
		// is missing due to non-FB3 security DB

		// In embedded mode we are not raising any errors - silent return
		if (MasterInterfacePtr()->serverMode(-1) < 0)
			return makeBuffer(tdbb);

		(Arg::Gds(isc_crdb_notable) << dbName).raise();
	}

	try
	{
		buffer = makeBuffer(tdbb);
		while (curs->fetchNext(&st, gr.getBuffer()) == IStatus::RESULT_OK)
		{
			Record* record = buffer->getTempRecord();
			record->nullify();

			putField(tdbb, record,
					 DumpField(f_sec_crt_user, VALUE_STRING, u->len, u->data));

			SINT64 v = uType;
			putField(tdbb, record,
					 DumpField(f_sec_crt_u_type, VALUE_INTEGER, sizeof(v), &v));

			buffer->store(record);
		}
		check("IResultSet::fetchNext", &st);
	}
	catch (const Exception&)
	{
		clearSnapshot();
		throw;
	}

	return getData(relation);
}
Ejemplo n.º 22
0
int main(s32 argc, const char* argv[]) {
	//Mutex.
	sys_mutex_attr_t attr;
	memset(&attr, 0, sizeof(attr));
	attr.attr_protocol = SYS_MUTEX_PROTOCOL_FIFO;
	attr.attr_recursive = SYS_MUTEX_ATTR_NOT_RECURSIVE;
	attr.attr_pshared = SYS_MUTEX_ATTR_PSHARED;
	attr.attr_adaptive = SYS_MUTEX_ATTR_NOT_ADAPTIVE;
	strcpy(attr.name, "mutex");
	sysMutexCreate(&thread_mutex, &attr);

	//Threads.
	THREADS_RUNNING = 2;
	sys_ppu_thread_t pad_id, program_id;
	sysThreadCreate(&pad_id, pad_thread, (void*) &GLOBAL_EXIT, 1500, 0x400, 0, "pad");
	sysThreadCreate(&program_id, program_thread, (void*) &GLOBAL_EXIT, 1337, 0x400, 0, "program");

	//Create buffers.
	gcmContextData *context;
	void *host_addr = NULL;
	rsxBuffer buffers[MAX_BUFFERS];
	int currentBuffer = 0;

	//Allocate a 1Mb buffer, alligned to a 1Mb boundary to be our shared IO memory with the RSX.
	host_addr = memalign(1024*1024, HOST_SIZE);
	context = initScreen(host_addr, HOST_SIZE);

	//Get resolution.
	u16 width, height;
	getResolution(&width, &height);

	//Create buffers.
	int i;
	for(i = 0; i < MAX_BUFFERS; i++) {
		makeBuffer(&buffers[i], width, height, i);
	}
	flip(context, MAX_BUFFERS - 1);

	//Main loop.
	while(THREADS_RUNNING > 0) {
		//Prepare buffer.
		setRenderTarget(context, &buffers[currentBuffer]);
		waitFlip();

		//Flip buffer onto screen.
		flip(context, buffers[currentBuffer].id); 

		//Change buffer.
		currentBuffer++;
		if(currentBuffer >= MAX_BUFFERS) {
			currentBuffer = 0;
		}
	}

	//Free buffers.
	gcmSetWaitFlip(context);
	for(i = 0; i < MAX_BUFFERS; i++) {
		rsxFree(buffers[i].ptr);
	}
	rsxFinish(context, 1);
	free(host_addr);

	//Mutex destroy.
	sysMutexDestroy(thread_mutex);

	return 0;
}
Ejemplo n.º 23
0
 GLuint makeBuffer(const std::string &filePath){
     GLuint bufferName;
     glGenBuffers(1, &bufferName);
     makeBuffer(bufferName, filePath);
     return bufferName;
 }
Ejemplo n.º 24
0
NoRSX::NoRSX(int real_screen_type, int buffer_screen_type) : EventHandler(){
	screen_type = real_screen_type;
	buffer_type = buffer_screen_type;

	currentBuffer = 0;
	host_addr = memalign(1024*1024, HOST_SIZE);
	
	switch(real_screen_type){
		case RESOLUTION_1920x1080: {
			width=1920;height=1080;
			buffers[0].width=1920;buffers[0].height=1080;
			buffers[1].width=1920;buffers[1].height=1080;
		} break;
		case RESOLUTION_1280x720: {
			width=1280;height=720;
			buffers[0].width=1280;buffers[0].height=720;
			buffers[1].width=1280;buffers[1].height=720;
		} break;
		case RESOLUTION_720x576: {
			width=720;height=576;
			buffers[0].width=720;buffers[0].height=576;
			buffers[1].width=720;buffers[1].height=576;
		} break;
		case RESOLUTION_720x480: {
			width=720;height=480;
			buffers[0].width=720;buffers[0].height=480;
			buffers[1].width=720;buffers[1].height=480;
		} break;
		default:
			getResolution(&width,&height);
			switch(real_screen_type){
				default:
				case RESOLUTION_AUTO_LOWER_1080p: {
					if(height>=1080){
						real_screen_type = RESOLUTION_1280x720;
						width=1280;height=720;
						buffers[0].width=1280;buffers[0].height=720;
						buffers[1].width=1280;buffers[1].height=720;
					}else
						real_screen_type = RESOLUTION_AUTO;
				} break;
				case RESOLUTION_AUTO_LOWER_720p: {
					if(height>=720){
						real_screen_type = RESOLUTION_720x576;
						width=720;height=576;
						buffers[0].width=720;buffers[0].height=576;
						buffers[1].width=720;buffers[1].height=576;
					}else
						real_screen_type = RESOLUTION_AUTO;
				} break;
				case RESOLUTION_AUTO_LOWER_576p: {
					if(height>=576){
						real_screen_type = RESOLUTION_720x480;
						width=720;height=480;
						buffers[0].width=720;buffers[0].height=480;
						buffers[1].width=720;buffers[1].height=480;
					}else
						real_screen_type = RESOLUTION_AUTO;
				} break;
					real_screen_type = RESOLUTION_AUTO;
				break;
			}
		  break;
	}
	context = initScreen(host_addr, HOST_SIZE, real_screen_type, width, height);

	for(int i=0;i<2;i++)
		makeBuffer(&buffers[i],width,height,i);
	
	switch(buffer_screen_type){
		case RESOLUTION_1920x1080:
			width=1920; height=1080;
			break;
		case RESOLUTION_1280x720:
			width=1280; height=720;
			break;
		case RESOLUTION_720x576:
			width=720; height=576;
			break;
		case RESOLUTION_720x480:
			width=720; height=480;
			break;
		default:
			getResolution(&width,&height);
			break;
	}	
	
	buffer = makeMemBuffer(width,height,&buffer_size);
	buffer_size = buffers[0].width * buffers[0].height * sizeof(u32);
	
	
	flip(context, 0);
	setRenderTarget(context, &buffers[0]);
	RegisterCallBack(EVENT_SLOT0);
}