Esempio n. 1
0
  /*
   * re-program firmware: this entire function and all subroutines must run from RAM
   * (don't make this static!)
   */
  __attribute__ ((section (".coderam")))
  void flashFirmware(uint8_t* source, uint32_t size){
    __disable_irq(); // Disable ALL interrupts. Can only be executed in Privileged modes.
    setLed(RED);
    eeprom_unlock();
    if(size > (16+16+64+128)*1024){
      eeprom_erase_sector(FLASH_Sector_6);
      toggleLed(); // inline
    }
    if(size > (16+16+64)*1024){
      eeprom_erase_sector(FLASH_Sector_5);
      toggleLed();
    }
    if(size > (16+16)*1024){
      eeprom_erase_sector(FLASH_Sector_4);
      toggleLed();
    }
    if(size > 16*1024){
      eeprom_erase_sector(FLASH_Sector_3);
      toggleLed();
    }
    eeprom_erase_sector(FLASH_Sector_2);
    toggleLed();
    eeprom_write_block(ADDR_FLASH_SECTOR_2, source, size);
    eeprom_lock();
    eeprom_wait();
    NVIC_SystemReset(); // (static inline)
  }

  void programFlashTask(void* p){
    int sector = flashSectorToWrite;
    uint32_t size = flashSizeToWrite;
    uint8_t* source = (uint8_t*)flashAddressToWrite;
    if(sector >= 0 && sector < MAX_USER_PATCHES && size <= 128*1024){
      uint32_t addr = getFlashAddress(sector);
      eeprom_unlock();
      int ret = eeprom_erase(addr);
      if(ret == 0)
	ret = eeprom_write_block(addr, source, size);
      eeprom_lock();
      registry.init();
      if(ret == 0){
	// load and run program
	int pc = registry.getNumberOfPatches()-MAX_USER_PATCHES+sector;
	program.loadProgram(pc);
	// program.loadDynamicProgram(source, size);
	program.resetProgram(false);
      }else{
	setErrorMessage(PROGRAM_ERROR, "Failed to write program to flash");
      }
    }else if(sector == 0xff && size < MAX_SYSEX_FIRMWARE_SIZE){
      flashFirmware(source, size);
    }else{
      setErrorMessage(PROGRAM_ERROR, "Invalid flash program command");
    }
    vTaskDelete(NULL);
  }

  void eraseFlashTask(void* p){
    int sector = flashSectorToWrite;
    if(sector == 0xff){
      for(int i=0; i<MAX_USER_PATCHES; ++i)
	eraseFlashProgram(i);
      settings.clearFlash();
    }else if(sector >= 0 && sector < MAX_USER_PATCHES){
      eraseFlashProgram(sector);
    }else{
      setErrorMessage(PROGRAM_ERROR, "Invalid flash erase command");
    }
    registry.init();
    vTaskDelete(NULL);
  }

  // static int midiMessagesToSend = 0;
  // void sendMidiDataTask(void* p){
  //   switch(midiMessagesToSend){
  //   case SYSEX_PRESET_NAME_COMMAND:
  //     midi.sendPatchNames();
  //     break;
  //   // case 0:
  //   //   midi.sendDeviceInfo();
  //   //   break;
  //   // case SYSEX_PARAMETER_NAME_COMMAND:
  //   //   midi.sendPatchParameterNames();
  //   //   break;
  //   // case SYSEX_FIRMWARE_VERSION:
  //   //   midi.sendFirmwareVersion();
  //   //   break;
  //   // case SYSEX_DEVICE_ID:
  //   //   midi.sendDeviceId();
  //   //   break;
  //   // case SYSEX_DEVICE_STATS:
  //   //   midi.sendDeviceStats();
  //   //   break;
  //   // case SYSEX_PROGRAM_MESSAGE:
  //   //   midi.sendProgramMessage();
  //   //   break;
  //   // case SYSEX_PROGRAM_STATS:
  //   //   midi.sendProgramStats();
  //   //   break;
  //   // case PATCH_BUTTON:
  //   //   midi.sendCc(PATCH_BUTTON, isPushButtonPressed() ? 127 : 0);
  //   //   break;
  //   // case LED:
  //   //   midi.sendCc(LED, getLed() == NONE ? 0 : getLed() == GREEN ? 42 : 84);
  //   //   break;
  //   // case 127:
  //   //   midi.sendSettings();
  //   //   break;
  //   }
  //   midiMessagesToSend = -1;
  //   vTaskDelete(NULL);    
  // }

