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); }