qquickimageparticle

Q_PROPERTY(qreal rotationVelocityVariation READ rotationVelocityVariation WRITE setRotationVelocityVariation NOTIFY rotationVelocityVariationChanged RESET resetRotation)

184

//If true, then will face the direction of motion. Stacks with rotation, e.g. setting rotation

185

//to 180 will lead to facing away from the direction of motion

186

Q_PROPERTY(bool autoRotation READ autoRotation WRITE setAutoRotation NOTIFY autoRotationChanged RESET resetRotation)

187

188

//xVector is the vector from the top-left point to the top-right point, and is multiplied by current size

189

Q_PROPERTY(QQuickDirection* xVector READ xVector WRITE setXVector NOTIFY xVectorChanged RESET resetDeformation)

190

//yVector is the same, but top-left to bottom-left. The particle is always a parallelogram.

191

Q_PROPERTY(QQuickDirection* yVector READ yVector WRITE setYVector NOTIFY yVectorChanged RESET resetDeformation)

192

Q_PROPERTY(bool spritesInterpolate READ spritesInterpolate WRITE setSpritesInterpolate NOTIFY spritesInterpolateChanged)

193

194

Q_PROPERTY(EntryEffect entryEffect READ entryEffect WRITE setEntryEffect NOTIFY entryEffectChanged)

195

public:

196

explicit QQuickImageParticle(QQuickItem *parent = 0);

197

virtual ~QQuickImageParticle();

198

199

enum Status { Null, Ready, Loading, Error };

200

Q_ENUM(Status)

201

202

QQmlListProperty<QQuickSprite> sprites();

203

QQuickStochasticEngine* spriteEngine() {return m_spriteEngine;}

executed 22348 times by 1 test: return m_spriteEngine;

Executed by:

tst_qquickspritegoal

22348

enum EntryEffect {

None = 0,

Fade = 1,

Scale = 2

};

Q_ENUM(EntryEffect)

enum PerformanceLevel{//TODO: Expose?

Unknown = 0,

Simple,

Colored,

Deformable,

Tabled,

Sprites

};

QUrl image() const { return m_image ? m_image->source : QUrl(); }

never executed: return m_image ? m_image->source : QUrl();

222

void setImage(const QUrl &image);

223

224

QUrl colortable() const { return m_colorTable ? m_colorTable->source : QUrl(); }

never executed: return m_colorTable ? m_colorTable->source : QUrl();

225

void setColortable(const QUrl &table);

226

227

QUrl sizetable() const { return m_sizeTable ? m_sizeTable->source : QUrl(); }

never executed: return m_sizeTable ? m_sizeTable->source : QUrl();

228

void setSizetable (const QUrl &table);

229

230

QUrl opacitytable() const { return m_opacityTable ? m_opacityTable->source : QUrl(); }

never executed: return m_opacityTable ? m_opacityTable->source : QUrl();

231

void setOpacitytable(const QUrl &table);

232

233

QColor color() const { return m_color; }

never executed: return m_color;

234

void setColor(const QColor &color);

235

236

qreal colorVariation() const { return m_color_variation; }

never executed: return m_color_variation;

237

void setColorVariation(qreal var);

238

239

qreal alphaVariation() const { return m_alphaVariation; }

never executed: return m_alphaVariation;

240

241

qreal alpha() const { return m_alpha; }

never executed: return m_alpha;

242

243

qreal redVariation() const { return m_redVariation; }

never executed: return m_redVariation;

244

245

qreal greenVariation() const { return m_greenVariation; }

never executed: return m_greenVariation;

246

247

qreal blueVariation() const { return m_blueVariation; }

never executed: return m_blueVariation;

248

249

qreal rotation() const { return m_rotation; }

never executed: return m_rotation;

250

251

qreal rotationVariation() const { return m_rotationVariation; }

never executed: return m_rotationVariation;

252

253

qreal rotationVelocity() const { return m_rotationVelocity; }

never executed: return m_rotationVelocity;

254

255

qreal rotationVelocityVariation() const { return m_rotationVelocityVariation; }

never executed: return m_rotationVelocityVariation;

256

257

bool autoRotation() const { return m_autoRotation; }

never executed: return m_autoRotation;

258

259

QQuickDirection* xVector() const { return m_xVector; }

never executed: return m_xVector;

260

261

QQuickDirection* yVector() const { return m_yVector; }

never executed: return m_yVector;

262

263

bool spritesInterpolate() const { return m_spritesInterpolate; }

never executed: return m_spritesInterpolate;

264

265

bool bypassOptimizations() const { return m_bypassOptimizations; }

never executed: return m_bypassOptimizations;

266

267

EntryEffect entryEffect() const { return m_entryEffect; }

never executed: return m_entryEffect;

268

269

Status status() const { return m_status; }

never executed: return m_status;

270

271

void resetColor();

272

void resetRotation();

273

void resetDeformation();

Q_SIGNALS:

void imageChanged();

void colortableChanged();

279

void sizetableChanged();

