void FlatShader::CreateEffectFromFile( wchar_t* FXFileName )
{
_Assert(NULL != UtilityShader::pool);
D3DXCreateEffectFromFile(gEngine->GetDriver()->GetD3DDevice(), FXFileName, NULL, NULL, D3DXSHADER_DEBUG, UtilityShader::pool, &mEffect, NULL);
_Assert(NULL != mEffect);
}
void ShadowMapRenderer::DrawMeshShadowTexPass(const D3DXMATRIX& matWorld, Geometry* geo, Camera* camera)
{
_Assert(NULL != geo);
geo->SetVertexStream();
geo->SetVertexDeclaration();
mShadowTexEffect->SetTechnique("Shadow");
mShadowTexEffect->SetMatrix("matWVP", &(matWorld * camera->ViewMatrix() * camera->ProjMatrix()));
mShadowTexEffect->SetMatrix("matWorld", &matWorld);
_Assert(CASCADE_COUNTS >= 3);
mShadowTexEffect->SetMatrix("matLightVP0", &mVirtualCamera[0].matVP);
mShadowTexEffect->SetMatrix("matLightVP1", &mVirtualCamera[1].matVP);
mShadowTexEffect->SetMatrix("matLightVP2", &mVirtualCamera[2].matVP);
mShadowTexEffect->SetRawValue("lightPos0", &(mVirtualCamera[0].pos), 0, sizeof(Vector3));
mShadowTexEffect->SetRawValue("lightPos1", &(mVirtualCamera[1].pos), 0, sizeof(Vector3));
mShadowTexEffect->SetRawValue("lightPos2", &(mVirtualCamera[2].pos), 0, sizeof(Vector3));
mShadowTexEffect->SetTexture("shadowMapTex0", mShadowMapBluredTex[0]->GetD3DTexture());
mShadowTexEffect->SetTexture("shadowMapTex1", mShadowMapBluredTex[1]->GetD3DTexture());
mShadowTexEffect->SetTexture("shadowMapTex2", mShadowMapBluredTex[2]->GetD3DTexture());
float farZ = 0;
camera->GetCameraParams(NULL, &farZ, NULL, NULL);
mShadowTexEffect->SetFloat("farZ", farZ);
mShadowTexEffect->CommitChanges();
geo->Draw();
}
void ShadowMapRenderer::createTextures()
{
SAFE_DELETE(mShadowMapTex);
SAFE_DELETE(mShadowMapBluredTexH);
SAFE_DELETE(mShadowTex);
for(int i = 0; i < CASCADE_COUNTS; ++i)
SAFE_DELETE(mShadowMapBluredTex[i]);
mShadowMapTex = New Texture;
mShadowMapTex->Create(SHADOW_MAP_SIZE, SHADOW_MAP_SIZE, D3DFMT_G32R32F, D3DUSAGE_RENDERTARGET);
mShadowMapBluredTexH = New Texture;
mShadowMapBluredTexH->Create(SHADOW_MAP_SIZE, SHADOW_MAP_SIZE, D3DFMT_G32R32F, D3DUSAGE_RENDERTARGET);
for(int i = 0; i < CASCADE_COUNTS; ++i)
{
mShadowMapBluredTex[i] = New Texture;
mShadowMapBluredTex[i]->Create(SHADOW_MAP_SIZE, SHADOW_MAP_SIZE, D3DFMT_G32R32F, D3DUSAGE_RENDERTARGET);
_Assert(mShadowMapBluredTex[i] != NULL);
}
mShadowTex = New Texture;
mShadowTex->Create(SHADOW_TEX_SIZE, SHADOW_TEX_SIZE, D3DFMT_A8R8G8B8, D3DUSAGE_RENDERTARGET);
_Assert(mShadowMapTex != NULL);
_Assert(mShadowTex != NULL);
}
static Thread_queue_Heads *_Thread_queue_Queue_enqueue(
Thread_queue_Queue *queue,
Thread_Control *the_thread,
void ( *initialize )( Thread_queue_Heads *, Thread_Control * ),
void ( *enqueue )( Thread_queue_Heads *, Thread_Control * )
)
{
Thread_queue_Heads *heads;
Thread_queue_Heads *spare_heads;
heads = queue->heads;
spare_heads = the_thread->Wait.spare_heads;
the_thread->Wait.spare_heads = NULL;
if ( heads == NULL ) {
_Assert( spare_heads != NULL );
_Assert( _Chain_Is_empty( &spare_heads->Free_chain ) );
heads = spare_heads;
queue->heads = heads;
_Chain_Prepend_unprotected( &heads->Free_chain, &spare_heads->Free_node );
( *initialize )( heads, the_thread );
} else {
_Chain_Prepend_unprotected( &heads->Free_chain, &spare_heads->Free_node );
( *enqueue )( heads, the_thread );
}
return heads;
}
/// Game
BZGame::BZGame(CAStageLayer* player) : BZBoard(player)
{
GUARD_FUNCTION();
_name = "na";
_nCounter = 0;
_nScore = 0;
_typesCount = 0;
if (_typesCount < BLOCK_TYPES) _types[_typesCount++] = "bubble_a"; else _Assert(false);
if (_typesCount < BLOCK_TYPES) _types[_typesCount++] = "bubble_b"; else _Assert(false);
if (_typesCount < BLOCK_TYPES) _types[_typesCount++] = "bubble_c"; else _Assert(false);
if (_typesCount < BLOCK_TYPES) _types[_typesCount++] = "bubble_d"; else _Assert(false);
if (_typesCount < BLOCK_TYPES) _types[_typesCount++] = "bubble_e"; else _Assert(false);
//_types[_typesCount++] = "bird";
_nGameStatesCount = 0;
memset(_oldGameStates, 0, sizeof(_oldGameStates));
setState(GS_Idle);
_timeLastBorn = 0;
//_VerifyClass(this);
}
void ModelPreviewCanvas::AddjustCameraPos()
{
_Assert(mCamera != NULL);
_Assert(mModel != NULL);
AABBox bound;
mModel->CalcDynamicAABBox(IDENTITY_MATRIX, &bound);
float width = bound.GetSize().x;
float height = bound.GetSize().y;
float length = bound.GetSize().z;
float aspect = 0;
float fov = 0;
mCamera->GetCameraParams(NULL, NULL, &fov, &aspect);
float distY = (height / 2.0f) / tan(fov / 2.0f);
float distX = (height / 2.0f) / (aspect * tan(fov / 2.0f));
float dist = Max(distX, distY);
mCamera->SetWorldPosition(bound.GetCenter());
mCamera->Translate(0, 0, -dist - length);
mCamera->LookAt(bound.GetCenter());
HoverCameraController* hoverCameraController = New HoverCameraController(5.0f, 20.0f, -4*PI/9, 4*PI/9,
2.0f, 1000.0f, bound.GetCenter(), dist + length);
mCamera->SetCameraController(hoverCameraController);
}
void _Thread_Exit(
Thread_Control *executing,
Thread_Life_state set,
void *exit_value
)
{
ISR_lock_Context lock_context;
_Assert(
_Watchdog_Get_state( &executing->Timer.Watchdog ) == WATCHDOG_INACTIVE
);
_Assert(
executing->current_state == STATES_READY
|| executing->current_state == STATES_SUSPENDED
);
_Thread_State_acquire( executing, &lock_context );
_Thread_Set_exit_value( executing, exit_value );
_Thread_Change_life_locked(
executing,
0,
set,
THREAD_LIFE_PROTECTED | THREAD_LIFE_CHANGE_DEFERRED
);
_Thread_State_release( executing, &lock_context );
}
int clsDump::DumpScope(clsScope * pScope, int onlyCalculateSize)
{
int iSize = 0;
unsigned int iIndex;
iSize += DumpLine("----- SCOPE BEG -----\n", onlyCalculateSize);
iSize += DumpLine("\tUID %u\n", pScope->m_UID, onlyCalculateSize);
iSize += DumpLocation(pScope->m_Location, onlyCalculateSize);
_Assert(pScope->m_pParentScope && "Frontend Error: All scopes should have a parent.");
iSize += DumpLine("\tParent Scope UID %u\n", pScope->m_pParentScope->m_UID, onlyCalculateSize);
_Assert(pScope->m_pRootScope && "Frontend Error: All scopes should have a root.");
iSize += DumpLine("\tRoot Scope UID %u\n", pScope->m_pRootScope->m_UID, onlyCalculateSize);
iSize += DumpLine("\tNumber of Children Scopes %u\n", pScope->m_pChildrenScopes.size(), onlyCalculateSize);
for (iIndex = 0; iIndex < pScope->m_pChildrenScopes.size(); ++iIndex)
{
iSize += DumpLine("\tChild Scope UID %u\n", pScope->m_pChildrenScopes[iIndex]->m_UID, onlyCalculateSize);
}
iSize += DumpLine("\tNumber of Signals %u\n", pScope->m_pSignals.size(), onlyCalculateSize);
for (iIndex = 0; iIndex < pScope->m_pSignals.size(); ++iIndex)
{
iSize += DumpLine("\tSignal UID %u\n", pScope->m_pSignals[iIndex]->m_UID, onlyCalculateSize);
}
iSize += DumpLine("\tNumber of Arguments %u\n", pScope->m_pArguments.size(), onlyCalculateSize);
for (iIndex = 0; iIndex < pScope->m_pArguments.size(); ++iIndex)
{
iSize += DumpLine("\tArgument UID %u\n", pScope->m_pArguments[iIndex]->m_UID, onlyCalculateSize);
}
iSize += DumpLine("\tNumber of Parameters %u\n", pScope->m_pParameters.size(), onlyCalculateSize);
for (iIndex = 0; iIndex < pScope->m_pParameters.size(); ++iIndex)
{
iSize += DumpLine("\tParameter UID %u\n", pScope->m_pParameters[iIndex]->m_UID, onlyCalculateSize);
}
iSize += DumpLine("\tNumber of Conditions %u\n", pScope->m_pConditions.size(), onlyCalculateSize);
for (iIndex = 0; iIndex < pScope->m_pConditions.size(); ++iIndex)
{
iSize += DumpLine("\tCondition UID %u\n", pScope->m_pConditions[iIndex]->m_UID, onlyCalculateSize);
}
iSize += DumpLine("\tNumber of Events %u\n", pScope->m_pEvents.size(), onlyCalculateSize);
for (iIndex = 0; iIndex < pScope->m_pEvents.size(); ++iIndex)
{
iSize += DumpLine("\tEvent UID %u\n", pScope->m_pEvents[iIndex]->m_UID, onlyCalculateSize);
}
if (pScope->m_pBasicBlock)
{
iSize += DumpLine("\tHas Basicblock %u\n", true, onlyCalculateSize);
iSize += DumpLine("\tBasicblock UID %u\n", pScope->m_pBasicBlock->m_UID, onlyCalculateSize);
}
else
{
iSize += DumpLine("\tHas No Basicblock %u\n", false, onlyCalculateSize);
}
iSize += DumpString("\tScope Name\n", pScope->m_sScopeName, onlyCalculateSize);
iSize += DumpLine("\tScope Type UID %u\n", pScope->m_pScopeType->m_UID, onlyCalculateSize);
iSize += DumpLine("\tScope is Root = %u\n", pScope->m_IsRoot, onlyCalculateSize);
iSize += DumpLine("\tScope is Automatic = %u\n", pScope->m_IsAutomatic, onlyCalculateSize);
iSize += DumpLine("----- SCOPE END -----\n", onlyCalculateSize);
return iSize;
}
void BumpSpecularShader::Render(const D3DXMATRIX& matWorld, Geometry* geo, Camera* camera, bool isStandAlone)
{
_Assert(NULL != geo);
_Assert(NULL != camera);
geo->SetVertexStream();
geo->SetVertexDeclaration();
BumpSpecularShader::mEffect->SetTechnique("BumpSpecular");
BumpSpecularShader::mEffect->SetMatrix("matWVP", &(matWorld * camera->ViewMatrix() * camera->ProjMatrix()));
BumpSpecularShader::mEffect->SetMatrix("matWorld", &matWorld);
BumpSpecularShader::mEffect->SetMatrix("matUVTransform", &(mMaterial->UVTransformMatrix()));
BumpSpecularShader::mEffect->SetRawValue("eyePos", &(camera->GetRelativePosition()), 0, sizeof(Vector3));
if(NULL == mMaterial->GetTexture(0))
{
BumpSpecularShader::mEffect->SetBool("useColorTex", false);
}
else
{
BumpSpecularShader::mEffect->SetBool("useColorTex", true);
BumpSpecularShader::mEffect->SetTexture("colorTex", mMaterial->GetTexture(0)->GetD3DTexture());
}
if(gEngine->GetSceneManager()->NeedDirLightShadow())
{
BumpSpecularShader::mEffect->SetBool("calcShadow", true);
BumpSpecularShader::mEffect->SetTexture("shadowTex", ShadowMapRenderer::GetShadowTex()->GetD3DTexture());
}
else
{
BumpSpecularShader::mEffect->SetBool("calcShadow", false);
}
BumpSpecularShader::mEffect->SetTexture("normalTex", mMaterial->GetTexture(1)->GetD3DTexture());
BumpSpecularShader::mEffect->SetRawValue("mtlAmbient", &(mMaterial->GetAmbientColor()), 0, sizeof(D3DXCOLOR));
BumpSpecularShader::mEffect->SetRawValue("mtlDiffuse", &(mMaterial->GetDiffuseColor()), 0, sizeof(D3DXCOLOR));
BumpSpecularShader::mEffect->SetRawValue("mtlSpec", &(mMaterial->GetFinalSpecularColor()), 0, sizeof(D3DXCOLOR));
BumpSpecularShader::mEffect->SetFloat("gloss", mMaterial->GetSpecGloss());
BumpSpecularShader::mEffect->CommitChanges();
if(isStandAlone)
{
BumpSpecularShader::mEffect->Begin(0, 0);
BumpSpecularShader::mEffect->BeginPass(0);
}
geo->Draw();
if(isStandAlone)
{
BumpSpecularShader::mEffect->EndPass();
BumpSpecularShader::mEffect->End();
}
}
bool BZStagePlayLayerGamePlay::checkCondition(CAState* from, const CATransition& trans)
{
//root.idle: inner condition
//root.running: button event
if (CAMachine::checkCondition(from, trans))
return true;
bool result = false;
float timeout = trans.timeout;
if (timeout > 0 && this->getTimeNow() - from->getTimeEnter() > timeout)
{
return true;
}
string fname = from->getFullName();
if (CAString::startWith(fname, "root.fade"))
{
const char* pszPose = "fadein";
if (fname == "root.fadein")
{
}
else if (fname == "root.fadeout")
{
pszPose = "fadeout";
}
else
{
_Assert(false);
}
if (result)
{
string result = "";
result += from->getFullName();
result += "@";
result += trans.condition;
this->setConditionResult(result.c_str(), true);
}
}
else if (fname == "root.diving")
{
}
else if (fname == "root.resume" || fname == "root.restart")
{
CAStageLayer* pl = this->getSubLayer("game.play.pause");
_Assert(pl);
_Assert(trans.condition == "pause.isidle" || trans.condition == "over.isidle");
if (pl->getCurrentState()->getFullName() == "root.idle")
{
return true;
}
}
if (CAMachine::checkCondition(from, trans))
return true;
return false;
}
static void _Thread_Start_life_change_for_executing(
Thread_Control *executing
)
{
_Assert( executing->Timer.state == WATCHDOG_INACTIVE );
_Assert(
executing->current_state == STATES_READY
|| executing->current_state == STATES_SUSPENDED
);
_Thread_Add_life_change_action( executing );
}
void ShadowMapRenderer::createRendertargetDepthStencil()
{
SAFE_RELEASE(mShadowMapRTSurface);
SAFE_RELEASE(mDepthStencilSurface);
gEngine->GetDriver()->GetD3DDevice()->CreateRenderTarget(SHADOW_MAP_SIZE, SHADOW_MAP_SIZE, D3DFMT_G32R32F,
D3DMULTISAMPLE_8_SAMPLES, 0, false, &mShadowMapRTSurface, NULL);
gEngine->GetDriver()->GetD3DDevice()->CreateDepthStencilSurface(SHADOW_MAP_SIZE, SHADOW_MAP_SIZE, D3DFMT_D24X8,
D3DMULTISAMPLE_8_SAMPLES, 0, true, &mDepthStencilSurface, NULL);
_Assert(mShadowMapRTSurface != NULL);
_Assert(mDepthStencilSurface != NULL);
}
Objects_Control *_Objects_Get_by_name(
const Objects_Information *information,
const char *name,
size_t *name_length_p,
Objects_Get_by_name_error *error
)
{
size_t name_length;
size_t max_name_length;
uint32_t index;
_Assert( information->is_string );
_Assert( _Objects_Allocator_is_owner() );
if ( name == NULL ) {
*error = OBJECTS_GET_BY_NAME_INVALID_NAME;
return NULL;
}
name_length = strnlen( name, information->name_length + 1 );
max_name_length = information->name_length;
if ( name_length > max_name_length ) {
*error = OBJECTS_GET_BY_NAME_NAME_TOO_LONG;
return NULL;
}
if ( name_length_p != NULL ) {
*name_length_p = name_length;
}
for ( index = 1; index <= information->maximum; index++ ) {
Objects_Control *the_object;
the_object = information->local_table[ index ];
if ( the_object == NULL )
continue;
if ( the_object->name.name_p == NULL )
continue;
if ( strncmp( name, the_object->name.name_p, max_name_length ) == 0 ) {
return the_object;
}
}
*error = OBJECTS_GET_BY_NAME_NO_OBJECT;
return NULL;
}
bool _Thread_queue_Do_extract_locked(
Thread_queue_Queue *queue,
const Thread_queue_Operations *operations,
Thread_Control *the_thread
#if defined(RTEMS_MULTIPROCESSING)
,
const Thread_queue_Context *queue_context
#endif
)
{
bool success;
bool unblock;
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) ) {
Thread_Proxy_control *the_proxy;
Thread_queue_MP_callout mp_callout;
the_proxy = (Thread_Proxy_control *) the_thread;
mp_callout = queue_context->mp_callout;
_Assert( mp_callout != NULL );
the_proxy->thread_queue_callout = queue_context->mp_callout;
}
#endif
( *operations->extract )( queue, the_thread );
/*
* We must update the wait flags under protection of the current thread lock,
* otherwise a _Thread_Timeout() running on another processor may interfere.
*/
success = _Thread_Wait_flags_try_change_release(
the_thread,
THREAD_QUEUE_INTEND_TO_BLOCK,
THREAD_QUEUE_READY_AGAIN
);
if ( success ) {
unblock = false;
} else {
_Assert( _Thread_Wait_flags_get( the_thread ) == THREAD_QUEUE_BLOCKED );
_Thread_Wait_flags_set( the_thread, THREAD_QUEUE_READY_AGAIN );
unblock = true;
}
_Thread_Wait_restore_default( the_thread );
return unblock;
}
void _Timer_Cancel( Per_CPU_Control *cpu, Timer_Control *the_timer )
{
Timer_Classes the_class;
the_class = the_timer->the_class;
if ( _Watchdog_Is_scheduled( &the_timer->Ticker ) ) {
the_timer->stop_time = _Timer_Get_CPU_ticks( cpu );
_Watchdog_Remove(
&cpu->Watchdog.Header[ _Timer_Watchdog_header_index( the_class ) ],
&the_timer->Ticker
);
} else if ( _Timer_Is_on_task_class( the_class ) ) {
Timer_server_Control *timer_server;
ISR_lock_Context lock_context;
timer_server = _Timer_server;
_Assert( timer_server != NULL );
_Timer_server_Acquire_critical( timer_server, &lock_context );
if ( _Watchdog_Get_state( &the_timer->Ticker ) == WATCHDOG_PENDING ) {
_Watchdog_Set_state( &the_timer->Ticker, WATCHDOG_INACTIVE );
_Chain_Extract_unprotected( &the_timer->Ticker.Node.Chain );
}
_Timer_server_Release_critical( timer_server, &lock_context );
}
}
static void _Thread_queue_Priority_priority_change(
Thread_queue_Queue *queue,
Thread_Control *the_thread,
Priority_Control new_priority
)
{
Thread_queue_Heads *heads;
Thread_queue_Priority_queue *priority_queue;
Scheduler_Node *scheduler_node;
heads = queue->heads;
_Assert( heads != NULL );
priority_queue = _Thread_queue_Priority_queue( heads, the_thread );
scheduler_node = _Scheduler_Thread_get_own_node( the_thread );
_RBTree_Extract(
&priority_queue->Queue,
&scheduler_node->Wait.Node.RBTree
);
_RBTree_Insert_inline(
&priority_queue->Queue,
&scheduler_node->Wait.Node.RBTree,
&new_priority,
_Thread_queue_Priority_less
);
}
void *_Freechain_Get(
Freechain_Control *freechain,
Freechain_Allocator allocator,
size_t number_nodes_to_extend,
size_t node_size
)
{
_Assert( node_size >= sizeof( Chain_Node ) );
if ( _Chain_Is_empty( &freechain->Free ) && number_nodes_to_extend > 0 ) {
void *starting_address;
starting_address = ( *allocator )( number_nodes_to_extend * node_size );
number_nodes_to_extend *= ( starting_address != NULL );
_Chain_Initialize(
&freechain->Free,
starting_address,
number_nodes_to_extend,
node_size
);
}
return _Chain_Get_unprotected( &freechain->Free );
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 缩放所有窗口
VOID CClientWnd::OnPlayZoom(UINT uCmd)
{
RECT rtMain;
RECT rtClient;
RECT rtChild;
SendMessage(m_hWnd, WM_MDICASCADE, 0, 0);
HWND hWnd = GetWindow(m_hWnd, GW_CHILD);
for (hWnd = GetWindow(hWnd, GW_HWNDFIRST); hWnd; )
{
_Assert(GetChildWnd(hWnd));
GetChildWnd(hWnd)->OnPlayZoom(uCmd, FALSE);
hWnd = GetWindow(hWnd, GW_HWNDNEXT);
}
if (m_bScrabble)
{
GetWindowRect(CMainWnd::m_hWnd, &rtMain);
GetClientRect(m_hWnd, &rtClient);
hWnd = GetWindow(GetWindow(m_hWnd, GW_CHILD), GW_HWNDFIRST);
GetWindowRect(hWnd, &rtChild);
MoveWindow(CMainWnd::m_hWnd, rtMain.left, rtMain.top,
_RectWidth(rtMain) - _RectWidth(rtClient) + _RectWidth(rtChild),
_RectHeight(rtMain) - _RectHeight(rtClient) + _RectHeight(rtChild), TRUE);
}
}
void TreeGeneratorFrame::getValueGeneralParams(TreeGeneralParams* generalParams)
{
_Assert(NULL != generalParams);
double scale = 0;
double scaleV = 0;
double baseSize = 0;
double radiusRatio = 0;
double ratioPower = 0;
mTextScale->GetValue().ToDouble(&scale);
mTextScaleV->GetValue().ToDouble(&scaleV);
mTextBaseSize->GetValue().ToDouble(&baseSize);
mTextRadiusRatio->GetValue().ToDouble(&radiusRatio);
mTextRatioPower->GetValue().ToDouble(&ratioPower);
generalParams->scale = scale;
generalParams->scaleV = scaleV;
generalParams->baseSize = baseSize;
generalParams->radiusRatio = radiusRatio;
generalParams->ratioPower = ratioPower;
generalParams->levels = mSpinLevels->GetValue();
generalParams->shape = mSpinShape->GetValue();
generalParams->baseSplits = mSpinBaseSplits->GetValue();
}
RTEMS_INLINE_ROUTINE bool _Scheduler_Set_root_visitor(
Resource_Node *resource_node,
void *arg
)
{
Scheduler_Set_root_context *ctx = arg;
Thread_Control *root = ctx->root;
Thread_Control *needs_help = root;
Thread_Control *offers_help =
THREAD_RESOURCE_NODE_TO_THREAD( resource_node );
const Scheduler_Control *scheduler = _Scheduler_Get_own( offers_help );
Thread_Control *needs_help_too;
_Resource_Node_set_root( resource_node, &root->Resource_node );
needs_help_too = ( *scheduler->Operations.ask_for_help )(
scheduler,
offers_help,
needs_help
);
if ( needs_help_too != needs_help && needs_help_too != NULL ) {
_Assert( ctx->needs_help == NULL );
ctx->needs_help = needs_help_too;
}
return false;
}
void _Scheduler_Thread_change_resource_root(
Thread_Control *top,
Thread_Control *root
)
{
Scheduler_Set_root_context ctx = { root, NULL };
Thread_Control *offers_help = top;
Scheduler_Node *offers_help_node;
Thread_Control *offers_help_too;
offers_help_node = _Scheduler_Thread_get_node( offers_help );
offers_help_too = _Scheduler_Node_get_owner( offers_help_node );
if ( offers_help != offers_help_too ) {
_Scheduler_Set_root_visitor( &offers_help_too->Resource_node, &ctx );
_Assert( ctx.needs_help == offers_help );
ctx.needs_help = NULL;
}
_Scheduler_Set_root_visitor( &top->Resource_node, &ctx );
_Resource_Iterate( &top->Resource_node, _Scheduler_Set_root_visitor, &ctx );
if ( ctx.needs_help != NULL ) {
_Scheduler_Ask_for_help( ctx.needs_help );
}
}
// 添加新session
void TcpListener::event_new_session(tcp::socket& sk)
{
TcpSession::TcpSessionSptr session = std::make_shared<TcpSession>(m_loop, next_session_id(),
std::bind(&TcpListener::event_session_error, this, std::placeholders::_1, std::placeholders::_2),
nullptr,
std::bind(&TcpListener::event_session_disconnect, this, std::placeholders::_1),
std::bind(&TcpListener::event_readable, this, std::placeholders::_1));
// 添加到列表
bool succ = m_map_session.insert(std::make_pair(session->sid(), session)).second;
if (succ == false)
{
session->stop();
_Assert(false, "添加新session失败");
return;
}
// 开启session
session->start();
// 添加到事件列表
std::unique_lock<std::mutex> ul(m_mtx_ev);
m_events.push_back(std::bind(&TcpListener::fun_session_new, this, session));
ul.unlock();
}
void _Semaphore_Post( struct _Semaphore_Control *_sem )
{
Semaphore_Control *sem;
Thread_queue_Context queue_context;
Thread_queue_Heads *heads;
sem = _Semaphore_Get( _sem );
_Thread_queue_Context_initialize( &queue_context );
_Semaphore_Queue_acquire( sem, &queue_context );
heads = sem->Queue.Queue.heads;
if ( heads == NULL ) {
_Assert( sem->count < UINT_MAX );
++sem->count;
_Semaphore_Queue_release( sem, &queue_context );
} else {
const Thread_queue_Operations *operations;
Thread_Control *first;
operations = SEMAPHORE_TQ_OPERATIONS;
first = ( *operations->first )( heads );
_Thread_queue_Extract_critical(
&sem->Queue.Queue,
operations,
first,
&queue_context
);
}
}
static bool _Thread_queue_Make_ready_again( Thread_Control *the_thread )
{
bool success;
bool unblock;
/*
* We must update the wait flags under protection of the current thread lock,
* otherwise a _Thread_Timeout() running on another processor may interfere.
*/
success = _Thread_Wait_flags_try_change_release(
the_thread,
THREAD_QUEUE_INTEND_TO_BLOCK,
THREAD_QUEUE_READY_AGAIN
);
if ( success ) {
unblock = false;
} else {
_Assert( _Thread_Wait_flags_get( the_thread ) == THREAD_QUEUE_BLOCKED );
_Thread_Wait_flags_set( the_thread, THREAD_QUEUE_READY_AGAIN );
unblock = true;
}
_Thread_Wait_restore_default( the_thread );
return unblock;
}
void _Thread_queue_Surrender_sticky(
Thread_queue_Queue *queue,
Thread_queue_Heads *heads,
Thread_Control *previous_owner,
Thread_queue_Context *queue_context,
const Thread_queue_Operations *operations
)
{
Thread_Control *new_owner;
Per_CPU_Control *cpu_self;
_Assert( heads != NULL );
_Thread_queue_Context_clear_priority_updates( queue_context );
new_owner = ( *operations->surrender )(
queue,
heads,
previous_owner,
queue_context
);
queue->owner = new_owner;
_Thread_queue_Make_ready_again( new_owner );
cpu_self = _Thread_Dispatch_disable_critical(
&queue_context->Lock_context.Lock_context
);
_Thread_queue_Queue_release(
queue,
&queue_context->Lock_context.Lock_context
);
_Thread_Priority_and_sticky_update( previous_owner, -1 );
_Thread_Priority_and_sticky_update( new_owner, 0 );
_Thread_Dispatch_enable( cpu_self );
}
void BZSpriteButton::_onClick()
{
_Assert(_bEnabled);
_setAnimateState(BS_Idle);
_Debug("button %s clicked", this->getModName().c_str());
_pLayer->onEvent(new CAEventCommand(this, "onClick"));
}
void _TOD_Set(
const Timestamp_Control *tod_as_timestamp,
ISR_lock_Context *lock_context
)
{
struct timespec tod_as_timespec;
uint64_t tod_as_ticks;
uint32_t cpu_count;
uint32_t cpu_index;
_Assert( _API_Mutex_Is_owner( _Once_Mutex ) );
_Timecounter_Set_clock( tod_as_timestamp, lock_context );
_Timestamp_To_timespec( tod_as_timestamp, &tod_as_timespec );
tod_as_ticks = _Watchdog_Ticks_from_timespec( &tod_as_timespec );
cpu_count = _SMP_Get_processor_count();
for ( cpu_index = 0 ; cpu_index < cpu_count ; ++cpu_index ) {
Per_CPU_Control *cpu = _Per_CPU_Get_by_index( cpu_index );
_Watchdog_Per_CPU_tickle_absolute( cpu, tod_as_ticks );
}
_TOD.is_set = true;
}
void _Mutex_recursive_Release( struct _Mutex_recursive_Control *_mutex )
{
Mutex_recursive_Control *mutex;
Thread_queue_Context queue_context;
ISR_Level level;
Thread_Control *executing;
unsigned int nest_level;
mutex = _Mutex_recursive_Get( _mutex );
_Thread_queue_Context_initialize( &queue_context );
_Thread_queue_Context_ISR_disable( &queue_context, level );
executing = _Mutex_Queue_acquire_critical( &mutex->Mutex, &queue_context );
_Assert( mutex->Mutex.Queue.Queue.owner == executing );
nest_level = mutex->nest_level;
if ( __predict_true( nest_level == 0 ) ) {
_Mutex_Release_critical( &mutex->Mutex, executing, level, &queue_context );
} else {
mutex->nest_level = nest_level - 1;
_Mutex_Queue_release( &mutex->Mutex, level, &queue_context );
}
}
Box::Box(const Box &old_box)
{
_Init(old_box._xsize, old_box._ysize, old_box._xpos, old_box._ypos, old_box._border,
old_box._outer_colour, old_box._inner_colour);
if (!_Assert())
throw std::invalid_argument("Box [WARNING]: constructor recieved an invalid input.");
}
void _Thread_Close( Thread_Control *the_thread, Thread_Control *executing )
{
_Assert( _Thread_Is_life_protected( executing->Life.state ) );
if ( _States_Is_dormant( the_thread->current_state ) ) {
_Thread_Make_zombie( the_thread );
} else {
if (
the_thread != executing
&& !_Thread_Is_life_terminating( executing->Life.state )
) {
/*
* Wait for termination of victim thread. If the executing thread is
* also terminated, then do not wait. This avoids potential cyclic
* dependencies and thus dead lock.
*/
the_thread->Life.terminator = executing;
_Thread_Set_state( executing, STATES_WAITING_FOR_TERMINATION );
}
_Thread_Request_life_change(
the_thread,
executing,
executing->current_priority,
THREAD_LIFE_TERMINATING
);
}
}
