void UpdateAI(uint32 diff)
{
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
switch (events.ExecuteEvent())
{
case EVENT_ALERGIC_REACTION:
me->CastSpell(me->GetVictim(), SPELL_ALLERGIC_REACTION, false);
events.ScheduleEvent(EVENT_ALERGIC_REACTION, 25000);
break;
case EVENT_TELEPORT:
me->CastSpell(me, SPELL_TELEPORT_SELF, false);
events.ScheduleEvent(EVENT_SUMMON, 2500);
events.ScheduleEvent(EVENT_TELEPORT, 30000);
break;
case EVENT_SUMMON:
Talk(EMOTE_SUMMON);
me->CastSpell(me, SPELL_SUMMON_LASHER_1, true);
me->CastSpell(me, SPELL_SUMMON_FLAYER_1, true);
break;
case EVENT_TRANSFORM:
DoTransform();
events.ScheduleEvent(EVENT_TRANSFORM, 35000);
break;
}
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 uiDiff)
{
if (!m_creature->SelectHostileTarget() || !m_creature->getVictim())
return;
if (m_uiSummonTimer)
{
if (m_uiSummonTimer <= uiDiff)
{
// Summon adds and restart chasing the victim
DoSummons();
DoScriptText(EMOTE_SUMMON, m_creature);
if (m_creature->getVictim())
m_creature->GetMotionMaster()->MoveChase(m_creature->getVictim());
m_uiSummonTimer = 0;
}
else
m_uiSummonTimer -= uiDiff;
}
if (m_uiAllergicTimer < uiDiff)
{
if (DoCastSpellIfCan(m_creature->getVictim(), SPELL_ALLERGIC_REACTION) == CAST_OK)
m_uiAllergicTimer = urand(25000, 40000);
}
else
m_uiAllergicTimer -= uiDiff;
if (m_uiTeleportTimer < uiDiff)
{
if (DoCastSpellIfCan(m_creature, SPELL_TELEPORT_SELF) == CAST_OK)
{
m_creature->GetMotionMaster()->MoveIdle();
m_uiTeleportTimer = urand(30000, 40000);
m_uiSummonTimer = 4000;
}
}
else
m_uiTeleportTimer -= uiDiff;
if (m_uiTransformTimer < uiDiff)
{
DoTransform();
m_uiTransformTimer = urand(25000, 40000);
}
else
m_uiTransformTimer -= uiDiff;
if (m_uiTrashTimer < uiDiff)
{
if (DoCastSpellIfCan(m_creature->getVictim(), SPELL_TRASH) == CAST_OK)
m_uiTrashTimer = urand(4000, 9000);
}
else
m_uiTrashTimer -= uiDiff;
DoMeleeAttackIfReady();
}
McoStatus LogoWin2::updateWindowData(int changed)
{
int i;
double xrt,yrt,zrt;
//return MCO_SUCCESS;
xrt = 0.00;
yrt = 0.04;
zrt = 0.000;
DoTransform(WE_Rotate,xrt,yrt,zrt);
forceUpdateData();
return MCO_SUCCESS;
}
void UpdateAI(const uint32 uiDiff)
{
if (m_uiPhase == 1)
{
if (m_uiDelayTimer <= uiDiff)
{
if (!GetClosestCreatureWithEntry(m_creature, NPC_TWISTED_VISAGE, 150.0f))
m_uiPhase = 2;
m_uiDelayTimer = 1000;
}else m_uiDelayTimer -= uiDiff;
return;
}
if (m_uiPhase == 2)
{
if (m_uiDelayTimer <= uiDiff)
{
DoTransform(m_uiTransformPhase);
m_uiTransformPhase++;
m_uiDelayTimer = 2500;
}else m_uiDelayTimer -= uiDiff;
}
if (m_uiPhase != 3)
return;
if (!m_creature->isInCombat())
{
if (m_uiOutOfCombatTimer <= uiDiff)
m_creature->ForcedDespawn();
else m_uiOutOfCombatTimer -= uiDiff;
return;
}
if (m_uiPhysicScreamTimer <= uiDiff)
{
DoCast(m_creature->SelectAttackingTarget(ATTACKING_TARGET_RANDOM, 0),SPELL_PSYCHIC_SCREAM);
SetPhysicScreamTimer();
}else m_uiPhysicScreamTimer -= uiDiff;
//Shadowbolt voley
if (m_uiShadowBoltTimer <= uiDiff)
{
DoCast(m_creature, m_bIsRegularMode ? SPELL_SHADOW_BOLT : SPELL_SHADOW_BOLT_H);
m_uiShadowBoltTimer = 8000;
}else m_uiShadowBoltTimer -= uiDiff;
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim())
return;
if (CanSummon)
{
if (Summon_Timer <= diff)
{
DoScriptText(EMOTE_SUMMON, me);
DoSummons();
Summon_Timer = 2500;
}
else
Summon_Timer -= diff;
}
if (Allergic_Timer <= diff)
{
DoCast(me->getVictim(), SPELL_ALLERGIC_REACTION);
Allergic_Timer = 25000+rand()%15000;
}
else
Allergic_Timer -= diff;
if (Teleport_Timer <= diff)
{
DoCast(me, SPELL_TELEPORT_SELF);
Teleport_Timer = 30000+rand()%10000;
CanSummon = true;
}
else
Teleport_Timer -= diff;
if (Transform_Timer <= diff)
{
DoTransform();
Transform_Timer = 25000+rand()%15000;
}
else
Transform_Timer -= diff;
DoMeleeAttackIfReady();
}
void LsysBranchRule::InternalRecursiveDraw(int nLevelsLeft, int nChildIdx, int nArrPos, ParamVector * arrParams)
{
if(arrParams[nArrPos][0] > m_BranchDescr[nChildIdx].m_lfProbability)
{
return;
}
glPushMatrix();
// draw the main branch
//if(nLevelsLeft < 1)
//{
// glColor3d(0.1, 0.7, 0.1);
//}
DoTransform(nChildIdx, nArrPos, arrParams);
DrawCone();
if(nLevelsLeft < 1)
{
// glColor3d(0.75, 0.5, 0.25);
glPopMatrix();
return;
}
int nPosNext = nArrPos*MAX_BRANCHES_PER_RULE;
for(int i = 0; i < MAX_BRANCHES_PER_RULE; ++i)
{
// do this if the branch is not broken
InternalRecursiveDraw(nLevelsLeft-1, i, nPosNext, arrParams);
++nPosNext;
}
glPopMatrix();
}
void UpdateAI(const uint32 diff)
{
if (!m_creature->SelectHostileTarget() || !m_creature->getVictim())
return;
if (CanSummon)
{
if (Summon_Timer < diff)
{
DoScriptText(EMOTE_SUMMON, m_creature);
DoSummons();
Summon_Timer = 2500;
}else Summon_Timer -= diff;
}
if (Allergic_Timer < diff)
{
DoCastSpellIfCan(m_creature->getVictim(),SPELL_ALLERGIC_REACTION);
Allergic_Timer = urand(25000, 40000);
}else Allergic_Timer -= diff;
if (Teleport_Timer < diff)
{
DoCastSpellIfCan(m_creature,SPELL_TELEPORT_SELF);
Teleport_Timer = urand(30000, 40000);
CanSummon = true;
}else Teleport_Timer -= diff;
if (Transform_Timer < diff)
{
DoTransform();
Transform_Timer = urand(25000, 40000);
}else Transform_Timer -= diff;
DoMeleeAttackIfReady();
}
void Redraw(void)
{
GLfloat tmp[4];
int ii;
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glBegin(GL_QUADS);
for (ii = 0; ii < 4; ii++) {
/* Transform a vertex from object to window coordinates.
* 1/w is returned as tmp[3] for perspective-correcting
* the texture coordinates.
*/
DoTransform(quadV[ii], tmp);
/* Ideally the colors will be computed by the lighting equation,
* but I've hard-coded values for this example.
*/
glColor3fv(quadC[ii]);
/* Scale by 1/w (stored in tmp[3]) */
glTexCoord4f(quadT[ii][0] * tmp[3],
quadT[ii][1] * tmp[3], 0.0f, tmp[3]);
/* Note I am using Vertex3, not Vertex4, since we have already
* performed the perspective divide.
*/
glVertex3fv(tmp);
}
glEnd();
glutSwapBuffers();
}
static void ReconstructRow(const VP8Decoder* const dec,
const VP8ThreadContext* ctx) {
int j;
int mb_x;
const int mb_y = ctx->mb_y_;
const int cache_id = ctx->id_;
uint8_t* const y_dst = dec->yuv_b_ + Y_OFF;
uint8_t* const u_dst = dec->yuv_b_ + U_OFF;
uint8_t* const v_dst = dec->yuv_b_ + V_OFF;
// Initialize left-most block.
for (j = 0; j < 16; ++j) {
y_dst[j * BPS - 1] = 129;
}
for (j = 0; j < 8; ++j) {
u_dst[j * BPS - 1] = 129;
v_dst[j * BPS - 1] = 129;
}
// Init top-left sample on left column too.
if (mb_y > 0) {
y_dst[-1 - BPS] = u_dst[-1 - BPS] = v_dst[-1 - BPS] = 129;
} else {
// we only need to do this init once at block (0,0).
// Afterward, it remains valid for the whole topmost row.
memset(y_dst - BPS - 1, 127, 16 + 4 + 1);
memset(u_dst - BPS - 1, 127, 8 + 1);
memset(v_dst - BPS - 1, 127, 8 + 1);
}
// Reconstruct one row.
for (mb_x = 0; mb_x < dec->mb_w_; ++mb_x) {
const VP8MBData* const block = ctx->mb_data_ + mb_x;
// Rotate in the left samples from previously decoded block. We move four
// pixels at a time for alignment reason, and because of in-loop filter.
if (mb_x > 0) {
for (j = -1; j < 16; ++j) {
Copy32b(&y_dst[j * BPS - 4], &y_dst[j * BPS + 12]);
}
for (j = -1; j < 8; ++j) {
Copy32b(&u_dst[j * BPS - 4], &u_dst[j * BPS + 4]);
Copy32b(&v_dst[j * BPS - 4], &v_dst[j * BPS + 4]);
}
}
{
// bring top samples into the cache
VP8TopSamples* const top_yuv = dec->yuv_t_ + mb_x;
const int16_t* const coeffs = block->coeffs_;
uint32_t bits = block->non_zero_y_;
int n;
if (mb_y > 0) {
memcpy(y_dst - BPS, top_yuv[0].y, 16);
memcpy(u_dst - BPS, top_yuv[0].u, 8);
memcpy(v_dst - BPS, top_yuv[0].v, 8);
}
// predict and add residuals
if (block->is_i4x4_) { // 4x4
uint32_t* const top_right = (uint32_t*)(y_dst - BPS + 16);
if (mb_y > 0) {
if (mb_x >= dec->mb_w_ - 1) { // on rightmost border
memset(top_right, top_yuv[0].y[15], sizeof(*top_right));
} else {
memcpy(top_right, top_yuv[1].y, sizeof(*top_right));
}
}
// replicate the top-right pixels below
top_right[BPS] = top_right[2 * BPS] = top_right[3 * BPS] = top_right[0];
// predict and add residuals for all 4x4 blocks in turn.
for (n = 0; n < 16; ++n, bits <<= 2) {
uint8_t* const dst = y_dst + kScan[n];
VP8PredLuma4[block->imodes_[n]](dst);
DoTransform(bits, coeffs + n * 16, dst);
}
} else { // 16x16
const int pred_func = CheckMode(mb_x, mb_y, block->imodes_[0]);
VP8PredLuma16[pred_func](y_dst);
if (bits != 0) {
for (n = 0; n < 16; ++n, bits <<= 2) {
DoTransform(bits, coeffs + n * 16, y_dst + kScan[n]);
}
}
}
{
// Chroma
const uint32_t bits_uv = block->non_zero_uv_;
const int pred_func = CheckMode(mb_x, mb_y, block->uvmode_);
VP8PredChroma8[pred_func](u_dst);
VP8PredChroma8[pred_func](v_dst);
DoUVTransform(bits_uv >> 0, coeffs + 16 * 16, u_dst);
DoUVTransform(bits_uv >> 8, coeffs + 20 * 16, v_dst);
}
// stash away top samples for next block
if (mb_y < dec->mb_h_ - 1) {
memcpy(top_yuv[0].y, y_dst + 15 * BPS, 16);
memcpy(top_yuv[0].u, u_dst + 7 * BPS, 8);
memcpy(top_yuv[0].v, v_dst + 7 * BPS, 8);
}
}
// Transfer reconstructed samples from yuv_b_ cache to final destination.
{
const int y_offset = cache_id * 16 * dec->cache_y_stride_;
const int uv_offset = cache_id * 8 * dec->cache_uv_stride_;
uint8_t* const y_out = dec->cache_y_ + mb_x * 16 + y_offset;
uint8_t* const u_out = dec->cache_u_ + mb_x * 8 + uv_offset;
uint8_t* const v_out = dec->cache_v_ + mb_x * 8 + uv_offset;
for (j = 0; j < 16; ++j) {
memcpy(y_out + j * dec->cache_y_stride_, y_dst + j * BPS, 16);
}
for (j = 0; j < 8; ++j) {
memcpy(u_out + j * dec->cache_uv_stride_, u_dst + j * BPS, 8);
memcpy(v_out + j * dec->cache_uv_stride_, v_dst + j * BPS, 8);
}
}
}
}
static
int TransformImage(char *cDefInpProf, char *cOutProf)
{
cmsHPROFILE hIn, hOut, hProof;
cmsHTRANSFORM xform;
cmsUInt32Number wInput, wOutput;
int OutputColorSpace;
cmsUInt32Number dwFlags = 0;
cmsUInt32Number EmbedLen;
cmsUInt8Number* EmbedBuffer;
cmsSetAdaptationState(ObserverAdaptationState);
if (BlackPointCompensation) {
dwFlags |= cmsFLAGS_BLACKPOINTCOMPENSATION;
}
switch (PrecalcMode) {
case 0: dwFlags |= cmsFLAGS_NOOPTIMIZE; break;
case 2: dwFlags |= cmsFLAGS_HIGHRESPRECALC; break;
case 3: dwFlags |= cmsFLAGS_LOWRESPRECALC; break;
default:;
}
if (GamutCheck) {
dwFlags |= cmsFLAGS_GAMUTCHECK;
cmsSetAlarmCodes(Alarm);
}
// Take input color space
wInput = GetInputPixelType();
if (lIsDeviceLink) {
hIn = cmsOpenProfileFromFile(cDefInpProf, "r");
hOut = NULL;
hProof = NULL;
}
else {
if (!IgnoreEmbedded && read_icc_profile(&Decompressor, &EmbedBuffer, &EmbedLen))
{
hIn = cmsOpenProfileFromMem(EmbedBuffer, EmbedLen);
if (Verbose) {
fprintf(stdout, " (Embedded profile found)\n");
PrintProfileInformation(hIn);
fflush(stdout);
}
if (hIn != NULL && SaveEmbedded != NULL)
SaveMemoryBlock(EmbedBuffer, EmbedLen, SaveEmbedded);
free(EmbedBuffer);
}
else
{
// Default for ITU/Fax
if (cDefInpProf == NULL && T_COLORSPACE(wInput) == PT_Lab)
cDefInpProf = "*Lab";
if (cDefInpProf != NULL && cmsstrcasecmp(cDefInpProf, "*lab") == 0)
hIn = CreateITU2PCS_ICC();
else
hIn = OpenStockProfile(0, cDefInpProf);
}
if (cOutProf != NULL && cmsstrcasecmp(cOutProf, "*lab") == 0)
hOut = CreatePCS2ITU_ICC();
else
hOut = OpenStockProfile(0, cOutProf);
hProof = NULL;
if (cProofing != NULL) {
hProof = OpenStockProfile(0, cProofing);
if (hProof == NULL) {
FatalError("Proofing profile couldn't be read.");
}
dwFlags |= cmsFLAGS_SOFTPROOFING;
}
}
if (!hIn)
FatalError("Input profile couldn't be read.");
if (!hOut)
FatalError("Output profile couldn't be read.");
// Assure both, input profile and input JPEG are on same colorspace
if (cmsGetColorSpace(hIn) != _cmsICCcolorSpace(T_COLORSPACE(wInput)))
FatalError("Input profile is not operating in proper color space");
// Output colorspace is given by output profile
if (lIsDeviceLink) {
OutputColorSpace = GetDevicelinkColorSpace(hIn);
}
else {
OutputColorSpace = GetProfileColorSpace(hOut);
}
jpeg_copy_critical_parameters(&Decompressor, &Compressor);
WriteOutputFields(OutputColorSpace);
wOutput = ComputeOutputFormatDescriptor(wInput, OutputColorSpace);
xform = cmsCreateProofingTransform(hIn, wInput,
hOut, wOutput,
hProof, Intent,
ProofingIntent, dwFlags);
if (xform == NULL)
FatalError("Cannot transform by using the profiles");
DoTransform(xform, OutputColorSpace);
jcopy_markers_execute(&Decompressor, &Compressor);
cmsDeleteTransform(xform);
cmsCloseProfile(hIn);
cmsCloseProfile(hOut);
if (hProof) cmsCloseProfile(hProof);
return 1;
}
static
int TransformImage(char *cDefInpProf, char *cOutProf)
{
cmsHPROFILE hIn, hOut, hProof;
cmsHTRANSFORM xform;
DWORD wInput, wOutput;
int OutputColorSpace;
DWORD dwFlags = 0;
DWORD EmbedLen;
LPBYTE EmbedBuffer;
if (BlackPointCompensation) {
dwFlags |= cmsFLAGS_BLACKPOINTCOMPENSATION;
}
switch (PrecalcMode) {
case 0: dwFlags |= cmsFLAGS_NOTPRECALC; break;
case 2: dwFlags |= cmsFLAGS_HIGHRESPRECALC; break;
case 3: dwFlags |= cmsFLAGS_LOWRESPRECALC; break;
default:;
}
if (GamutCheck)
dwFlags |= cmsFLAGS_GAMUTCHECK;
if (lIsDeviceLink) {
hIn = cmsOpenProfileFromFile(cDefInpProf, "r");
hOut = NULL;
hProof = NULL;
}
else {
if (!IgnoreEmbedded && read_icc_profile(&Decompressor, &EmbedBuffer, &EmbedLen))
{
hIn = cmsOpenProfileFromMem(EmbedBuffer, EmbedLen);
if (Verbose) {
fprintf(stdout, " (Embedded profile found)\n");
fprintf(stdout, "Product name: %s\n", cmsTakeProductName(hIn));
fprintf(stdout, "Description : %s\n", cmsTakeProductDesc(hIn));
fflush(stdout);
}
if (hIn != NULL && SaveEmbedded != NULL)
SaveMemoryBlock(EmbedBuffer, EmbedLen, SaveEmbedded);
free(EmbedBuffer);
}
else
{
hIn = OpenStockProfile(cDefInpProf);
}
hOut = OpenStockProfile(cOutProf);
hProof = NULL;
if (cProofing != NULL) {
hProof = OpenStockProfile(cProofing);
}
}
// Take input color space
wInput = GetInputPixelType();
// Assure both, input profile and input JPEG are on same colorspace
if (cmsGetColorSpace(hIn) != _cmsICCcolorSpace(T_COLORSPACE(wInput)))
FatalError("Input profile is not operating in proper color space");
// Output colorspace is given by output profile
if (lIsDeviceLink) {
OutputColorSpace = T_COLORSPACE(wInput);
}
else {
OutputColorSpace = GetProfileColorSpace(hOut);
}
jpeg_copy_critical_parameters(&Decompressor, &Compressor);
WriteOutputFields(OutputColorSpace);
wOutput = ComputeOutputFormatDescriptor(wInput, OutputColorSpace);
xform = cmsCreateProofingTransform(hIn, wInput,
hOut, wOutput,
hProof, Intent,
ProofingIntent, dwFlags);
// Handle tile by tile or strip by strip strtok
DoTransform(xform);
jcopy_markers_execute(&Decompressor, &Compressor);
cmsDeleteTransform(xform);
cmsCloseProfile(hIn);
cmsCloseProfile(hOut);
if (hProof) cmsCloseProfile(hProof);
return 1;
}
/// @brief DOCME
/// @param n_samples
/// @param input
/// @param output_r
/// @param output_i
///
void FFT::InverseTransform(size_t n_samples,float *input,float *output_r,float *output_i) {
DoTransform(n_samples,input,output_r,output_i,true);
}
/// @brief Transform wrappers
/// @param n_samples
/// @param input
/// @param output_r
/// @param output_i
///
void FFT::Transform(size_t n_samples,float *input,float *output_r,float *output_i) {
DoTransform(n_samples,input,output_r,output_i,false);
}