280

void opacitytableChanged();

281

282

void colorChanged();

283

void colorVariationChanged();

284

285

void alphaVariationChanged(qreal arg);

286

287

void alphaChanged(qreal arg);

288

289

void redVariationChanged(qreal arg);

290

291

void greenVariationChanged(qreal arg);

292

293

void blueVariationChanged(qreal arg);

294

295

void rotationChanged(qreal arg);

296

297

void rotationVariationChanged(qreal arg);

298

299

void rotationVelocityChanged(qreal arg);

300

301

void rotationVelocityVariationChanged(qreal arg);

302

303

void autoRotationChanged(bool arg);

304

305

void xVectorChanged(QQuickDirection* arg);

306

307

void yVectorChanged(QQuickDirection* arg);

308

309

void spritesInterpolateChanged(bool arg);

310

311

void bypassOptimizationsChanged(bool arg);

312

313

void entryEffectChanged(EntryEffect arg);

314

315

void statusChanged(Status arg);

316

317

public Q_SLOTS:

318

void reloadColor(const Color4ub &c, QQuickParticleData* d);

319

void setAlphaVariation(qreal arg);

320

321

void setAlpha(qreal arg);

322

323

void setRedVariation(qreal arg);

324

325

void setGreenVariation(qreal arg);

326

327

void setBlueVariation(qreal arg);

328

329

void setRotation(qreal arg);

330

331

void setRotationVariation(qreal arg);

332

333

void setRotationVelocity(qreal arg);

334

335

void setRotationVelocityVariation(qreal arg);

336

337

void setAutoRotation(bool arg);

338

339

void setXVector(QQuickDirection* arg);

340

341

void setYVector(QQuickDirection* arg);

342

343

void setSpritesInterpolate(bool arg);

344

345

void setBypassOptimizations(bool arg);

346

347

void setEntryEffect(EntryEffect arg);

348

349

protected:

350

void reset() override;

351

void initialize(int gIdx, int pIdx) override;

352

void commit(int gIdx, int pIdx) override;

353

354

QSGNode *updatePaintNode(QSGNode *, UpdatePaintNodeData *) override;

355

void prepareNextFrame(QSGNode**);

356

void buildParticleNodes(QSGNode**);

357

358

void sceneGraphInvalidated() override;

359

360

private Q_SLOTS:

361

void createEngine(); //### method invoked by sprite list changing (in engine.h) - pretty nasty

362

363

void spriteAdvance(int spriteIndex);

364

void spritesUpdate(qreal time = 0 );

365

void mainThreadFetchImageData();

366

void finishBuildParticleNodes(QSGNode **n);

private:

struct ImageData {

QUrl source;

QQuickPixmap pix;

};

QScopedPointer<ImageData> m_image;

373

QScopedPointer<ImageData> m_colorTable;

374

QScopedPointer<ImageData> m_sizeTable;

375

QScopedPointer<ImageData> m_opacityTable;

376

bool loadingSomething();

QColor m_color;

qreal m_color_variation;

381

382

QHash<int, QSGGeometryNode *> m_nodes;

383

QHash<int, int> m_idxStarts;//TODO: Proper resizing will lead to needing a spriteEngine per particle - do this after sprite engine gains transparent sharing?

384

QList<QPair<int, int> > m_startsIdx;//Same data, optimized for alternate retrieval

385

386

int m_lastIdxStart;

387

QSGMaterial *m_material;

// derived values...

qreal m_alphaVariation;

392

qreal m_alpha;

393

qreal m_redVariation;

394

qreal m_greenVariation;

395

qreal m_blueVariation;

396

qreal m_rotation;

397

qreal m_rotationVariation;

398

qreal m_rotationVelocity;

399

qreal m_rotationVelocityVariation;

400

bool m_autoRotation;

401

QQuickDirection* m_xVector;

402

QQuickDirection* m_yVector;

403

404

QList<QQuickSprite*> m_sprites;

405

QQuickSpriteEngine* m_spriteEngine;

406

bool m_spritesInterpolate;

407

408

bool m_explicitColor;

409

bool m_explicitRotation;

410

bool m_explicitDeformation;

411

bool m_explicitAnimation;

412

QHash<int, QVector<QQuickParticleData*> > m_shadowData;

413

void clearShadows();

414

QQuickParticleData* getShadowDatum(QQuickParticleData* datum);

415

416

bool m_bypassOptimizations;

417

PerformanceLevel perfLevel;

418

419

PerformanceLevel m_lastLevel;

420

bool m_debugMode;

421

422

template<class Vertex>

423

void initTexCoords(Vertex* v, int count){

424

Vertex* end = v + count;

425

while (v < end){

v < end	Description
TRUE	evaluated 6000 times by 3 tests Evaluated by: tst_qquickcustomaffector tst_qquickimageparticle tst_qquickspritegoal
FALSE	evaluated 12 times by 3 tests Evaluated by: tst_qquickcustomaffector tst_qquickimageparticle tst_qquickspritegoal