#ifdef BUTTON_PROGRAM_CHANGE
#ifndef abs
#define abs(x) ((x)>0?(x):-(x))
#endif /* abs */
  void programChangeTask(void* p){
    setLed(RED);
    int pc = settings.program_index;
    int bank = getAnalogValue(0)*5/4096;
    int prog = getAnalogValue(1)*8/4096+1;
    do{
      float a = getAnalogValue(0)*5/4096.0 - 0.5/5;
      float b = getAnalogValue(1)*8/4096.0 - 0.5/8;
      //      if(a - (int)a < 0.8) // deadband each segment: [0.8-1.0)
      if(a > 0 && abs(a - (int)a - 0.1) > 0.2) // deadband each segment: [0.9-1.1]
	bank = (int)a;
      if(b > 0 && abs(b-(int)b - 0.1) > 0.2)
	prog = (int)b+1;
      if(pc != bank*8+prog){
	toggleLed();
	pc = bank*8+prog;
	updateProgramIndex(pc);
	vTaskDelay(20);
      }
    }while(isPushButtonPressed() || pc < 1 || pc >= (int)registry.getNumberOfPatches());
    setLed(RED);
    program.loadProgram(pc);
    program.resetProgram(false);
    for(;;); // wait for program manager to delete this task
  }
Esempio n. 2
0
void InitApp(float width, float height)
{
	vec2 min, max;
	//fill in the blank
	min.x = -width/2;
	min.y = -height/2;
	max.x = width/2;
	max.y = height/2;

	pApp = new App();
	Screen* pScreen = new Screen(min.x, min.y, max.x, max.y); // create the screen so you can start using gl functions!
	//programs
	ProgramManager* pProgramManager = ProgramManager::GetProgramManager();
	int programID = pProgramManager->CreateProgram("vertex2.vert", "fragment2.frag");
	pProgramManager->AddProgram("program1", programID);
	//now add textures and programs to the App
	TextureManager* pTextureManager = TextureManager::GetTextureManager();
	pTextureManager->AddTexture("images/picture.png");
	
	//add objects
	vec2 quadDimensions = {512.0f, 512.0f};
	GLuint indices[6] = {0, 1, 3, 3, 1, 2};
	pScreen->SetMatrixUniform(); // set the projection matrix
	Quad* pQuad = new Quad(&quadDimensions, indices, 6, "images/picture.png", "program1");
	pScreen->AddObject(pQuad);
	pApp->AddObject(pScreen);
}
Esempio n. 3
0
  void programFlashTask(void* p){
    int sector = flashSectorToWrite;
    uint32_t size = flashSizeToWrite;
    uint8_t* source = (uint8_t*)flashAddressToWrite;
    if(sector >= 0 && sector < MAX_USER_PATCHES && size <= 128*1024){
      uint32_t addr = getFlashAddress(sector);
      eeprom_unlock();
      int ret = eeprom_erase(addr);
      if(ret == 0)
	ret = eeprom_write_block(addr, source, size);
      eeprom_lock();
      registry.init();
      if(ret == 0){
	// load and run program
	int pc = registry.getNumberOfPatches()-MAX_USER_PATCHES+sector;
	program.loadProgram(pc);
	// program.loadDynamicProgram(source, size);
	program.resetProgram(false);
      }else{
	setErrorMessage(PROGRAM_ERROR, "Failed to write program to flash");
      }
    }else if(sector == 0xff && size < MAX_SYSEX_FIRMWARE_SIZE){
      flashFirmware(source, size);
    }else{
      setErrorMessage(PROGRAM_ERROR, "Invalid flash program command");
    }
    vTaskDelete(NULL);
  }
