experimental/nima/NimaActor.cpp - skia - Git at Google

 /*
  * Copyright 2018 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */

 #include "NimaActor.h"

 #include "SkData.h"
 #include "SkFilterQuality.h"
 #include "SkImage.h"
 #include "SkPaint.h"
 #include "SkString.h"
 #include "SkVertices.h"

 #include <algorithm>
 #include <cmath>

 NimaActor::NimaActor(std::string nimaPath, std::string texturePath)
     : fTexture(nullptr)
     , fActorImages()
     , fPaint(nullptr)
     , fAnimationNames()
     , fAnimationInstance(nullptr) {
     // Load the NIMA data.
     INHERITED::load(nimaPath);

     // Load the image asset.
     fTexture = SkImage::MakeFromEncoded(SkData::MakeFromFileName(texturePath.c_str()));

     this->init();
 }

 NimaActor::NimaActor(sk_sp<SkData> nimaBytes, sk_sp<SkData> textureBytes)
     : fTexture(nullptr)
     , fActorImages()
     , fPaint(nullptr)
     , fAnimationNames()
     , fAnimationInstance(nullptr) {
     // Load the NIMA data.
     INHERITED::load(const_cast<uint8_t*>(nimaBytes->bytes()), nimaBytes->size());

     // Load the image asset.
     fTexture = SkImage::MakeFromEncoded(textureBytes);

     this->init();
 }

 void NimaActor::init() {
     // Create the paint.
     fPaint = std::make_unique<SkPaint>();
     fPaint->setShader(fTexture->makeShader(nullptr));
     fPaint->setFilterQuality(SkFilterQuality::kLow_SkFilterQuality);

     // Load the image nodes.
     fActorImages.reserve(m_ImageNodeCount);
     for (uint32_t i = 0; i < m_ImageNodeCount; i ++) {
         fActorImages.emplace_back(m_ImageNodes[i], fTexture.get(), fPaint.get());
     }

     // Sort the image nodes.
     std::sort(fActorImages.begin(), fActorImages.end(), [](auto a, auto b) {
         return a.drawOrder() < b.drawOrder();
     });

     // Get the list of animations.
     fAnimationNames.reserve(m_AnimationsCount);
     for (uint32_t i = 0; i < m_AnimationsCount; i++) {
         fAnimationNames.push_back(m_Animations[i].name());
     }
     this->setAnimation(0);
 }

 SkScalar NimaActor::duration() const {
     if (fAnimationInstance) {
         return fAnimationInstance->duration();
     }
     return 0.0f;
 }

 void NimaActor::setAnimation(uint8_t index) {
     if (index < fAnimationNames.size()) {
         fAnimationIndex = index;
         fAnimationInstance = this->animationInstance(fAnimationNames[fAnimationIndex]);
     }
 }

 void NimaActor::setAnimation(std::string name) {
     for (size_t i = 0; i < fAnimationNames.size(); i++)
     {
         std::string aName = fAnimationNames[i];
         if (aName == name)
         {
             setAnimation(i);
             return;
         }
     }
 }

 void NimaActor::render(SkCanvas* canvas, uint32_t renderFlags) {
     // Render the image nodes.
     for (auto& image : fActorImages) {
         image.render(canvas, renderFlags);
     }
 }

 void NimaActor::seek(SkScalar t) {
     // Apply the animation.
     if (fAnimationInstance) {
         t = std::fmod(t, fAnimationInstance->max());
         fAnimationInstance->time(t);
         fAnimationInstance->apply(1.0f);
     }
 }

 // ===================================================================================

 NimaActorImage::NimaActorImage(nima::ActorImage* actorImage, SkImage* texture, SkPaint* paint)
         : fActorImage(actorImage)
         , fTexture(texture)
         , fPaint(paint)
         , fSkinned(false)
         , fPositions()
         , fTexs()
         , fBoneIdx()
         , fBoneWgt()
         , fIndices()
         , fBones()
         , fVertices(nullptr)
         , fRenderFlags(0) {
     // Update the vertices and bones.
     this->updateVertices(true);
     this->updateBones();
 }

 void NimaActorImage::render(SkCanvas* canvas, uint32_t renderFlags) {
         bool dirty = renderFlags != fRenderFlags;
         fRenderFlags = renderFlags;

         bool useImmediate = renderFlags & kImmediate_RenderFlag;
         bool useCache = renderFlags & kCache_RenderFlag;
         bool drawBounds = renderFlags & kBounds_RenderFlag;

         // Don't use the cache if drawing in immediate mode.
         useCache &= !useImmediate;

         if (fActorImage->doesAnimationVertexDeform() || dirty) {
             // These are vertices that transform beyond just bone transforms, so they must be
             // updated every frame.
             // If the render flags are dirty, reset the vertices object.
             this->updateVertices(!useCache);
         }

         // Update the bones.
         this->updateBones();

         // Deform the bones in immediate mode.
         sk_sp<SkVertices> vertices = fVertices;
         if (useImmediate) {
             vertices = fVertices->applyBones(fBones.data(), fBones.size());
         }

         // Draw the vertices object.
         this->drawVerticesObject(vertices.get(), canvas, !useImmediate);

         // Draw the bounds.
         if (drawBounds && fActorImage->renderOpacity() > 0.0f) {
             // Get the bounds.
             SkRect bounds = vertices->bounds();

             // Approximate bounds if not using immediate transforms.
             if (!useImmediate) {
                 const SkRect originalBounds = fBones[0].mapRect(vertices->bounds());
                 bounds = originalBounds;
                 for (size_t i = 1; i < fBones.size(); i++) {
                     const SkVertices::Bone& matrix = fBones[i];
                     bounds.join(matrix.mapRect(originalBounds));
                 }
             }

             // Draw the bounds.
             SkPaint paint;
             paint.setStyle(SkPaint::kStroke_Style);
             paint.setColor(0xFFFF0000);
             canvas->drawRect(bounds, paint);
         }
     }

 void NimaActorImage::updateVertices(bool isVolatile) {
     // Update whether the image is skinned.
     fSkinned = fActorImage->connectedBoneCount() > 0;

     // Retrieve data from the image.
     uint32_t  vertexCount  = fActorImage->vertexCount();
     uint32_t  vertexStride = fActorImage->vertexStride();
     float*    vertexData   = fActorImage->vertices();
     uint32_t  indexCount   = fActorImage->triangleCount() * 3;
     uint16_t* indexData    = fActorImage->triangles();

     // Don't render if not visible.
     if (!vertexCount || fActorImage->textureIndex() < 0) {
         fPositions.clear();
         fTexs.clear();
         fBoneIdx.clear();
         fBoneWgt.clear();
         fIndices.clear();
         return;
     }

     // Split the vertex data.
     fPositions.resize(vertexCount);
     fTexs.resize(vertexCount);
     fIndices.resize(indexCount);
     if (fSkinned) {
         fBoneIdx.resize(vertexCount * 4);
         fBoneWgt.resize(vertexCount * 4);
     }
     for (uint32_t i = 0; i < vertexCount; i ++) {
         uint32_t j = i * vertexStride;

         // Get the attributes.
         float* attrPosition = vertexData + j;
         float* attrTex      = vertexData + j + 2;
         float* attrBoneIdx  = vertexData + j + 4;
         float* attrBoneWgt  = vertexData + j + 8;

         // Get deformed positions if necessary.
         if (fActorImage->doesAnimationVertexDeform()) {
             attrPosition = fActorImage->animationDeformedVertices() + i * 2;
         }

         // Set the data.
         fPositions[i].set(attrPosition[0], attrPosition[1]);
         fTexs[i].set(attrTex[0] * fTexture->width(), attrTex[1] * fTexture->height());
         if (fSkinned) {
             for (uint32_t k = 0; k < 4; k ++) {
                 fBoneIdx[i][k] = static_cast<uint32_t>(attrBoneIdx[k]);
                 fBoneWgt[i][k] = attrBoneWgt[k];
             }
         }
     }
     memcpy(fIndices.data(), indexData, indexCount * sizeof(uint16_t));

     // Update the vertices object.
     fVertices = SkVertices::MakeCopy(SkVertices::kTriangles_VertexMode,
                                      vertexCount,
                                      fPositions.data(),
                                      fTexs.data(),
                                      nullptr,
                                      fBoneIdx.data(),
                                      fBoneWgt.data(),
                                      fIndices.size(),
                                      fIndices.data(),
                                      isVolatile);
 }

 void NimaActorImage::updateBones() {
     // NIMA matrices are a collection of 6 floats.
     constexpr int kNIMAMatrixSize = 6;

     // Set up the matrices for the first time.
     if (fBones.size() == 0) {
         int numMatrices = 1;
         if (fSkinned) {
             numMatrices = fActorImage->boneInfluenceMatricesLength() / kNIMAMatrixSize;
         }

         // Initialize all matrices to the identity matrix.
         fBones.assign(numMatrices, {{ 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f }});
     }

     if (fSkinned) {
         // Update the matrices.
         float* matrixData = fActorImage->boneInfluenceMatrices();
         memcpy(fBones.data(), matrixData, fBones.size() * kNIMAMatrixSize * sizeof(float));
     }

     // Set the zero matrix to be the world transform.
     memcpy(fBones.data(),
            fActorImage->worldTransform().values(),
            kNIMAMatrixSize * sizeof(float));
 }

 void NimaActorImage::drawVerticesObject(SkVertices* vertices, SkCanvas* canvas, bool useBones) const {
     // Determine the blend mode.
     SkBlendMode blendMode;
     switch (fActorImage->blendMode()) {
         case nima::BlendMode::Off: {
             blendMode = SkBlendMode::kSrc;
             break;
         }
         case nima::BlendMode::Normal: {
             blendMode = SkBlendMode::kSrcOver;
             break;
         }
         case nima::BlendMode::Additive: {
             blendMode = SkBlendMode::kPlus;
             break;
         }
         case nima::BlendMode::Multiply: {
             blendMode = SkBlendMode::kMultiply;
             break;
         }
         case nima::BlendMode::Screen: {
             blendMode = SkBlendMode::kScreen;
             break;
         }
     }

     // Set the opacity.
     fPaint->setAlpha(static_cast<U8CPU>(fActorImage->renderOpacity() * 255));

     // Draw the vertices.
     if (useBones) {
         canvas->drawVertices(vertices, fBones.data(), fBones.size(), blendMode, *fPaint);
     } else {
         canvas->drawVertices(vertices, blendMode, *fPaint);
     }

     // Reset the opacity.
     fPaint->setAlpha(255);
 }
	/*
	* Copyright 2018 Google Inc.
	*
	* Use of this source code is governed by a BSD-style license that can be
	* found in the LICENSE file.
	*/

	#include "NimaActor.h"

	#include "SkData.h"
	#include "SkFilterQuality.h"
	#include "SkImage.h"
	#include "SkPaint.h"
	#include "SkString.h"
	#include "SkVertices.h"

	#include <algorithm>
	#include <cmath>

	NimaActor::NimaActor(std::string nimaPath, std::string texturePath)
	: fTexture(nullptr)
	, fActorImages()
	, fPaint(nullptr)
	, fAnimationNames()
	, fAnimationInstance(nullptr) {
	// Load the NIMA data.
	INHERITED::load(nimaPath);

	// Load the image asset.
	fTexture = SkImage::MakeFromEncoded(SkData::MakeFromFileName(texturePath.c_str()));

	this->init();
	}

	NimaActor::NimaActor(sk_sp<SkData> nimaBytes, sk_sp<SkData> textureBytes)
	: fTexture(nullptr)
	, fActorImages()
	, fPaint(nullptr)
	, fAnimationNames()
	, fAnimationInstance(nullptr) {
	// Load the NIMA data.
	INHERITED::load(const_cast<uint8_t*>(nimaBytes->bytes()), nimaBytes->size());

	// Load the image asset.
	fTexture = SkImage::MakeFromEncoded(textureBytes);

	this->init();
	}

	void NimaActor::init() {
	// Create the paint.
	fPaint = std::make_unique<SkPaint>();
	fPaint->setShader(fTexture->makeShader(nullptr));
	fPaint->setFilterQuality(SkFilterQuality::kLow_SkFilterQuality);

	// Load the image nodes.
	fActorImages.reserve(m_ImageNodeCount);
	for (uint32_t i = 0; i < m_ImageNodeCount; i ++) {
	fActorImages.emplace_back(m_ImageNodes[i], fTexture.get(), fPaint.get());
	}

	// Sort the image nodes.
	std::sort(fActorImages.begin(), fActorImages.end(), [](auto a, auto b) {
	return a.drawOrder() < b.drawOrder();
	});

	// Get the list of animations.
	fAnimationNames.reserve(m_AnimationsCount);
	for (uint32_t i = 0; i < m_AnimationsCount; i++) {
	fAnimationNames.push_back(m_Animations[i].name());
	}
	this->setAnimation(0);
	}

	SkScalar NimaActor::duration() const {
	if (fAnimationInstance) {
	return fAnimationInstance->duration();
	}
	return 0.0f;
	}

	void NimaActor::setAnimation(uint8_t index) {
	if (index < fAnimationNames.size()) {
	fAnimationIndex = index;
	fAnimationInstance = this->animationInstance(fAnimationNames[fAnimationIndex]);
	}
	}

	void NimaActor::setAnimation(std::string name) {
	for (size_t i = 0; i < fAnimationNames.size(); i++)
	{
	std::string aName = fAnimationNames[i];
	if (aName == name)
	{
	setAnimation(i);
	return;
	}
	}
	}

	void NimaActor::render(SkCanvas* canvas, uint32_t renderFlags) {
	// Render the image nodes.
	for (auto& image : fActorImages) {
	image.render(canvas, renderFlags);
	}
	}

	void NimaActor::seek(SkScalar t) {
	// Apply the animation.
	if (fAnimationInstance) {
	t = std::fmod(t, fAnimationInstance->max());
	fAnimationInstance->time(t);
	fAnimationInstance->apply(1.0f);
	}
	}

	// ===================================================================================

	NimaActorImage::NimaActorImage(nima::ActorImage* actorImage, SkImage* texture, SkPaint* paint)
	: fActorImage(actorImage)
	, fTexture(texture)
	, fPaint(paint)
	, fSkinned(false)
	, fPositions()
	, fTexs()
	, fBoneIdx()
	, fBoneWgt()
	, fIndices()
	, fBones()
	, fVertices(nullptr)
	, fRenderFlags(0) {
	// Update the vertices and bones.
	this->updateVertices(true);
	this->updateBones();
	}

	void NimaActorImage::render(SkCanvas* canvas, uint32_t renderFlags) {
	bool dirty = renderFlags != fRenderFlags;
	fRenderFlags = renderFlags;

	bool useImmediate = renderFlags & kImmediate_RenderFlag;
	bool useCache = renderFlags & kCache_RenderFlag;
	bool drawBounds = renderFlags & kBounds_RenderFlag;

	// Don't use the cache if drawing in immediate mode.
	useCache &= !useImmediate;

	if (fActorImage->doesAnimationVertexDeform() \|\| dirty) {
	// These are vertices that transform beyond just bone transforms, so they must be
	// updated every frame.
	// If the render flags are dirty, reset the vertices object.
	this->updateVertices(!useCache);
	}

	// Update the bones.
	this->updateBones();

	// Deform the bones in immediate mode.
	sk_sp<SkVertices> vertices = fVertices;
	if (useImmediate) {
	vertices = fVertices->applyBones(fBones.data(), fBones.size());
	}

	// Draw the vertices object.
	this->drawVerticesObject(vertices.get(), canvas, !useImmediate);

	// Draw the bounds.
	if (drawBounds && fActorImage->renderOpacity() > 0.0f) {
	// Get the bounds.
	SkRect bounds = vertices->bounds();

	// Approximate bounds if not using immediate transforms.
	if (!useImmediate) {
	const SkRect originalBounds = fBones[0].mapRect(vertices->bounds());
	bounds = originalBounds;
	for (size_t i = 1; i < fBones.size(); i++) {
	const SkVertices::Bone& matrix = fBones[i];
	bounds.join(matrix.mapRect(originalBounds));
	}
	}

	// Draw the bounds.
	SkPaint paint;
	paint.setStyle(SkPaint::kStroke_Style);
	paint.setColor(0xFFFF0000);
	canvas->drawRect(bounds, paint);
	}
	}

	void NimaActorImage::updateVertices(bool isVolatile) {
	// Update whether the image is skinned.
	fSkinned = fActorImage->connectedBoneCount() > 0;

	// Retrieve data from the image.
	uint32_t vertexCount = fActorImage->vertexCount();
	uint32_t vertexStride = fActorImage->vertexStride();
	float* vertexData = fActorImage->vertices();
	uint32_t indexCount = fActorImage->triangleCount() * 3;
	uint16_t* indexData = fActorImage->triangles();

	// Don't render if not visible.
	if (!vertexCount \|\| fActorImage->textureIndex() < 0) {
	fPositions.clear();
	fTexs.clear();
	fBoneIdx.clear();
	fBoneWgt.clear();
	fIndices.clear();
	return;
	}

	// Split the vertex data.
	fPositions.resize(vertexCount);
	fTexs.resize(vertexCount);
	fIndices.resize(indexCount);
	if (fSkinned) {
	fBoneIdx.resize(vertexCount * 4);
	fBoneWgt.resize(vertexCount * 4);
	}
	for (uint32_t i = 0; i < vertexCount; i ++) {
	uint32_t j = i * vertexStride;

	// Get the attributes.
	float* attrPosition = vertexData + j;
	float* attrTex = vertexData + j + 2;
	float* attrBoneIdx = vertexData + j + 4;
	float* attrBoneWgt = vertexData + j + 8;

	// Get deformed positions if necessary.
	if (fActorImage->doesAnimationVertexDeform()) {
	attrPosition = fActorImage->animationDeformedVertices() + i * 2;
	}

	// Set the data.
	fPositions[i].set(attrPosition[0], attrPosition[1]);
	fTexs[i].set(attrTex[0] * fTexture->width(), attrTex[1] * fTexture->height());
	if (fSkinned) {
	for (uint32_t k = 0; k < 4; k ++) {
	fBoneIdx[i][k] = static_cast<uint32_t>(attrBoneIdx[k]);
	fBoneWgt[i][k] = attrBoneWgt[k];
	}
	}
	}
	memcpy(fIndices.data(), indexData, indexCount * sizeof(uint16_t));

	// Update the vertices object.
	fVertices = SkVertices::MakeCopy(SkVertices::kTriangles_VertexMode,
	vertexCount,
	fPositions.data(),
	fTexs.data(),
	nullptr,
	fBoneIdx.data(),
	fBoneWgt.data(),
	fIndices.size(),
	fIndices.data(),
	isVolatile);
	}

	void NimaActorImage::updateBones() {
	// NIMA matrices are a collection of 6 floats.
	constexpr int kNIMAMatrixSize = 6;

	// Set up the matrices for the first time.
	if (fBones.size() == 0) {
	int numMatrices = 1;
	if (fSkinned) {
	numMatrices = fActorImage->boneInfluenceMatricesLength() / kNIMAMatrixSize;
	}

	// Initialize all matrices to the identity matrix.
	fBones.assign(numMatrices, {{ 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f }});
	}

	if (fSkinned) {
	// Update the matrices.
	float* matrixData = fActorImage->boneInfluenceMatrices();
	memcpy(fBones.data(), matrixData, fBones.size() * kNIMAMatrixSize * sizeof(float));
	}

	// Set the zero matrix to be the world transform.
	memcpy(fBones.data(),
	fActorImage->worldTransform().values(),
	kNIMAMatrixSize * sizeof(float));
	}

	void NimaActorImage::drawVerticesObject(SkVertices* vertices, SkCanvas* canvas, bool useBones) const {
	// Determine the blend mode.
	SkBlendMode blendMode;
	switch (fActorImage->blendMode()) {
	case nima::BlendMode::Off: {
	blendMode = SkBlendMode::kSrc;
	break;
	}
	case nima::BlendMode::Normal: {
	blendMode = SkBlendMode::kSrcOver;
	break;
	}
	case nima::BlendMode::Additive: {
	blendMode = SkBlendMode::kPlus;
	break;
	}
	case nima::BlendMode::Multiply: {
	blendMode = SkBlendMode::kMultiply;
	break;
	}
	case nima::BlendMode::Screen: {
	blendMode = SkBlendMode::kScreen;
	break;
	}
	}

	// Set the opacity.
	fPaint->setAlpha(static_cast<U8CPU>(fActorImage->renderOpacity() * 255));

	// Draw the vertices.
	if (useBones) {
	canvas->drawVertices(vertices, fBones.data(), fBones.size(), blendMode, *fPaint);
	} else {
	canvas->drawVertices(vertices, blendMode, *fPaint);
	}

	// Reset the opacity.
	fPaint->setAlpha(255);
	}