void FileEntry::Print(const StringRef& indent) const
{
auto opStr = ConvertToString(mOperations);
auto perStr = ConvertToString(mPermission);
Log::FormatInfo("{}{}:{}\t{}\t{}\t{}", indent, mName, mSize,perStr,opStr,mSignature);
}
bool ACreatureActor::InitCreatureRender()
{
FString cur_creature_filename = creature_filename;
bool does_exist = FPlatformFileManager::Get().GetPlatformFile().FileExists(*cur_creature_filename);
if (!does_exist)
{
// see if it is in the content directory
cur_creature_filename = FPaths::GameContentDir() + FString(TEXT("/")) + cur_creature_filename;
does_exist = FPlatformFileManager::Get().GetPlatformFile().FileExists(*cur_creature_filename);
}
if (does_exist)
{
auto load_filename = ConvertToString(cur_creature_filename);
// try to load creature
ACreatureActor::LoadDataPacket(load_filename);
LoadCreature(load_filename);
// try to load all animations
auto all_animation_names = creature_manager->GetCreature()->GetAnimationNames();
auto first_animation_name = all_animation_names[0];
for (auto& cur_name : all_animation_names)
{
ACreatureActor::LoadAnimation(load_filename, cur_name);
AddLoadedAnimation(load_filename, cur_name);
}
auto cur_str = ConvertToString(start_animation_name);
for (auto& cur_name : all_animation_names)
{
if (cur_name == cur_str)
{
first_animation_name = cur_name;
break;
}
}
SetActiveAnimation(first_animation_name);
if (smooth_transitions)
{
creature_manager->SetAutoBlending(true);
}
FillBoneData();
return true;
}
else {
UE_LOG(LogTemp, Warning, TEXT("ACreatureActor::BeginPlay() - ERROR! Could not load creature file: %s"), *creature_filename);
}
return false;
}
//Джх╬╤сап
void DisplayManager::AddTime(Real deltaTime)
{
lifetText->msg->setCaption("Life: "+ConvertToString(INSTANCE(PlayerManager)->lifeNum));
bombText->msg->setCaption("Bomb: "+ConvertToString(INSTANCE(PlayerManager)->bombNum));
scoreText->msg->setCaption("Score: "+ConvertToString(INSTANCE(ScoreManager)->displayScore));
lifetText->node->setVisible(true);
bombText->node->setVisible(true);
scoreText->node->setVisible(true);
}
void
ACreatureSwitchItemActor:: InitSwitchRenderData()
{
if (creature_actor)
{
auto creature_manager = creature_actor->GetCreatureManager();
if (creature_manager)
{
auto cur_creature = creature_manager->GetCreature();
auto& regions_map = cur_creature->GetRenderComposition()->getRegionsMap();
std::string find_name = ConvertToString(creature_switch_region);
for (auto& cur_region_pair : regions_map)
{
auto cur_region = cur_region_pair.second;
if (cur_region->getName() == find_name)
{
// init render mesh
real_switch_region = cur_region;
InitRealSwitchRegion();
switch_init_done = true;
break;
}
}
}
}
}
void ConfigManager::SetConfigV(int flag, int val){
DBUtil::initDB("save.db");
string sqlstr = "update config_save set value=" + ConvertToString(val) + " where id = " + ConvertToString(flag);
((ConfigStruct*) cvs->objectForKey(flag))->value = val;
DBUtil::updateData(sqlstr);
DBUtil::closeDB();
}
std::string ConfigManager::getZBState(int aiZBID)
{
string ts_ret = "";
stringstream tSqlS;
tSqlS << "select * from zb_list ";
tSqlS << "where id = ";
tSqlS << ConvertToString(aiZBID);
CCLog(">[ConfigManager] getZBState() | %s", tSqlS.str().c_str());
vector<map<string, string>> vdata;
DBUtil::initDB("save.db");
vdata = DBUtil::getDataInfo(tSqlS.str(), NULL);
int m_number = vdata.size();
for (int i = 0; i < m_number; i++){
ts_ret = ((map<string, string>) vdata.at(i)).at("config");
if (ts_ret.length()>0){
break;
}
}
DBUtil::closeDB();
return ts_ret;
}
void ACreatureCollectionActor::SetBluePrintActiveClip(FString clipName)
{
if (AreAllActorsReady() == false)
{
delay_set_clip_name = ConvertToString(clipName);
return;
}
active_clip_name = ConvertToString(clipName);
if (collection_clips.count(active_clip_name))
{
auto& cur_collection = collection_clips[active_clip_name];
cur_collection.ref_index = 0;
UpdateActorAnimationToStart(cur_collection);
}
}
char * xlw::XlfOper4::AsString(int * pxlret) const
{
char * s;
int xlret = ConvertToString(s);
if (pxlret)
*pxlret=xlret;
else
ThrowOnError(xlret);
return s;
};
char * xlw::XlfOper4::AsString(const std::string& ErrorId, int * pxlret) const
{
char * s;
int xlret = ConvertToString(s);
if (pxlret)
*pxlret=xlret;
else
ThrowOnError(xlret,ErrorId+" conversion to char* failed");
return s;
};
bool LWOFile::LoadUVMap(unsigned int iChunkSize)
{
Layer *pLayer=GetLastLayer();
const char *pChunkEndPos=m_pData+iChunkSize-4;
unsigned short iDimension=0;
if(!ReadU2(iDimension))
{
return false;
}
// not 2 floats per vertex
if(iDimension!=2)
{
// just skip
m_pData+=iChunkSize-4-2;
AddError("Warning: UVMap has "+ConvertToString(iDimension)+" floats per vertex (2 expected)");
return true;
}
unsigned int iStrBytes=0;
std::string strName;
if(!ReadS0(strName,iStrBytes))
{
return false;
}
// VMAP { type[ID4], dimension[U2], name[S0],
// ( vert[VX], value[F4] # dimension )* }
UVMap *pUVMap=new UVMap();
pUVMap->m_strName=strName;
pUVMap->m_Values.resize(2*pLayer->m_iPoints);
pLayer->m_UVMaps.push_back(pUVMap);
float *pValues=&(pUVMap->m_Values[0]);
memset(pValues,0,sizeof(float)*2*pLayer->m_iPoints);
while(m_pData<pChunkEndPos)
{
unsigned int iVertexID=0;
if(!ReadVX(iVertexID)) return false;
if(iVertexID>=pLayer->m_iPoints) return false;
if(!ReadF4(pValues[iVertexID*2+0])) return false;
if(!ReadF4(pValues[iVertexID*2+1])) return false;
// flip v coordinate
pValues[iVertexID*2+1]=1-pValues[iVertexID*2+1];
}
return true;
}
ErrnoError HttpClient::SendRequest(common::http::http_method method,
const uri::Url& url,
common::http::http_protocol protocol,
const char* extra_header,
bool is_keep_alive) {
CHECK(protocol <= common::http::HP_1_1);
if (!url.IsValid()) {
return make_errno_error_inval();
}
uri::Url::scheme sc = url.GetScheme();
if (!(sc == uri::Url::http || sc == uri::Url::https)) {
return make_errno_error_inval();
}
const std::string method_str = ConvertToString(method);
time_t now = time(nullptr);
char timebuf[100];
strftime(timebuf, sizeof(timebuf), RFC1123FMT, gmtime(&now));
uri::Upath path = url.GetPath();
char header_data[1024] = {0};
int cur_pos = SNPrintf(header_data, sizeof(header_data),
protocol == common::http::HP_2_0 ? "%s /%s " HTTP_2_0_PROTOCOL_NAME
"\r\n"
"Host: %s\r\n"
"Date: %s\r\n"
: "%s /%s " HTTP_1_1_PROTOCOL_NAME
"\r\n"
"Host: %s\r\n"
"Date: %s\r\n",
method_str, path.GetHpath(), url.GetHost(), timebuf);
if (extra_header) {
int exlen = SNPrintf(header_data + cur_pos, sizeof(header_data) - cur_pos, "%s\r\n", extra_header);
cur_pos += exlen;
}
if (!is_keep_alive) {
#define CONNECTION_CLOSE "Connection: close\r\n\r\n"
const int last_len = sizeof(CONNECTION_CLOSE) - 1;
memcpy(header_data + cur_pos, CONNECTION_CLOSE, last_len);
cur_pos += last_len;
} else {
#define CONNECTION_KEEP_ALIVE "Keep-Alive: timeout=15, max=100\r\n\r\n"
const int last_len = sizeof(CONNECTION_KEEP_ALIVE) - 1;
memcpy(header_data + cur_pos, CONNECTION_KEEP_ALIVE, last_len);
cur_pos += last_len;
}
DCHECK(strlen(header_data) == static_cast<size_t>(cur_pos));
size_t nwrite = 0;
return Write(header_data, cur_pos, &nwrite);
}
void
ACreatureActor::SetBluePrintAnimationCustomTimeRange(FString name_in, int32 start_time, int32 end_time)
{
auto cur_str = ConvertToString(name_in);
auto all_animations = creature_manager->GetAllAnimations();
if (all_animations.count(cur_str) > 0)
{
all_animations[cur_str]->setStartTime(start_time);
all_animations[cur_str]->setEndTime(end_time);
}
}
void
CreatureCore::ClearBluePrintPointCache(FString name_in, int32 approximation_level)
{
auto cur_creature_manager = GetCreatureManager();
if (!cur_creature_manager)
{
UE_LOG(LogTemp, Warning, TEXT("ACreatureActor::MakeBluePrintPointCache() - ERROR! Could not generate point cache for %s"), *name_in);
return;
}
cur_creature_manager->ClearPointCache(ConvertToString(name_in));
}
void ACreatureCollectionActor::AddBluePrintCollectionClipData(FString clipName, ACreatureActor * creatureActor, FString creatureActorClipName)
{
if (creatureActor == NULL)
{
return;
}
std::string new_clip_name = ConvertToString(clipName);
std::string real_actor_clip_name = ConvertToString(creatureActorClipName);
if (collection_clips.count(new_clip_name) < 0)
{
collection_clips[new_clip_name] = ACreatureCollectionClip();
}
creatureActor->SetIsDisabled(true);
creatureActor->SetDriven(false);
creatureActor->SetBluePrintAnimationLoop(false);
ACreatureCollectionClip& cur_collection_clip = collection_clips[new_clip_name];
cur_collection_clip.actor_sequence.push_back(std::make_pair(creatureActor, real_actor_clip_name));
}
std::string ConvertToString(const fastonosql::core::upscaledb::Config& conf) {
auto argv = conf.Args();
if (conf.create_if_missing) {
argv.push_back("-c");
}
if (conf.dbnum) {
argv.push_back("-n");
argv.push_back(ConvertToString(conf.dbnum));
}
return fastonosql::core::ConvertToStringConfigArgs(argv);
}
FRenderMaterialRef GetRenderMaterial(eastl::wstring const & ShaderName) {
eastl::wstring wShaderNameFinal = ConvertToResourceString(ShaderName);
eastl::string ShaderNameFinal = ConvertToString(wShaderNameFinal);
u64 Key = MurmurHash2_64(ShaderNameFinal.data(), sizeof(ShaderNameFinal[0]) * ShaderNameFinal.length(), 0);
auto RenderMaterialIter = RenderMaterialsMap.find(Key);
if (RenderMaterialIter != RenderMaterialsMap.end()) {
return RenderMaterialIter->second;
}
FRenderMaterialRef Ref = eastl::make_shared<FRenderMaterial>(ShaderNameFinal);
RenderMaterialsMap[Key] = Ref;
return Ref;
}
void CreatureCore::ParseEvents(float deltaTime)
{
SCOPE_CYCLE_COUNTER(STAT_CreatureCore_ParseEvents);
float cur_runtime = (creature_manager->getActualRunTime());
animation_frame = cur_runtime;
auto load_filename = ConvertToString(absolute_creature_filename);
auto cur_animation_name = creature_manager->GetActiveAnimationName();
auto cur_token = GetAnimationToken(load_filename, cur_animation_name);
CreatureModule::CreatureAnimation * cur_animation = NULL;
if (global_animations.count(cur_token) > 0)
{
cur_animation = global_animations[cur_token].get();
}
if (cur_animation)
{
int cur_start_time = cur_animation->getStartTime();
int cur_end_time = cur_animation->getEndTime();
float diff_val_start = fabs(cur_runtime - cur_start_time);
const float cutoff = 0.01f;
if ((diff_val_start <= cutoff)
&& !is_looping
&& !play_start_done
&& should_play)
{
play_start_done = true;
should_process_animation_start = true;
}
if ((cur_runtime + 1.0f >= cur_end_time)
&& !is_looping
&& !play_end_done
&& should_play)
{
play_end_done = true;
should_play = false;
should_process_animation_end = true;
}
}
}
/*******************************************************************************
* Function Name : ShowFPS
* Description : отрисовка показаний количества кадров за сек.
* Input : uint8_t FPS_counter
* Return : None
*******************************************************************************/
void UI_ShowFPS(uint8_t FPS_counter)
{
static char FPS_TEXT[3] = {' ', ' ', 0};
/* установить цвет фона, шрифт */
LCD_SetBackColor(globalBackColor);
LCD_SetFont(&lucidaConsole10ptFontInfo);
/* очищаем старые показания */
LCD_PutColorStrig(349, 224, 0, &FPS_TEXT[0], globalBackColor);
/* verify limit */
if(FPS_counter >= 100) FPS_counter = 99;
ConvertToString(FPS_counter, &FPS_TEXT[0], 2);
/* выводим новые показания */
LCD_PutColorStrig(349, 224, 0, &FPS_TEXT[0], LightGray);
/* сбрасываем флаг */
show_FPS_flag = 0;
}
void
CreatureCore::MakeBluePrintPointCache(FString name_in, int32 approximation_level)
{
auto cur_creature_manager = GetCreatureManager();
if (!cur_creature_manager)
{
UE_LOG(LogTemp, Warning, TEXT("ACreatureActor::MakeBluePrintPointCache() - ERROR! Could not generate point cache for %s"), *name_in);
return;
}
int32 real_approximation_level = approximation_level;
if (real_approximation_level <= 0)
{
real_approximation_level = 1;
}
else if (real_approximation_level > 10)
{
real_approximation_level = 10;
}
cur_creature_manager->MakePointCache(ConvertToString(name_in), real_approximation_level);
}
ErrnoError HttpClient::SendError(common::http::http_protocol protocol,
common::http::http_status status,
const char* extra_header,
const char* text,
bool is_keep_alive,
const HttpServerInfo& info) {
CHECK(protocol <= common::http::HP_1_1);
const std::string title = ConvertToString(status);
char err_data[1024] = {0};
off_t err_len = SNPrintf(err_data, sizeof(err_data), HTML_PATTERN_ISISSSS7, status, title, status, title, text,
info.server_url, info.server_name);
ErrnoError err = SendHeaders(protocol, status, extra_header, "text/html", &err_len, nullptr, is_keep_alive, info);
if (err) {
DEBUG_MSG_ERROR(err, logging::LOG_LEVEL_ERR);
}
size_t nwrite = 0;
err = Write(err_data, err_len, &nwrite);
if (err) {
DEBUG_MSG_ERROR(err, logging::LOG_LEVEL_ERR);
}
return err;
}
void CreatureCore::ProcessRenderRegions()
{
auto cur_creature = creature_manager->GetCreature();
auto& regions_map = cur_creature->GetRenderComposition()->getRegionsMap();
int num_triangles = cur_creature->GetTotalNumIndices() / 3;
// process alphas
if (region_alphas.Num() != cur_creature->GetTotalNumPoints())
{
region_alphas.Init(255, cur_creature->GetTotalNumPoints());
}
// fill up animation alphas
for (auto& cur_region_pair : regions_map)
{
auto cur_region = cur_region_pair.second;
auto start_pt_index = cur_region->getStartPtIndex();
auto end_pt_index = cur_region->getEndPtIndex();
auto cur_alpha = FMath::Clamp(cur_region->getOpacity() / 100.0f, 0.0f, 1.0f) * 255.0f;
for (auto i = start_pt_index; i <= end_pt_index; i++)
{
region_alphas[i] = (uint8)cur_alpha;
}
}
// user overwrite alphas
if (region_alpha_map.Num() > 0)
{
// fill up the alphas for specific regions with alpha overwrites
for (auto cur_iter : region_alpha_map)
{
auto cur_name = ConvertToString(cur_iter.Key);
auto cur_alpha = cur_iter.Value;
if (regions_map.count(cur_name) > 0)
{
meshRenderRegion * cur_region = regions_map[cur_name];
auto start_pt_index = cur_region->getStartPtIndex();
auto end_pt_index = cur_region->getEndPtIndex();
for (auto i = start_pt_index; i <= end_pt_index; i++)
{
region_alphas[i] = cur_alpha;
}
}
}
}
// now write out alphas into render triangles
/*
glm::uint32 * cur_idx = cur_creature->GetGlobalIndices();
for (int i = 0; i < num_triangles; i++)
{
int real_idx_1 = cur_idx[0];
int real_idx_2 = cur_idx[1];
int real_idx_3 = cur_idx[2];
auto& cur_tri = draw_tris[i];
auto set_alpha_1 = region_alphas[real_idx_1];
auto set_alpha_2 = region_alphas[real_idx_2];
auto set_alpha_3 = region_alphas[real_idx_3];
cur_tri.Vertex0.Color = FColor(set_alpha_1, set_alpha_1, set_alpha_1, set_alpha_1);
cur_tri.Vertex1.Color = FColor(set_alpha_2, set_alpha_2, set_alpha_1, set_alpha_2);
cur_tri.Vertex2.Color = FColor(set_alpha_3, set_alpha_3, set_alpha_1, set_alpha_3);
cur_idx += 3;
}
*/
}
const char* CGameToken::GetValueAsString() const
{
static string temp;
temp = ConvertToString(m_value);
return temp;
}
void ArgumentList::GenerateThrow(std::string message, unsigned long row, unsigned long column)
{
throw(StructureName+" "+message+" row:"+ConvertToString(row)+"; column:"+ConvertToString(column)+".");
}
void
UCreatureMeshComponent::RunCollectionTick(float DeltaTime)
{
UpdateCoreValues();
if (bHiddenInGame)
{
return;
}
if (active_collection_clip == nullptr)
{
return;
}
float true_delta_time = DeltaTime * animation_speed;
auto cur_data = GetCollectionDataFromClip(active_collection_clip);
if (cur_data == nullptr)
{
return;
}
if (cur_data->animation_speed > 0)
{
true_delta_time = DeltaTime * cur_data->animation_speed;
}
if (active_collection_play == false)
{
true_delta_time = 0;
}
TArray<FProceduralMeshTriangle>& write_triangles = cur_data->ProceduralMeshTris;
auto& cur_core = cur_data->creature_core;
if (cur_core.GetCreatureManager() == nullptr)
{
return;
}
cur_core.should_play = true;
bool can_tick = cur_core.RunTick(true_delta_time);
if (can_tick) {
// Events
bool announce_start = cur_core.GetAndClearShouldAnimStart();
bool announce_end = cur_core.GetAndClearShouldAnimEnd();
float cur_runtime = (cur_core.GetCreatureManager()->getActualRunTime());
bool is_collection_start = (active_collection_clip->active_index == 0) && announce_start;
bool is_collection_end = (active_collection_clip->active_index == active_collection_clip->sequence_clips.Num() - 1) && announce_end;
if (is_collection_start)
{
CreatureAnimationStartEvent.Broadcast(cur_runtime);
}
if (is_collection_end)
{
CreatureAnimationEndEvent.Broadcast(cur_runtime);
}
// Process Collection Clip
auto cur_manager = cur_core.GetCreatureManager();
auto& all_animations = cur_manager->GetAllAnimations();
auto& cur_token = active_collection_clip->sequence_clips[active_collection_clip->active_index];
std::string anim_string = ConvertToString(cur_token.animation_name);
if (all_animations.count(anim_string) == 0)
{
return;
}
auto clip_animation = all_animations.at(anim_string).get();
float next_time = cur_runtime + true_delta_time;
if (next_time >= clip_animation->getEndTime())
{
// At the end of current clip, see if we should switch to the next clip
int next_active_index = active_collection_clip->active_index + 1;
int seq_num = active_collection_clip->sequence_clips.Num();
bool do_switch = false;
if (next_active_index >= seq_num)
{
if (active_collection_loop)
{
active_collection_clip->active_index = 0;
do_switch = true;
}
}
else {
active_collection_clip->active_index++;
do_switch = true;
}
if (do_switch)
{
SetActiveCollectionAnimation(active_collection_clip);
}
}
DoCreatureMeshUpdate(GetCollectionDataIndexFromClip(active_collection_clip));
}
}
/**
* Convert int value to string.
*/
const char* CDeviceUtils::ConvertToString(int intVal)
{
return ConvertToString((long)intVal);
}
void ACreatureActor::SetBluePrintBlendActiveAnimation(FString name_in, float factor)
{
auto cur_str = ConvertToString(name_in);
SetAutoBlendActiveAnimation(cur_str, factor);
}
void ACreatureActor::SetBluePrintActiveAnimation(FString name_in)
{
auto cur_str = ConvertToString(name_in);
SetActiveAnimation(cur_str);
}
/**
* @brief LoadPreference
* @param None
* @retval None
*/
void LoadPreference(void)
{
uint16_t i, j = 0;
uint8_t load_success = 0;
char m_txt[50] = "param ";
uint16_t m_color;
Settings_Message("For skip load settings push 'DOWN'", Red);
/* Init data massive */
for(i = 0; i < 800; i ++)
{
INFO_A.DATA[i] = INFO_B.DATA[i] = 0;
INFO_A.visDATA[i] = INFO_B.visDATA[i] = 120;
}
delay_ms(1000);
if(EPM570_Read_Keys() == DOWN)
{
Settings_Message("Load Preference SKIPED", White);
delay_ms(1000);
}
else
{
/* Load all params */
for(i = 0; i < PARAM_NUM; i++)
{
load_success = Settings_LoadParam(SettingsParams[i]);
memset(&m_txt[6], 0, 49 - 6);
ConvertToString(i, &m_txt[6], 3);
j = strlen(m_txt);
if(load_success != 0)
{
strcat(&m_txt[j], " failed, erased");
m_color = Red;
}
else
{
strcat(&m_txt[j], " load");
m_color = LighGreen;
}
Settings_Message(m_txt, m_color);
if(load_success != 0) delay_ms(200);
}
/* ------------------------------------- Update States, Modes, Texts and other ------------------------------------- */
/* вид интерполяции */
ActiveMode = (InterpolationMode_TypeDef*)InterpModes[Interpolate_AciveMode_Index]; //
if(ActiveMode == &FFT_MODE)
{
gOSC_MODE.autoMeasurments = ON;
mModeActive = (MeasMode_TypeDef*)&MeasurmentsMode[2];
}
/* чтение значения времени автоотключения */
if( (AutoOff_Timer.Work_Minutes != 0) && (AutoOff_Timer.Work_Minutes != (int8_t)-1) )
{
AutoOff_Timer.State = ENABLE;
AutoOff_Timer.ResetTime = RTC_GetCounter();
sprintf (&AutoPowerOFF_btnTxt[10], "%d", AutoOff_Timer.Work_Minutes);
AutoPowerOFF.Text = AutoPowerOFF_btnTxt;
}
/* Samples num points */
if(gOSC_MODE.oscNumPoints == 0) gOSC_MODE.oscNumPoints = 388;
/* Update sync */
gInterfaceMenu.Buttons[4]->Text = (char*)&sweepMODE_text[gSyncState.Mode];
TrigMenu.Buttons[4]->Text = TriggShowInfo.triggType_Name[gSyncState.Type];
TrigMenu.Buttons[5]->Text = (char*)&Trigg_Sourse_Sync_Text[gSyncState.Sourse][0];
gSyncState.foops->SetTrigg_X(trigPosX_cursor.Position - leftLimit);
gSyncState.foops->StateUpdate();
/* AC/DC inputs state */
setActiveButton(gInterfaceMenu.Buttons[8]);
ON_OFF_Channels(&INFO_A, TRUE);
setActiveButton(gInterfaceMenu.Buttons[9]);
ON_OFF_Channels(&INFO_B, TRUE);
/* Autodivider for analog inputs */
Set_AutoDivider_State(param_auto_div, ENABLE);
/* PWM correction zero for analog inputs */
*(INFO_A.AD_Type.Analog.corrZ) = INFO_A.AD_Type.Analog.Zero_PWM_values[INFO_A.AD_Type.Analog.Div];
*(INFO_B.AD_Type.Analog.corrZ) = INFO_B.AD_Type.Analog.Zero_PWM_values[INFO_B.AD_Type.Analog.Div];
/* */
gInterfaceMenu.Buttons[1]->Text = Change_AnalogDivider(CHANNEL_A, INFO_A.AD_Type.Analog.Div); // btnVDIV_A
gInterfaceMenu.Buttons[2]->Text = Change_AnalogDivider(CHANNEL_B, INFO_B.AD_Type.Analog.Div); // btnVDIV_B
/* Interpolation */
changeInterpolation(ActiveMode);
Interpolation.Text = (char*)ActiveMode->Text;
/* Update sweep state, scale coeffs */
Sweep_UpdateState();
/* Update UI elements */
UI_LoadPreferenceUpdate();
/*Set LCD backlight*/
EPM570_Set_BackLight(gOSC_MODE.BackLight);
}
}
/**
* @brief This function handles External lines 9 to 5 interrupt request.
* Zero cross 220 line motor input
* @param None
* @retval None
*/
void EXTI9_5_IRQHandler(void)
{
static FlagStatus start = SET;
#ifdef __MOTOR_REGULATE_RELAY_METHOD
static uint8_t period_count = 0;
static uint8_t skip_periods_num = 0;
static uint8_t period_div = 0;
#else
static int speed = 0;
static float period_delay_ms = 0;
#endif
uint32_t interrupt_status = EXTI->IMR & GPIO_MOTOR_ZC_A1;
#ifdef __DBUG_INTR_MOTOR
char dbg_str[10] = "\r\n ";
static uint8_t dbg_full_period_cnt = 0;
#endif
if (((EXTI->PR & GPIO_MOTOR_ZC_A1) != (uint32_t)RESET) && (interrupt_status != (uint32_t)RESET))
{
EXTI->PR = GPIO_MOTOR_ZC_A1; /* Clear the EXTI line pending bit */
if(CU_Motor_GetState()->state == 1)
{
#ifdef __MOTOR_REGULATE_RELAY_METHOD
if((start == SET) || (skip_periods_num != CU_Motor_GetState()->speed))
{
#ifdef __DBUG_INTR_MOTOR
Debug_Send_String("\r\n intr: start");
dbg_full_period_cnt = 0;
#endif
start = RESET;
skip_periods_num = CU_Motor_GetState()->speed;
period_count = 0;
period_div = 0;
if(skip_periods_num >= 100)
{
#ifdef __DBUG_INTR_MOTOR
Debug_Send_String("\r\n intr: skip_periods_num >= 100");
#endif
CU_Motor_GetState()->state = 0;
GPIO_ResetBits(GPIO_MOTOR_OUT_PORT, GPIO_MOTOR_OUT_PWM);
return;
}
else
{
if(skip_periods_num == 0)
{
// period_div = 0;
CU_Motor_GetState()->state = 0;
GPIO_ResetBits(GPIO_MOTOR_OUT_PORT, GPIO_MOTOR_OUT_PWM);
return;
}
else period_div = (uint8_t)(100.0 / (float)skip_periods_num);
#ifdef __DBUG_INTR_MOTOR
ConvertToString(skip_periods_num, &dbg_str[2], 3);
Debug_Send_String("\r\n intr: skip_per_num ");
Debug_Send_String(dbg_str);
ConvertToString(period_div, &dbg_str[2], 3);
Debug_Send_String("\r\n intr: period_div ");
Debug_Send_String(dbg_str);
#endif
}
}
period_count++;
if(period_count > 100)
{
period_count = 0;
#ifdef __DBUG_INTR_MOTOR
dbg_full_period_cnt++;
ConvertToString(dbg_full_period_cnt, &dbg_str[2], 3);
Debug_Send_String("\r\n intr: *** dbg period_cnt ***");
Debug_Send_String(dbg_str);
#endif
}
// full ON
if(period_div == 0)
{
GPIO_SetBits(GPIO_MOTOR_OUT_PORT, GPIO_MOTOR_OUT_PWM);
}
else
{
#ifdef __DBUG_INTR_MOTOR
ConvertToString(period_count, &dbg_str[2], 3);
Debug_Send_String("\r\n intr: period_cnt ");
Debug_Send_String(dbg_str);
#endif
if((period_count % period_div) == 0)
{
#ifdef __DBUG_INTR_MOTOR
Debug_Send_String("\r\n intr: triac ON");
#endif
GPIO_SetBits(GPIO_MOTOR_OUT_PORT, GPIO_MOTOR_OUT_PWM);
}
else
{
#ifdef __DBUG_INTR_MOTOR
Debug_Send_String("\r\n intr: triac OFF");
#endif
GPIO_ResetBits(GPIO_MOTOR_OUT_PORT, GPIO_MOTOR_OUT_PWM);
}
}
#else /*__MOTOR_REGULATE_PHASE_METHOD */
GPIO_MOTOR_OUT_PORT->BRR = GPIO_MOTOR_OUT_PWM; // RESET
if((start == SET) || (speed != CU_Motor_GetTachoSpeed()))
{
#ifdef __DBUG_INTR_MOTOR
Debug_Send_String("\r\n intr: start");
dbg_full_period_cnt = 0;
#endif
start = RESET;
speed = CU_Motor_GetTachoSpeed();
if((speed == 0) || (speed >= 1000))
{
#ifdef __DBUG_INTR_MOTOR
Debug_Send_String("\r\n intr: speed == 0 || speed >= 1000");
#endif
CU_Motor_GetState()->state = 0;
return;
}
else
{
period_delay_ms = __220_HALF_PERIOD__ - (__220_HALF_PERIOD__ / (1000.0 / (float)speed));
if(period_delay_ms > __220_HALF_PERIOD__ - 1) period_delay_ms = __220_HALF_PERIOD__ - 1;
#ifdef __DBUG_INTR_MOTOR
ConvertToString(speed, &dbg_str[2], 4);
Debug_Send_String("\r\n intr: speed ");
Debug_Send_String(dbg_str);
ConvertToString(period_delay_ms, &dbg_str[2], 3);
Debug_Send_String("\r\n intr: period_delay ");
Debug_Send_String(dbg_str);
#endif
}
}
if(period_delay_ms != 0)
{
/* set autoreload counter, (500 - 1) = 0.5ms, (1000 - 1) = 1ms */
TIM4->ARR = (uint32_t)(period_delay_ms * 999.0);
TIM4->CR1 |= TIM_CR1_CEN;
}
else
{
TIM4->CR1 &= (uint16_t)(~((uint16_t)TIM_CR1_CEN));
GPIO_MOTOR_OUT_PORT->BSRR = GPIO_MOTOR_OUT_PWM; // SET
}
#endif /*__MOTOR_REGULATE_METHOD */
}
else
{
#ifdef __DBUG_INTR_MOTOR
Debug_Send_String("\r\n intr: motor status OFF, disable intr");
#endif
NVIC_DisableIRQ(EXTI9_5_IRQn);
GPIO_MOTOR_OUT_PORT->BRR = GPIO_MOTOR_OUT_PWM; // RESET
/* set start flag status for the next motor starts */
start = SET;
}
}
/* tacho interrupt */
interrupt_status = EXTI->IMR & GPIO_MOTOR_TACHO_A63;
if (((EXTI->PR & GPIO_MOTOR_TACHO_A63) != (uint32_t)RESET) && (interrupt_status != (uint32_t)RESET))
{
EXTI->PR = GPIO_MOTOR_TACHO_A63; /* Clear the EXTI line pending bit */
// if ((GPIOA->IDR & GPIO_Pin_8) != (uint32_t)Bit_RESET) tachometr_counter++;
tachometr_counter++;
}
}
bool CreatureCore::InitCreatureRender()
{
FString cur_creature_filename = creature_filename;
bool init_success = false;
std::string load_filename;
//////////////////////////////////////////////////////////////////////////
//Changed by God of Pen
//////////////////////////////////////////////////////////////////////////
if (pJsonData != nullptr)
{
if (cur_creature_filename.IsEmpty())
{
cur_creature_filename = creature_asset_filename;
}
absolute_creature_filename = cur_creature_filename;
load_filename = ConvertToString(cur_creature_filename);
// try to load creature
init_success = CreatureCore::LoadDataPacket(load_filename, pJsonData);;
}
else{
bool does_exist = FPlatformFileManager::Get().GetPlatformFile().FileExists(*cur_creature_filename);
if (!does_exist)
{
// see if it is in the content directory
cur_creature_filename = FPaths::GameContentDir() + FString(TEXT("/")) + cur_creature_filename;
does_exist = FPlatformFileManager::Get().GetPlatformFile().FileExists(*cur_creature_filename);
}
if (does_exist)
{
absolute_creature_filename = cur_creature_filename;
load_filename = ConvertToString(cur_creature_filename);
// try to load creature
CreatureCore::LoadDataPacket(load_filename);
init_success = true;
}
else {
if (do_file_warning && (!load_filename.empty())) {
UE_LOG(LogTemp, Warning, TEXT("ACreatureActor::BeginPlay() - ERROR! Could not load creature file: %s"), *creature_filename);
GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, FString::Printf(TEXT("ACreatureActor::BeginPlay() - ERROR! Could not load creature file: %s"), *creature_filename));
}
}
}
if (init_success)
{
LoadCreature(load_filename);
// try to load all animations
auto all_animation_names = creature_manager->GetCreature()->GetAnimationNames();
auto first_animation_name = all_animation_names[0];
for (auto& cur_name : all_animation_names)
{
CreatureCore::LoadAnimation(load_filename, cur_name);
AddLoadedAnimation(load_filename, cur_name);
}
auto cur_str = ConvertToString(start_animation_name);
for (auto& cur_name : all_animation_names)
{
if (cur_name == cur_str)
{
first_animation_name = cur_name;
break;
}
}
SetActiveAnimation(first_animation_name);
if (smooth_transitions)
{
creature_manager->SetAutoBlending(true);
}
FillBoneData();
}
return init_success;
}