Esempio n. 4
0
IntegratorFunction::IntegratorFunction(Domain* domain, Framework *framework, CLSSource::Function* function) :
    CallableFunction(domain, framework, function->parameters), m_program(NULL)
{
    ProgramManager* man = framework->getPrograManager();

    ProgramBuilder builder(m_framework->getComputeContext());
    size_t return_values = 0;
    m_program = man->manage(builder.createTimeIntegratorProgram(&m_domain, function, &return_values));

    for (int i = 0; i < return_values; ++i) {
        m_returnValues.push_back(framework->createData(*domain, ""));
    }
}
Esempio n. 5
0
int main( int argc, char* args[] )
{
	init();

	SDL_RenderPresent(gRenderer);

	ProgramManager* manager = new ProgramManager(gRenderer);
	manager->loop();
	delete manager;

	close();

	return 0;
}
/*!
	Initialize the scene, reserve shaders, compile and cache program

	\param[in] None.
	\return None

*/
void ObjLoader::InitModel()
{
	ProgramManager* ProgramManagerObj   = MapRenderHandler->RendererProgramManager();
	Transform*	TransformObj            = MapRenderHandler->RendererTransform();


	if (! ( program = ProgramManagerObj->Program( ( char * )"PolkaShader" ) ) )
	{
		program = ProgramManagerObj->ProgramInit( ( char * )"PolkaShader" );
		ProgramManagerObj->AddProgram( program );
	}

	program->VertexShader	= ShaderManager::ShaderInit( VERTEX_SHADER_PRG,	GL_VERTEX_SHADER	);
	program->FragmentShader	= ShaderManager::ShaderInit( FRAGMENT_SHADER_PRG, GL_FRAGMENT_SHADER	);

    //////////////////////////////////////////////////////
    /////////// Vertex shader //////////////////////////
    //////////////////////////////////////////////////////
	CACHE *m = reserveCache( VERTEX_SHADER_PRG, true );

	if( m ) {
		if( !ShaderManager::ShaderCompile( program->VertexShader, ( char * )m->buffer, 1 ) ) exit( 1 );
        freeCache( m );
	}

    /////////// Fragment shader //////////////////////////
	m = reserveCache( FRAGMENT_SHADER_PRG, true );
	if( m ) {
		if( !ShaderManager::ShaderCompile( program->FragmentShader, ( char * )m->buffer, 1 ) ) exit( 2 );
        freeCache( m );
	}

    if( !ProgramManagerObj->ProgramLink( program, 1 ) ) exit( 3 );

    // Use Phong Shade Program
    glUseProgram( program->ProgramID );
    
    char MaterialAmbient   = ProgramManagerObj->ProgramGetUniformLocation(program, (char*)"MaterialAmbient");
    char MaterialSpecular  = ProgramManagerObj->ProgramGetUniformLocation(program, (char*)"MaterialSpecular");
    char MaterialDiffuse   = ProgramManagerObj->ProgramGetUniformLocation(program, (char*)"MaterialDiffuse");
    char LightAmbient      = ProgramManagerObj->ProgramGetUniformLocation(program, (char*)"LightAmbient");
    char LightSpecular     = ProgramManagerObj->ProgramGetUniformLocation(program, (char*)"LightSpecular");
    char LightDiffuse      = ProgramManagerObj->ProgramGetUniformLocation(program, (char*)"LightDiffuse");
    char ShininessFactor   = ProgramManagerObj->ProgramGetUniformLocation(program, (char*)"ShininessFactor");
    char LightPosition     = ProgramManagerObj->ProgramGetUniformLocation(program, (char*)"LightPosition");
        timer              = ProgramManagerObj->ProgramGetUniformLocation(program, (char*)"Time");
    toggleIndex           = ProgramManagerObj->ProgramGetUniformLocation(program, (char*)"toggleDiscardBehaviour");
    char Side              = ProgramManagerObj->ProgramGetUniformLocation(program, (char*)"Side");
    char DotSize           = ProgramManagerObj->ProgramGetUniformLocation(program, (char*)"DotSize");
    
    char ModelColor           = ProgramManagerObj->ProgramGetUniformLocation(program, (char*)"ModelColor");
    char DotColor           = ProgramManagerObj->ProgramGetUniformLocation(program, (char*)"DotColor");
    char BackSideModelColor           = ProgramManagerObj->ProgramGetUniformLocation(program, (char*)"BackSideModelColor");
    char BackSideDotColor           = ProgramManagerObj->ProgramGetUniformLocation(program, (char*)"BackSideDotColor");
    
    if (MaterialAmbient >= 0){
        glUniform3f(MaterialAmbient, 0.04f, 0.04f, 0.04f);
    }
    
    if (MaterialSpecular >= 0){
        glUniform3f(MaterialSpecular, 1.0, 0.5, 0.5);
    }
    
    glm::vec3 color = glm::vec3(1.0, 1.0, 1.0);
    if (MaterialDiffuse >= 0){
        glUniform3f(MaterialDiffuse, color.r, color.g, color.b);
    }

    if (LightAmbient >= 0){
        glUniform3f(LightAmbient, 1.0f, 1.0f, 1.0f);
    }
    
    if (LightSpecular >= 0){
        glUniform3f(LightSpecular, 1.0, 1.0, 1.0);
    }

    if (LightDiffuse >= 0){
        glUniform3f(LightDiffuse, 1.0f, 1.0f, 1.0f);
    }

    if (ShininessFactor >= 0){
        glUniform1f(ShininessFactor, 40);
    }
    
    if (LightPosition >= 0){
        glUniform3f(LightPosition, 0.0, 0.0, 10.0 );
    }

    if ( toggleIndex >= 0 ){
        glUniform1i(toggleIndex, (int)toggle);
    }
    
    if ( Side >= 0 ){
        glUniform1f(Side, 0.30);
    }
    
    if ( DotSize >= 0 ){
        glUniform1f(DotSize, 0.13);
    }
    
    if (ModelColor >= 0){
        glUniform3f(ModelColor, 1.0, 1.0, 1.0 );
    }
    
    if (DotColor >= 0){
        glUniform3f(DotColor, 0.4, 0.5, 1.0 );
    }
    
    if (BackSideModelColor >= 0){
        glUniform3f(BackSideModelColor, 0.0, 1.0, 0.0 );
    }
    
    if (BackSideDotColor >= 0){
        glUniform3f(BackSideDotColor, 1.0, 1.0, 1.0 );
    }
    
    MVP = ProgramManagerObj->ProgramGetUniformLocation( program, ( char* )"ModelViewProjectionMatrix" );
    MV  = ProgramManagerObj->ProgramGetUniformLocation( program, ( char* )"ModelViewMatrix" );
    NormalMatrix  = ProgramManagerObj->ProgramGetUniformLocation(program, (char*)"NormalMatrix");
    

    return;
}
/*!
	Initialize the scene, reserve shaders, compile and cache program

	\param[in] None.
	\return None

*/
void ObjLoader::InitModel()
{
	ProgramManager* ProgramManagerObj   = MapRenderHandler->RendererProgramManager();
	Transform*	TransformObj            = MapRenderHandler->RendererTransform();


	if (! ( program = ProgramManagerObj->Program( ( char * )"ADSShader" ) ) )
	{
		program = ProgramManagerObj->ProgramInit( ( char * )"ADSShader" );
		ProgramManagerObj->AddProgram( program );
	}

	program->VertexShader	= ShaderManager::ShaderInit( VERTEX_SHADER_PRG,	GL_VERTEX_SHADER	);
	program->FragmentShader	= ShaderManager::ShaderInit( FRAGMENT_SHADER_PRG, GL_FRAGMENT_SHADER	);

    //////////////////////////////////////////////////////
    /////////// Vertex shader //////////////////////////
    //////////////////////////////////////////////////////
	CACHE *m = reserveCache( VERTEX_SHADER_PRG, true );

	if( m ) {
		if( !ShaderManager::ShaderCompile( program->VertexShader, ( char * )m->buffer, 1 ) ) exit( 1 );
        freeCache( m );
	}

    /////////// Fragment shader //////////////////////////
	m = reserveCache( FRAGMENT_SHADER_PRG, true );
	if( m ) {
		if( !ShaderManager::ShaderCompile( program->FragmentShader, ( char * )m->buffer, 1 ) ) exit( 2 );
        freeCache( m );
	}

    if( !ProgramManagerObj->ProgramLink( program, 1 ) ) exit( 3 );

    // Use Phong Shade Program
    glUseProgram( program->ProgramID );
    
    char MaterialAmbient   = ProgramManagerObj->ProgramGetUniformLocation(program, (char*)"MaterialAmbient");
    char MaterialSpecular  = ProgramManagerObj->ProgramGetUniformLocation(program, (char*)"MaterialSpecular");
    char MaterialDiffuse   = ProgramManagerObj->ProgramGetUniformLocation(program, (char*)"MaterialDiffuse");
    char LightAmbient      = ProgramManagerObj->ProgramGetUniformLocation(program, (char*)"LightAmbient");
    char LightSpecular     = ProgramManagerObj->ProgramGetUniformLocation(program, (char*)"LightSpecular");
    char LightDiffuse      = ProgramManagerObj->ProgramGetUniformLocation(program, (char*)"LightDiffuse");
    char ShininessFactor   = ProgramManagerObj->ProgramGetUniformLocation(program, (char*)"ShininessFactor");
    char LightPosition     = ProgramManagerObj->ProgramGetUniformLocation(program, (char*)"LightPosition");
    char ModelColor        = ProgramManagerObj->ProgramGetUniformLocation(program, (char*)"ModelColor");
    char DotColor          = ProgramManagerObj->ProgramGetUniformLocation(program, (char*)"DotColor");
    char Side              = ProgramManagerObj->ProgramGetUniformLocation(program, (char*)"Side");
    
    if (MaterialAmbient >= 0){
        glUniform3f(MaterialAmbient, 0.04f, 0.04f, 0.04f);
    }
    
    if (MaterialSpecular >= 0){
        glUniform3f(MaterialSpecular, 1.0, 1.0, 1.0);
    }
    
    glm::vec3 color = glm::vec3(1.0, 1.0, 0.0);
    if (MaterialDiffuse >= 0){
        glUniform3f(MaterialDiffuse, color.r, color.g, color.b);
    }
    
    if (LightAmbient >= 0){
        glUniform3f(LightAmbient, 1.0f, 1.0f, 1.0f);
    }
    
    if (LightSpecular >= 0){
        glUniform3f(LightSpecular, 1.0, 1.0, 1.0);
    }
    
    if (LightDiffuse >= 0){
        glUniform3f(LightDiffuse, 1.0f, 1.0f, 1.0f);
    }
    
    if (ShininessFactor >= 0){
        glUniform1f(ShininessFactor, 40);
    }
    
    if ( LightPosition >= 0 ){
        glm::vec3 lightPosition(0.0, 5.0, 10);
        glUniform3fv(LightPosition, 1, (float*)&lightPosition);
    }
    
    if ( ModelColor >= 0 ){
        glm::vec3 mColor(0.50, 0.50, 1.0);
        glUniform3fv(ModelColor, 1, (float*)&mColor);
    }

    if ( DotColor >= 0 ){
        glm::vec3 dColor(1.0, 1.0, 10);
        glUniform3fv(DotColor, 1, (float*)&dColor);
    }
    
    if ( Side >= 0 ){
        glUniform1f(Side, 80);
    }
    

    MVP = ProgramManagerObj->ProgramGetUniformLocation( program, ( char* )"ModelViewProjectionMatrix" );
    MV  = ProgramManagerObj->ProgramGetUniformLocation( program, ( char* )"ModelViewMatrix" );
    NormalMatrix  = ProgramManagerObj->ProgramGetUniformLocation(program, (char*)"NormalMatrix");
    
    return;
}
Esempio n. 8
0
void RenderDevice::render( const RenderState& state, const LightQueue& lights )
{
    BufferManager* buffers = activeContext->bufferManager;
    ProgramManager* programs = activeContext->programManager;
    
    RenderBatch* renderable = state.renderable;
    bindBuffers(renderable);

    const GeometryBuffer* gb = renderable->getGeometryBuffer().get();
    if( gb->data.Empty() ) return;

    BufferEntry* bufs = buffers->getBuffer(gb);

    // Setup the vertex buffer format.
    VertexBuffer* vb = bufs->vb.get();
    renderBackend->setupVertexBuffer(vb);
    
    Material* material = state.material;
    ShaderMaterial* shader = material->getShader().Resolve();

    ShaderProgram* shaderProgram = programs->getProgram(shader);
    if( !shaderProgram ) return;

    if( !shaderProgram->isLinked() && !shaderProgram->link() )
        return;

    shaderProgram->bind();

    renderBackend->setupRenderState(state, true);
    bindTextureUnits(state, true);

    if( !renderable->onPreRender.empty() )
    {
        // Call the user pre render hook.
        renderable->onPreRender(activeView, state);
    }

    RenderLayer stage = renderable->getRenderLayer();

    if( stage != RenderLayer::Overlays )
    {
        if( !setupRenderStateMatrix(state) )
            return;

        //if( !setupRenderStateLight(state, lights) )
        //  return;
    }
    else if( stage == RenderLayer::Overlays )
    {
        if( !setupRenderStateOverlay(state) )
            return;
    }

    UniformBuffer* ub = renderable->getUniformBuffer().get();
    shaderProgram->setUniforms(ub);

    renderBackend->renderBatch(renderable);
    
    if( !renderable->onPostRender.empty() )
    {
        // Call the user post render hook.
        renderable->onPostRender(activeView, state);
    }
    
    renderBackend->unsetupRenderState(state);
    unbindTextureUnits(state.material);
    
    shaderProgram->unbind();

    renderBackend->unbindVertexBuffer(vb);
    unbindBuffers(renderable);
}
Esempio n. 9
0
VOID Player::turn(ProgramManager &rProgramManager, GameInfo &rGameInfo)
{
	if(rGameInfo.first == first_)
	{
		if(rGameInfo.scoredEight) rProgramManager.endGame(name_ + L" выиграл со счЄтом: " + getScoreWStr());
		else if(rGameInfo.scoredZero)
		{ 
			rGameInfo.scoredZero = FALSE;
			rGameInfo.drawCue    = FALSE;
			rGameInfo.turn       = Turns::SetZeroPos;

			rProgramManager.updateZero();
		}
		else if(rGameInfo.scoredWrong)
		{
			rGameInfo.scoredWrong = FALSE;
			rGameInfo.drawCue     = FALSE;
			rGameInfo.turn        = Turns::SetPos;
		}

		if(!copied_) 
		{
			memcpy(tmpBallsStatus_, rProgramManager.getScored(), sizeof(tmpBallsStatus_));
			memcpy(tmpBallsPos_, rProgramManager.getPoints(), sizeof(tmpBallsPos_));

			copied_ = !copied_;
		}

		if(rGameInfo.turn == Turns::SetZeroPos)
		{ 
			rProgramManager.setBallCoords(rProgramManager.getMousePos());

			rProgramManager.work(textToDraw(), PointF(0, 0), static_cast<ARGB>(Color::LightGreen), FALSE);

			if(Key(VK_END)) 
			{
				rGameInfo.turn = Turns::Blow;

				rGameInfo.drawCue = TRUE;
			}
		}
		else if(rGameInfo.turn == Turns::SetPos)
		{
			rProgramManager.setBallCoords(rProgramManager.getMousePos(), rGameInfo.wrongBall);
			rProgramManager.work(textToDraw(), PointF(0, 0), static_cast<ARGB>(Color::LightGreen), FALSE);
			
			if(Key(VK_END)) 
			{
				rGameInfo.turn = Turns::Blow;

				rGameInfo.drawCue = TRUE;
			}
		}
		else if(rGameInfo.turn == Turns::Blow) 
		{	
			if(Key(VK_SPACE))
			{
				POINT cursor = { 0, 0 };
				GetCursorPos(&cursor);		

				rProgramManager.nextMove();
				rGameInfo.turn = Turns::Step;
			}
			else rProgramManager.work(textToDraw());
		}
		else if(rGameInfo.turn == Turns::Step)
		{
			if(!rProgramManager.stopBalls()) rProgramManager.work(textToDraw());
			else
			{
				updateScore(checkScored(rProgramManager, rGameInfo));
				if(!checkPoints(rProgramManager)) if(score_ != 0) score_--;
				resetValues();
				rGameInfo.resetToNext(); 
			}		
		}
	}
	else rProgramManager.work(textToDraw(), PointF(static_cast<REAL>(rProgramManager.getMemDCWindow().width - 6 * sizestenaRIGHT), 0), static_cast<ARGB>(Color::Red), rGameInfo.drawCue);
}
Esempio n. 10
0
WORD Player::checkScored(ProgramManager &rProgramManager, GameInfo &rGameInfo)
{
	WORD ret_val = 0;
	for(size_t i = 0; i < NUMBER_OF_BALLS; i++)
		if(tmpBallsStatus_[i] != rProgramManager.getScored()[i])
		{
			BallType ballType = getBallType(static_cast<Balls::Ball>(i));
			
			if(!rGameInfo.firstScore && ballType != BallType::Zero) 
			{
				rGameInfo.firstScore = !rGameInfo.firstScore;
				ballType_ = ballType;

				rGameInfo.ballType2 = (ballType_ == BallType::Solid)? BallType::Striped : BallType::Solid;
			}
			else if(ballType_ == BallType::NoType && rGameInfo.firstScore) ballType_ = rGameInfo.ballType2;
				 
			switch(ballType)
			{
			case BallType::Zero:
				rProgramManager.updateZero();
				rGameInfo.scoredZero = TRUE;
				if(score_ != 0) score_--;
				break;
			case BallType::Solid: 
				if(i == Balls::Ball::eighth)
				{
					rGameInfo.scoredEight = TRUE;
					score_ = 0;

					return FALSE;
				}
				else
				{
					if(ballType_ == BallType::Solid) 
					{
						rGameInfo.scored = TRUE;
						ret_val++;
					}
					else 
					{
						rGameInfo.scoredWrong = TRUE;
						rGameInfo.wrongBall = static_cast<Balls::Ball>(i);
						if(score_ != 0) score_--;
					}
				}
				break;
			case BallType::Striped: 
				if(ballType_ == BallType::Striped) ret_val++;
				else 
				{
					rGameInfo.scoredWrong = TRUE;
					rGameInfo.wrongBall = static_cast<Balls::Ball>(i);
					if(score_ != 0) score_--;
				}
				break;
			default: PostQuitMessage(-999);
			}			
		}
	
	return ret_val;
}
Esempio n. 11
0
 void runManagerTask(void* p){
   setup(); // call main OWL setup
   program.runManager();
 }
