void cFurnaceEntity::OnSlotChanged(cItemGrid * a_ItemGrid, int a_SlotNum)
{
super::OnSlotChanged(a_ItemGrid, a_SlotNum);
if (m_World == NULL)
{
// The furnace isn't initialized yet, do no processing
return;
}
ASSERT(a_ItemGrid == &m_Contents);
switch (a_SlotNum)
{
case fsInput:
{
UpdateInput();
break;
}
case fsFuel:
{
UpdateFuel();
break;
}
case fsOutput:
{
UpdateOutput();
break;
}
}
}
bool GameScene::Frame(float gameTime, int frameRate)
{
bool result;
// Read user input
result = m_Input->Frame();
if(!result)
{
return false;
}
// Update game time
m_GameTime->Frame();
// Update position
result = UpdateInput(m_GameTime->GetTime());
if(!result)
{
return false;
}
// Render the graphics scene.
result = Render();
if(!result)
{
return false;
}
return true;
}
// Explicit calculation which is used to test the wallet constant
// We get the same virtual size due to rounding(weight/4) for both use_max_sig values
static size_t CalculateNestedKeyhashInputSize(bool use_max_sig)
{
// Generate ephemeral valid pubkey
CKey key;
key.MakeNewKey(true);
CPubKey pubkey = key.GetPubKey();
// Generate pubkey hash
uint160 key_hash(Hash160(pubkey.begin(), pubkey.end()));
// Create inner-script to enter into keystore. Key hash can't be 0...
CScript inner_script = CScript() << OP_0 << std::vector<unsigned char>(key_hash.begin(), key_hash.end());
// Create outer P2SH script for the output
uint160 script_id(Hash160(inner_script.begin(), inner_script.end()));
CScript script_pubkey = CScript() << OP_HASH160 << std::vector<unsigned char>(script_id.begin(), script_id.end()) << OP_EQUAL;
// Add inner-script to key store and key to watchonly
CBasicKeyStore keystore;
keystore.AddCScript(inner_script);
keystore.AddKeyPubKey(key, pubkey);
// Fill in dummy signatures for fee calculation.
SignatureData sig_data;
if (!ProduceSignature(keystore, use_max_sig ? DUMMY_MAXIMUM_SIGNATURE_CREATOR : DUMMY_SIGNATURE_CREATOR, script_pubkey, sig_data)) {
// We're hand-feeding it correct arguments; shouldn't happen
assert(false);
}
CTxIn tx_in;
UpdateInput(tx_in, sig_data);
return (size_t)GetVirtualTransactionInputSize(tx_in);
}
void WaterLandscapeDemoScene::OnUpdate(TimeT currentTime, TimeT deltaTime)
{
UpdateInput();
// Every quarter second, generate a random wave
static float t_base = 0.0f;
if (currentTime - t_base >= 0.25f)
{
GenerateRandomWave();
}
// Make sure the water mesh is kept up to date with ripple animations
mWaterMesh->Update(deltaTime);
mCamera->Update(currentTime, deltaTime);
// The point light circles the scene as a function of time, staying seven units above the land's
// or water's surface.
mLights[1].pos.x = 50.0f * cosf((float)currentTime);
mLights[1].pos.z = 50.0f * sinf((float)currentTime);
mLights[1].pos.y = 7.0f + std::max(mTerrainMesh->GetHeight(mLights[1].pos.x, mLights[1].pos.z), 0.0f);
// The spotlight takes on the camera position and is aimed in the same direction as the camera is
// looking. In this way it looks like we are holding a flashlight.
mLights[2].pos = mCamera->Position();
D3DXVec3Normalize(&mLights[2].dir, &(mCamera->Target() - mCamera->Position()));
}
//-----------------------------------------------------------------------------
// Name: FrameMove()
// Desc: Called once per frame, the call is the entry point for animating
// the scene.
//-----------------------------------------------------------------------------
HRESULT CMyApplication::FrameMove()
{
// Update user input state
UpdateInput();
for( DWORD iPlayer=0; iPlayer<m_dwNumPlayers; iPlayer++ )
{
// Respond to input
if( m_UserInput[iPlayer].bDoConfigureInput )
{
// One-shot per keypress
m_UserInput[iPlayer].bDoConfigureInput = FALSE;
ConfigInput();
}
// Update the world state according to user input
if( m_UserInput[iPlayer].fAxisMoveUD )
m_fWorldRotY += m_fElapsedTime * m_UserInput[iPlayer].fAxisMoveUD;
if( m_UserInput[iPlayer].fAxisRotateLR )
m_fWorldRotX += m_fElapsedTime * m_UserInput[iPlayer].fAxisRotateLR;
}
return S_OK;
}
//----------------------------------------------------------------------------
void Application::UpdateLogic() {
#ifndef MULTITHREADED
// Update Input
UpdateInput();
// Update time variable
// Run the game logic
if (!isPaused) Update();
// Render frame
UpdateFrame();
// Update physics simulation
UpdatePhysics();
// Update logic done after physics
if (!isPaused) UpdateLate();
// Update sound system
UpdateSound();
// Update delta time
// Calculate FPS
// Increment current frame variable TODO: removeme
currentFrame++;
#ifdef _DEBUG
// Update Debug Console
UpdateDebug();
#endif
#endif
}
static void resetMappings(unsigned long key)
{
g_config->setOption("SDL.Input.GamePad.0A", DefaultGamePad[0][0]);
g_config->setOption("SDL.Input.GamePad.0B", DefaultGamePad[0][1]);
g_config->setOption("SDL.Input.GamePad.0TurboA", DefaultGamePad[0][8]);
g_config->setOption("SDL.Input.GamePad.0TurboB", DefaultGamePad[0][9]);
UpdateInput(g_config);
}
bool CGame::Loop() {
UpdateGFXStart();
UserGFX();
UpdateGFXEnd();
UpdateInput();
return G_QUIT;
}
//-------------------------------------------------------------
// Name: FrameMove()
// Desc: 매 프레임마다 호출됨. 애니메이션 처리등 담당
//-------------------------------------------------------------
HRESULT CMyD3DApplication::FrameMove()
{
UpdateInput( &m_UserInput ); // 입력데이터 갱신
//---------------------------------------------------------
// 입력에 따라 좌표계를 갱신한다
//---------------------------------------------------------
// 회전
D3DXMATRIX matRotY;
D3DXMATRIX matRotX;
if( m_UserInput.bRotateLeft && !m_UserInput.bRotateRight )
m_fWorldRotY += m_fElapsedTime;
else
if( m_UserInput.bRotateRight && !m_UserInput.bRotateLeft )
m_fWorldRotY -= m_fElapsedTime;
if( m_UserInput.bRotateUp && !m_UserInput.bRotateDown )
m_fWorldRotX += m_fElapsedTime;
else
if( m_UserInput.bRotateDown && !m_UserInput.bRotateUp )
m_fWorldRotX -= m_fElapsedTime;
D3DXMatrixRotationX( &matRotX, m_fWorldRotX );
D3DXMatrixRotationY( &matRotY, m_fWorldRotY );
D3DXMatrixMultiply( &m_mWorld, &matRotY, &matRotX );
//---------------------------------------------------------
// 뷰행렬 설정
//---------------------------------------------------------
// 줌
if( m_UserInput.bZoomIn && !m_UserInput.bZoomOut )
m_fViewZoom += m_fElapsedTime;
else if( m_UserInput.bZoomOut && !m_UserInput.bZoomIn )
m_fViewZoom -= m_fElapsedTime;
D3DXVECTOR3 vFromPt = D3DXVECTOR3( 0.0f, 0.0f, -m_fViewZoom );
D3DXVECTOR3 vLookatPt = D3DXVECTOR3( 0.0f, 0.0f, 0.0f );
D3DXVECTOR3 vUpVec = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );
D3DXMatrixLookAtLH( &m_mView, &vFromPt, &vLookatPt, &vUpVec );
if( m_UserInput.bDispersionUp && !m_UserInput.bDispersionDown ){
m_dispersion_sq += m_fElapsedTime;
this->UpdateWeight(m_dispersion_sq*m_dispersion_sq);
} else
if( m_UserInput.bDispersionDown && !m_UserInput.bDispersionUp ){
m_dispersion_sq -= m_fElapsedTime;
this->UpdateWeight(m_dispersion_sq*m_dispersion_sq);
}
return S_OK;
}
bool SignSignature(const SigningProvider &provider, const CScript& fromPubKey, CMutableTransaction& txTo, unsigned int nIn, const CAmount& amount, int nHashType)
{
assert(nIn < txTo.vin.size());
MutableTransactionSignatureCreator creator(&txTo, nIn, amount, nHashType);
SignatureData sigdata;
bool ret = ProduceSignature(provider, creator, fromPubKey, sigdata);
UpdateInput(txTo.vin.at(nIn), sigdata);
return ret;
}
static int Set(nulloutput* p, int No, const void* Data, int Size)
{
int Result = ERR_INVALID_PARAM;
switch (No)
{
case OUT_INPUT: SETVALUE(p->Pin,pin,ERR_NONE); break;
case OUT_INPUT|PIN_FORMAT: SETPACKETFORMAT(p->Format,packetformat,UpdateInput(p)); break;
case OUT_TOTAL: SETVALUE(p->Total,int,ERR_NONE); break;
case OUT_DROPPED: SETVALUE(p->Dropped,int,ERR_NONE); break;
}
return Result;
}
void NCursesFrontend::Update(int key)
{
// Figure out how big the screen is
CalcWindowSizes();
if (m_dataUpdatePos <= 0)
{
FreeData();
m_neededLogEntries = m_messagesWinClientHeight;
if (!PrepareData())
{
return;
}
// recalculate frame sizes
CalcWindowSizes();
}
if (m_inputMode == editQueue)
{
int queueSize = CalcQueueSize();
if (queueSize == 0)
{
m_selectedQueueEntry = 0;
m_inputMode = normal;
}
}
//------------------------------------------
// Print Current NZBInfoList
//------------------------------------------
if (m_queueWinHeight > 0)
{
PrintQueue();
}
//------------------------------------------
// Print Messages
//------------------------------------------
if (m_messagesWinHeight > 0)
{
PrintMessages();
}
PrintStatus();
PrintKeyInputBar();
UpdateInput(key);
RefreshScreen();
}
int WaveOutBaseSet(waveout_base* p, int No, const void* Data, int Size)
{
int Result = ERR_INVALID_PARAM;
switch (No)
{
case OUT_INPUT|PIN_FORMAT: SETPACKETFORMAT(p->Input,packetformat,UpdateInput(p)); break;
case OUT_INPUT: SETVALUE(p->Pin,pin,ERR_NONE); break;
case OUT_TOTAL: SETVALUE(p->Total,int,ERR_NONE); break;
case OUT_DROPPED: SETVALUE(p->Dropped,int,ERR_NONE); break;
case AOUT_STEREO: SETVALUECMP(p->Stereo,int,UpdateInput(p),EqInt); break;
case AOUT_QUALITY: SETVALUECMP(p->Quality,int,UpdateInput(p),EqInt); break;
}
return Result;
}
//-------------------------------------------------------------
// Name: FrameMove()
// Desc: �� �����Ӹ��� ȣ���. �ִϸ��̼� ó���� ���
//-------------------------------------------------------------
HRESULT CMyD3DApplication::FrameMove()
{
// UFO�� �����δ�
m_pos.x = 1.5f*(FLOAT)cos(1.0f*this->m_fTime)+1.0f;
m_pos.z = 1.5f*(FLOAT)sin(1.0f*this->m_fTime);
m_pos.y = 1.3f;
UpdateInput( &m_UserInput ); // �Էµ����� ����
//---------------------------------------------------------
// �Է¿� ���� ��ǥ�踦 �����Ѵ�
//---------------------------------------------------------
// ȸ��
D3DXMATRIX matRotY;
D3DXMATRIX matRotX;
if( m_UserInput.bRotateLeft && !m_UserInput.bRotateRight )
m_fWorldRotY += m_fElapsedTime;
else
if( m_UserInput.bRotateRight && !m_UserInput.bRotateLeft )
m_fWorldRotY -= m_fElapsedTime;
if( m_UserInput.bRotateUp && !m_UserInput.bRotateDown )
m_fWorldRotX += m_fElapsedTime;
else
if( m_UserInput.bRotateDown && !m_UserInput.bRotateUp )
m_fWorldRotX -= m_fElapsedTime;
D3DXMatrixRotationX( &matRotX, m_fWorldRotX );
D3DXMatrixRotationY( &matRotY, m_fWorldRotY );
D3DXMatrixMultiply( &m_mWorld, &matRotY, &matRotX );
//---------------------------------------------------------
// ����� ����
//---------------------------------------------------------
// ��
if( m_UserInput.bZoomIn && !m_UserInput.bZoomOut )
m_fViewZoom += m_fElapsedTime;
else if( m_UserInput.bZoomOut && !m_UserInput.bZoomIn )
m_fViewZoom -= m_fElapsedTime;
D3DXVECTOR3 vFromPt = D3DXVECTOR3( 0.0f, 0.0f, -m_fViewZoom );
D3DXVECTOR3 vLookatPt = D3DXVECTOR3( 0.0f, 0.0f, 0.0f );
D3DXVECTOR3 vUpVec = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );
D3DXMatrixLookAtLH( &m_mView, &vFromPt, &vLookatPt, &vUpVec );
return S_OK;
}
//-------------------------------------------------------------
// Name: FrameMove()
// Desc: 매 프레임마다 호출됨. 애니메이션 처리등 담당
//-------------------------------------------------------------
HRESULT CMyD3DApplication::FrameMove()
{
// 입력데이터 갱신
UpdateInput( &m_UserInput );
//---------------------------------------------------------
// 입력에 따라 좌표계를 갱신한다
//---------------------------------------------------------
// 회전
D3DXMATRIX matRotY;
D3DXMATRIX matRotX;
D3DXMATRIX mCamera;
if( m_UserInput.bRotateLeft && !m_UserInput.bRotateRight )
m_fWorldRotY += m_fElapsedTime;
else
if( m_UserInput.bRotateRight && !m_UserInput.bRotateLeft )
m_fWorldRotY -= m_fElapsedTime;
if( m_UserInput.bRotateUp && !m_UserInput.bRotateDown )
m_fWorldRotX += m_fElapsedTime;
else
if( m_UserInput.bRotateDown && !m_UserInput.bRotateUp )
m_fWorldRotX -= m_fElapsedTime;
D3DXMatrixRotationX( &matRotX, m_fWorldRotX );
D3DXMatrixRotationY( &matRotY, m_fWorldRotY );
D3DXMatrixMultiply( &mCamera, &matRotY, &matRotX );
//---------------------------------------------------------
// 뷰행렬 설정
//---------------------------------------------------------
// 줌(zoom)
if( m_UserInput.bZoomIn && !m_UserInput.bZoomOut )
m_fViewZoom += m_fElapsedTime;
else if( m_UserInput.bZoomOut && !m_UserInput.bZoomIn )
m_fViewZoom -= m_fElapsedTime;
m_vFromPt = D3DXVECTOR4( 0.0f, 0.f, -m_fViewZoom,1 );
D3DXVECTOR3 vLookatPt = D3DXVECTOR3( 0.0f, 0.0f, 0.0f );
D3DXVECTOR3 vUpVec = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );
D3DXMatrixLookAtLH( &m_mView, (D3DXVECTOR3*)&m_vFromPt, &vLookatPt, &vUpVec );
m_mView = mCamera * m_mView;
return S_OK;
}
bool Engine::Update()
{ BROFILER_FRAME("MainThread")
UpdateInput();
UpdateMessages();
UpdateLogic();
UpdateScene();
UpdatePhysics();
Draw();
return true;
}
int CodecSet(codec* p, int No, const void* Data, int Size)
{
int Result = ERR_INVALID_PARAM;
switch (No)
{
case CODEC_INPUT: SETVALUE(p->In.Pin,pin,ERR_NONE); break;
case CODEC_INPUT|PIN_FORMAT: SETPACKETFORMAT(p->In.Format,packetformat,UpdateInput(p)); break;
case CODEC_OUTPUT: SETVALUE(p->Out.Pin,pin,ERR_NONE); break;
case CODEC_OUTPUT|PIN_FORMAT: if (p->UpdateOutput) SETPACKETFORMAT(p->In.Format,packetformat,p->UpdateOutput(p)); break;
case CODEC_OUTPUT|PIN_PROCESS: SETVALUE(p->Out.Process,packetprocess,ERR_NONE); break;
case CODEC_COMMENT: SETVALUE(p->Comment,pin,ERR_NONE); break;
case FLOW_FLUSH: Result = Flush(p); break;
case FLOW_RESEND: if (p->ReSend) Result = p->ReSend(p); break;
case FLOW_NOT_SUPPORTED: SETVALUE(p->NotSupported,pin,ERR_NONE); break;
}
return Result;
}
//-------------------------------------------------------------
// Name: FrameMove()
// Desc: ¸Å ÇÁ·¹ÀÓ¸¶´Ù È£ÃâµÊ. ¾Ö´Ï¸ÞÀÌ¼Ç Ã³¸®µî ´ã´ç
//-------------------------------------------------------------
HRESULT CMyD3DApplication::FrameMove()
{
UpdateInput( &m_UserInput ); // ÀԷµ¥ÀÌÅÍ °»½Å
//---------------------------------------------------------
// ÀԷ¿¡ µû¶ó ÁÂÇ¥°è¸¦ °»½ÅÇÑ´Ù
//---------------------------------------------------------
// ȸÀü
D3DXMATRIX matRotY;
D3DXMATRIX matRotX;
if( m_UserInput.bRotateLeft && !m_UserInput.bRotateRight )
m_fWorldRotY += m_fElapsedTime;
else
if( m_UserInput.bRotateRight && !m_UserInput.bRotateLeft )
m_fWorldRotY -= m_fElapsedTime;
if( m_UserInput.bRotateUp && !m_UserInput.bRotateDown )
m_fWorldRotX += m_fElapsedTime;
else
if( m_UserInput.bRotateDown && !m_UserInput.bRotateUp )
m_fWorldRotX -= m_fElapsedTime;
D3DXMatrixRotationX( &matRotX, m_fWorldRotX );
D3DXMatrixRotationY( &matRotY, m_fWorldRotY );
D3DXMatrixMultiply( &m_mWorld, &matRotY, &matRotX );
//---------------------------------------------------------
// ºäÇà·Ä ¼³Á¤
//---------------------------------------------------------
// ÁÜ
if( m_UserInput.bZoomIn && !m_UserInput.bZoomOut )
m_fViewZoom += m_fElapsedTime;
else if( m_UserInput.bZoomOut && !m_UserInput.bZoomIn )
m_fViewZoom -= m_fElapsedTime;
D3DXVECTOR3 vFromPt = D3DXVECTOR3( 0.0f, 0.2f, -m_fViewZoom );
D3DXVECTOR3 vLookatPt = D3DXVECTOR3( 0.0f, 0.5f, 0.0f );
D3DXVECTOR3 vUpVec = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );
D3DXMatrixLookAtLH( &m_mView, &vFromPt, &vLookatPt, &vUpVec );
return S_OK;
}
void MultiAgentTest::MyUpdateEventHandler( sml::smlUpdateEventId, void*, sml::Kernel* pKernel, sml::smlRunFlags )
{
int agents = pKernel->GetNumberAgents() ;
for (int agentIndex = 0 ; agentIndex < agents ; ++agentIndex)
{
sml::Agent* pAgent = pKernel->GetAgentByIndex( agentIndex ) ;
CPPUNIT_ASSERT( pAgent != NULL );
char const* pIOString = pAgent->ExecuteCommandLine( "print --depth 4 i1" ) ;
CPPUNIT_ASSERT( pIOString != NULL );
//std::cout << pIOString << std::endl ;
// Make sure we can get the output link (had a bug where this wouldn't always work)
sml::Identifier* pOutputLink = pAgent->GetOutputLink() ;
CPPUNIT_ASSERT( pOutputLink != NULL );
// Read in the commands
int numberCommands = pAgent->GetNumberCommands() ;
for ( int i = 0 ; i < numberCommands ; ++i )
{
sml::Identifier* pCommand = pAgent->GetCommand( i ) ;
CPPUNIT_ASSERT( pCommand != NULL );
char const* pName = pCommand->GetCommandName() ;
CPPUNIT_ASSERT( pName != NULL );
CPPUNIT_ASSERT( std::string( pName ) == "result" );
// Receive the new total
char const* pTotal = pCommand->GetParameterValue( "total" ) ;
CPPUNIT_ASSERT( pTotal != NULL );
std::stringstream paramValue( pTotal );
int intTotal = 0;
paramValue >> intTotal;
// Mark command as completed in working memory
pCommand->AddStatusComplete() ;
// Place a new addition request on the input link
UpdateInput( pAgent, intTotal );
}
}
}
bool Update()
{
Stackit;
float Delta;
if(CoreSys.KeyState(HGEK_ESCAPE))
return true;
Delta = CoreSys.Delta();
UpdateInput(Delta);
lpCoreDynBody->Update(Delta);
lpShip->Update(Delta);
ScrollOffset.x = lpShip->CoreBody::Center.x - (float)(CoreSys.Config->Width >> 1);
ScrollOffset.y = lpShip->CoreBody::Center.y - (float)(CoreSys.Config->Height >> 1);
lpCoreFlareList->Update(Delta);
return false;
}
//-------------------------------------------------------------
// Name: FrameMove()
// Desc: �� �����Ӹ��� ȣ���. �ִϸ��̼� ó���� ���
//-------------------------------------------------------------
HRESULT CMyD3DApplication::FrameMove()
{
UpdateInput( &m_UserInput );// ���̓f�[�^�̍X�V
//---------------------------------------------------------
// �Է¿� ���� ��ǥ�踦 �����Ѵ�
//---------------------------------------------------------
// ȸ��
D3DXMATRIX m;
D3DXMATRIX matRotY;
D3DXMATRIX matRotX;
if( m_UserInput.bRotateLeft && !m_UserInput.bRotateRight )
m_fWorldRotY += m_fElapsedTime;
else if( m_UserInput.bRotateRight && !m_UserInput.bRotateLeft )
m_fWorldRotY -= m_fElapsedTime;
if( m_UserInput.bRotateUp && !m_UserInput.bRotateDown )
m_fWorldRotX += m_fElapsedTime;
else if( m_UserInput.bRotateDown && !m_UserInput.bRotateUp )
m_fWorldRotX -= m_fElapsedTime;
//---------------------------------------------------------
// ��� ����
//---------------------------------------------------------
// ���� ȸ��
D3DXMatrixRotationX( &matRotX, m_fWorldRotX );
D3DXMatrixRotationY( &matRotY, m_fWorldRotY );
D3DXMatrixMultiply( &m, &matRotX, &matRotY );
// �����
D3DXVECTOR3 vFromPt = D3DXVECTOR3( 0.0f, 2.73f, -8.0f );
D3DXVECTOR3 vLookatPt = D3DXVECTOR3( 0.0f, 2.73f, 0.0f );
D3DXVECTOR3 vUpVec = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );
D3DXMatrixLookAtLH( &m_mView, &vFromPt, &vLookatPt, &vUpVec );
m_mView = m * m_mView;
m_pd3dDevice->SetTransform( D3DTS_VIEW, &m_mView );
return S_OK;
}
void Game::UpdateGame(void) {
UpdateInput();
if(_ingameMenu.GetStatus() == false) {
_map.Update();
_player->Update();
if(gameOver) {
gameOver = false;
_map.New();
_player->SetHealth(100);
_player->SetLevelLiteral(1);
_player->SetExpLiteral(0);
New(_saveGameID);
}
} else {
// :D
}
}
void cCamera::Update(float deltaTime)
{
UpdateInput(deltaTime);
esMatrixLoadIdentity( & Camera );
if(m_enabled)
{
cVector2di mousePos=INPUT->getMousePos();
float rotatex=(float)(mousePos.x-m_prevMouseX);
float rotatey=(float)(mousePos.y-m_prevMouseY);
m_currentRot.x+=rotatex;
m_currentRot.z+=rotatey;
m_prevMouseX=mousePos.x;
m_prevMouseY=mousePos.y;
}
esTranslate(&Camera,m_currentPos.x,m_currentPos.y,m_currentPos.z);
esRotate(&Camera,m_currentRot.x,0,1,0);
esRotate(&Camera,m_currentRot.z,1,0,0);
InverseMatrix(Camera,View);
}
void cFurnaceEntity::OnSlotChanged(cItemGrid * a_ItemGrid, int a_SlotNum)
{
super::OnSlotChanged(a_ItemGrid, a_SlotNum);
if (m_IsDestroyed)
{
return;
}
if (m_IsLoading)
{
return;
}
ASSERT(a_ItemGrid == &m_Contents);
switch (a_SlotNum)
{
case fsInput: UpdateInput(); break;
case fsFuel: UpdateFuel(); break;
case fsOutput: UpdateOutput(); break;
default: ASSERT(!"Invalid furnace slot update!"); break;
}
}
int CodecIDCTSet(codecidct* p, int No, const void* Data, int Size)
{
node* Advanced;
int Result = ERR_INVALID_PARAM;
switch (No)
{
case CODECIDCT_INPUT: SETVALUE(p->In.Pin,pin,ERR_NONE); break;
case CODECIDCT_INPUT|PIN_FORMAT: SETPACKETFORMAT(p->In.Format,packetformat,UpdateInput(p)); break;
case CODECIDCT_IDCT:
assert(Size==sizeof(idct*));
Result = SetIDCT(p,*(idct**)Data);
break;
case FLOW_NOT_SUPPORTED: SETVALUE(p->NotSupported,pin,ERR_NONE); break;
case FLOW_FLUSH: Result = Flush(p); break;
case NODE_SETTINGSCHANGED:
Advanced = Context()->Advanced;
if (Advanced)
Advanced->Get(Advanced,ADVANCED_DROPTOL,&p->DropTolerance,sizeof(tick_t));
break;
}
return Result;
}
//-------------------------------------------------------------
// Name: FrameMove()
// Desc: 매 프레임마다 호출됨. 애니메이션 처리등 담당
//-------------------------------------------------------------
HRESULT CMyD3DApplication::FrameMove()
{
UpdateInput( &m_UserInput ); // 입력데이터 갱신
return S_OK;
}
static void setTurboA(unsigned long key)
{
g_config->setOption("SDL.Input.GamePad.0TurboA", keyCheck(key));
UpdateInput(g_config);
}
void PageRecord::StartOutput() {
assert(m_page_started);
if(m_output_started)
return;
if(m_simple_synth != NULL) {
m_simple_synth->PlaySequence(SEQUENCE_RECORD_START.data(), SEQUENCE_RECORD_START.size());
usleep(200000);
}
try {
Logger::LogInfo("[PageRecord::StartOutput] " + tr("Starting output ..."));
if(m_output_manager == NULL) {
// set the file name
if(m_separate_files)
m_output_settings.file = GetNewSegmentFile(m_file_base);
// for OpenGL recording, detect the application size
if(m_video_area == PageInput::VIDEO_AREA_GLINJECT && !m_video_scaling) {
if(m_gl_inject_input == NULL) {
Logger::LogError("[PageRecord::StartOutput] " + tr("Error: Could not get the size of the OpenGL application because the GLInject input has not been created."));
throw GLInjectException();
}
m_gl_inject_input->GetCurrentSize(&m_video_in_width, &m_video_in_height);
if(m_video_in_width == 0 && m_video_in_height == 0) {
Logger::LogError("[PageRecord::StartOutput] " + tr("Error: Could not get the size of the OpenGL application. Either the "
"application wasn't started correctly, or the application hasn't created an OpenGL window yet. If "
"you want to start recording before starting the application, you have to enable scaling and enter "
"the video size manually."));
throw GLInjectException();
}
}
// calculate the output width and height
if(m_video_scaling) {
// Only even width and height is allowed because the final images are encoded as YUV.
m_output_settings.video_width = m_video_scaled_width / 2 * 2;
m_output_settings.video_height = m_video_scaled_height / 2 * 2;
} else if(m_video_area == PageInput::VIDEO_AREA_GLINJECT) {
// The input size is the size of the OpenGL application and can't be changed. The output size is set to the current size of the application.
m_output_settings.video_width = m_video_in_width / 2 * 2;
m_output_settings.video_height = m_video_in_height / 2 * 2;
} else {
// If the user did not explicitly select scaling, then don't force scaling just because the recording area is one pixel too large.
// One missing row/column of pixels is probably better than a blurry video (and scaling is SLOW).
m_video_in_width = m_video_in_width / 2 * 2;
m_video_in_height = m_video_in_height / 2 * 2;
m_output_settings.video_width = m_video_in_width;
m_output_settings.video_height = m_video_in_height;
}
// start the output
m_output_manager.reset(new OutputManager(m_output_settings));
} else {
// start a new segment
m_output_manager->GetSynchronizer()->NewSegment();
}
Logger::LogInfo("[PageRecord::StartOutput] " + tr("Started output."));
m_output_started = true;
m_recorded_something = true;
UpdateSysTray();
UpdateRecordPauseButton();
UpdateInput();
} catch(...) {
Logger::LogError("[PageRecord::StartOutput] " + tr("Error: Something went wrong during initialization."));
}
}
void PageRecord::StartPage() {
if(m_page_started)
return;
assert(!m_input_started);
assert(!m_output_started);
// save the settings in case libav/ffmpeg decides to kill the process
m_main_window->SaveSettings();
// clear the log
m_textedit_log->clear();
// clear the preview
if(m_previewing) {
m_video_previewer->Reset();
m_audio_previewer->Reset();
}
PageInput *page_input = m_main_window->GetPageInput();
PageOutput *page_output = m_main_window->GetPageOutput();
// get the video input settings
m_video_area = page_input->GetVideoArea();
m_video_x = page_input->GetVideoX();
m_video_y = page_input->GetVideoY();
if(m_video_area == PageInput::VIDEO_AREA_GLINJECT) {
m_video_in_width = 0;
m_video_in_height = 0;
} else {
m_video_in_width = page_input->GetVideoW();
m_video_in_height = page_input->GetVideoH();
}
m_video_frame_rate = page_input->GetVideoFrameRate();
m_video_scaling = page_input->GetVideoScalingEnabled();
m_video_scaled_width = page_input->GetVideoScaledW();
m_video_scaled_height = page_input->GetVideoScaledH();
m_video_record_cursor = page_input->GetVideoRecordCursor();
// get the audio input settings
m_audio_enabled = page_input->GetAudioEnabled();
m_audio_channels = 2;
m_audio_sample_rate = 44100;
m_audio_backend = page_input->GetAudioBackend();
m_alsa_source = page_input->GetALSASourceName();
#if SSR_USE_PULSEAUDIO
m_pulseaudio_source = page_input->GetPulseAudioSourceName();
#endif
#if SSR_USE_JACK
bool jack_connect_system_capture = page_input->GetJackConnectSystemCapture();
bool jack_connect_system_playback = page_input->GetJackConnectSystemPlayback();
#endif
// get the glinject settings
QString glinject_channel = page_input->GetGLInjectChannel();
bool glinject_relax_permissions = page_input->GetGLInjectRelaxPermissions();
QString glinject_command = page_input->GetGLInjectCommand();
QString glinject_working_directory = page_input->GetGLInjectWorkingDirectory();
bool glinject_auto_launch = page_input->GetGLInjectAutoLaunch();
bool glinject_limit_fps = page_input->GetGLInjectLimitFPS();
// get file settings
m_file_base = page_output->GetFile();
m_file_protocol = page_output->GetFileProtocol();
m_separate_files = page_output->GetSeparateFiles();
// get the output settings
if(m_separate_files)
m_output_settings.file = QString(); // will be set later
else
m_output_settings.file = m_file_base;
m_output_settings.container_avname = page_output->GetContainerAVName();
m_output_settings.video_codec_avname = page_output->GetVideoCodecAVName();
m_output_settings.video_kbit_rate = page_output->GetVideoKBitRate();
m_output_settings.video_options.clear();
m_output_settings.video_width = 0;
m_output_settings.video_height = 0;
m_output_settings.video_frame_rate = m_video_frame_rate;
m_output_settings.video_allow_frame_skipping = page_output->GetVideoAllowFrameSkipping();
m_output_settings.audio_codec_avname = (m_audio_enabled)? page_output->GetAudioCodecAVName() : QString();
m_output_settings.audio_kbit_rate = page_output->GetAudioKBitRate();
m_output_settings.audio_options.clear();
m_output_settings.audio_channels = m_audio_channels;
m_output_settings.audio_sample_rate = m_audio_sample_rate;
// some codec-specific things
// you can get more information about all these options by running 'ffmpeg -h' or 'avconv -h' from a terminal
switch(page_output->GetVideoCodec()) {
case PageOutput::VIDEO_CODEC_H264: {
// x264 has a 'constant quality' mode, where the bit rate is simply set to whatever is needed to keep a certain quality. The quality is set
// with the 'crf' option. 'preset' changes the encoding speed (and hence the efficiency of the compression) but doesn't really influence the quality,
// which is great because it means you don't have to experiment with different bit rates and different speeds to get good results.
m_output_settings.video_options.push_back(std::make_pair(QString("crf"), QString::number(page_output->GetH264CRF())));
m_output_settings.video_options.push_back(std::make_pair(QString("preset"), EnumToString(page_output->GetH264Preset())));
break;
}
case PageOutput::VIDEO_CODEC_VP8: {
// The names of there parameters are very unintuitive. The two options we care about (because they change the speed) are 'deadline' and 'cpu-used'.
// 'deadline=best' is unusably slow. 'deadline=good' is the normal setting, it tells the encoder to use the speed set with 'cpu-used'. Higher
// numbers will use *less* CPU, confusingly, so a higher number is faster. I haven't done much testing with 'realtime' so I'm not sure if it's a good idea here.
// It sounds useful, but I think it will use so much CPU that it will slow down the program that is being recorded.
m_output_settings.video_options.push_back(std::make_pair(QString("deadline"), QString("good")));
m_output_settings.video_options.push_back(std::make_pair(QString("cpu-used"), QString::number(page_output->GetVP8CPUUsed())));
break;
}
case PageOutput::VIDEO_CODEC_OTHER: {
m_output_settings.video_options = GetOptionsFromString(page_output->GetVideoOptions());
break;
}
default: break; // to keep GCC happy
}
switch(page_output->GetAudioCodec()) {
case PageOutput::AUDIO_CODEC_OTHER: {
m_output_settings.audio_options = GetOptionsFromString(page_output->GetAudioOptions());
break;
}
default: break; // to keep GCC happy
}
// hide the audio previewer if there is no audio
GroupVisible({m_label_mic_icon, m_audio_previewer}, m_audio_enabled);
Logger::LogInfo("[PageRecord::StartPage] " + tr("Starting page ..."));
try {
// for OpenGL recording, create the input now
if(m_video_area == PageInput::VIDEO_AREA_GLINJECT) {
if(glinject_auto_launch)
GLInjectInput::LaunchApplication(glinject_channel, glinject_relax_permissions, glinject_command, glinject_working_directory);
m_gl_inject_input.reset(new GLInjectInput(glinject_channel, glinject_relax_permissions, m_video_record_cursor, glinject_limit_fps, m_video_frame_rate));
}
#if SSR_USE_JACK
if(m_audio_enabled) {
// for JACK, start the input now
if(m_audio_backend == PageInput::AUDIO_BACKEND_JACK)
m_jack_input.reset(new JACKInput(jack_connect_system_capture, jack_connect_system_playback));
}
#endif
} catch(...) {
Logger::LogError("[PageRecord::StartPage] " + tr("Error: Something went wrong during initialization."));
m_gl_inject_input.reset();
#if SSR_USE_JACK
m_jack_input.reset();
#endif
}
Logger::LogInfo("[PageRecord::StartPage] " + tr("Started page."));
m_page_started = true;
m_recorded_something = false;
m_wait_saving = false;
UpdateSysTray();
OnUpdateHotkey();
OnUpdateSoundNotifications();
UpdateInput();
OnUpdateInformation();
m_timer_update_info->start(1000);
}
//=============================================================================
int main(int argc, char *argv[])
{
printf("INFO: Monster Outrage v %d\n", VERSION);
try
{
InitSDL();
LoadMedia();
InitGame();
bool quit = false;
uint ticks = SDL_GetTicks();
while(!quit)
{
// handle events
SDL_Event e;
while(SDL_PollEvent(&e) != 0)
{
if(e.type == SDL_QUIT)
quit = true;
else if(e.type == SDL_KEYDOWN)
{
if(e.key.state == SDL_PRESSED)
ProcessKey(e.key.keysym.scancode, true);
}
else if(e.type == SDL_KEYUP)
{
if(e.key.state == SDL_RELEASED)
ProcessKey(e.key.keysym.scancode, false);
}
else if(e.type == SDL_MOUSEMOTION || e.type == SDL_MOUSEBUTTONDOWN || e.type == SDL_MOUSEBUTTONUP)
{
SDL_GetMouseState(&cursor_pos.x, &cursor_pos.y);
if(e.type == SDL_MOUSEBUTTONDOWN)
{
if(e.button.state == SDL_PRESSED && e.button.button < MAX_BUTTON)
ProcessButton(e.button.button, true);
}
else if(e.type == SDL_MOUSEBUTTONUP)
{
if(e.button.state == SDL_RELEASED && e.button.button < MAX_BUTTON)
ProcessButton(e.button.button, false);
}
}
}
// calculate dt
uint new_ticks = SDL_GetTicks();
float dt = float(new_ticks - ticks)/1000.f;
ticks = new_ticks;
Draw();
Update(dt);
UpdateInput();
}
CleanGame();
CleanMedia();
CleanSDL();
}
catch(cstring err)
{
printf("%s\nERROR: Read error and press any key to exit.\n", err);
_getch();
return 1;
}
return 0;
}