Esempio n. 12
0
PatchDefinition* getPatchDefinition(){
  return program.getPatchDefinition();
}
/*!
	Initialize the scene, reserve shaders, compile and cache program

	\param[in] None.
	\return None

*/
void ObjLoader::InitModel()
{
	ProgramManager* ProgramManagerObj   = MapRenderHandler->RendererProgramManager();
	Transform*	TransformObj            = MapRenderHandler->RendererTransform();


	if (! ( program = ProgramManagerObj->Program( ( char * )"SpecularShader" ) ) )
	{
		program = ProgramManagerObj->ProgramInit( ( char * )"SpecularShader" );
		ProgramManagerObj->AddProgram( program );
	}

	program->VertexShader	= ShaderManager::ShaderInit( VERTEX_SHADER_PRG,	GL_VERTEX_SHADER	);
	program->FragmentShader	= ShaderManager::ShaderInit( FRAGMENT_SHADER_PRG, GL_FRAGMENT_SHADER	);

    /////////// Vertex shader //////////////////////////
	CACHE *m = reserveCache( VERTEX_SHADER_PRG, true );

	if( m ) {
		if( !ShaderManager::ShaderCompile( program->VertexShader, ( char * )m->buffer, 1 ) ) exit( 1 );
        freeCache( m );
	}

    /////////// Fragment shader //////////////////////////
	m = reserveCache( FRAGMENT_SHADER_PRG, true );
	if( m ) {
		if( !ShaderManager::ShaderCompile( program->FragmentShader, ( char * )m->buffer, 1 ) ) exit( 2 );
        freeCache( m );
	}

    if( !ProgramManagerObj->ProgramLink( program, 1 ) ) exit( 3 );

    glUseProgram( program->ProgramID );
    
    char MaterialSpecular  = ProgramManagerObj->ProgramGetUniformLocation(program, (char*)"MaterialSpecular");
    char LightSpecular     = ProgramManagerObj->ProgramGetUniformLocation(program, (char*)"LightSpecular");
    char ShininessFactor   = ProgramManagerObj->ProgramGetUniformLocation(program, (char*)"ShininessFactor");
    char LightPosition     = ProgramManagerObj->ProgramGetUniformLocation(program, (char*)"LightPosition");

    if (MaterialSpecular >= 0){
        glUniform3f(MaterialSpecular, 1.0, 0.5, 0.5);
    }
    
    if (LightSpecular >= 0){
        glUniform3f(LightSpecular, 1.0, 1.0, 1.0);
    }

    if (ShininessFactor >= 0){
        glUniform1f(ShininessFactor, 40);
    }
    
    if (LightPosition >= 0){
        glm::vec3 lightPosition(0.0, 0.0, 10.0);
        glUniform3fv(LightPosition, 1, (float*)&lightPosition);
    }
    
    MVP = ProgramManagerObj->ProgramGetUniformLocation( program, ( char* )"ModelViewProjectionMatrix" );
    MV  = ProgramManagerObj->ProgramGetUniformLocation( program, ( char* )"ModelViewMatrix" );
    NormalMatrix  = ProgramManagerObj->ProgramGetUniformLocation(program, (char*)"NormalMatrix");

    return;
}