blob: 4634a45199a0451d33c7b8a133725d3e68e71235 [file] [log] [blame]
/*
* 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 "SampleNimaActor.h"
#include "SkString.h"
#include "SkVertices.h"
#include "SkPaint.h"
#include "SkFilterQuality.h"
#include "Resources.h"
#include <algorithm>
using namespace nima;
SampleActor::SampleActor(std::string baseName)
: fTexture(nullptr)
, fActorImages()
, fPaint(nullptr) {
// Load the NIMA data.
SkString nimaSkPath = GetResourcePath(("nima/" + baseName + ".nima").c_str());
std::string nimaPath(nimaSkPath.c_str());
INHERITED::load(nimaPath);
// Load the image asset.
fTexture = GetResourceAsImage(("nima/" + baseName + ".png").c_str());
// 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, fPaint.get());
}
// Sort the image nodes.
std::sort(fActorImages.begin(), fActorImages.end(), [](auto a, auto b) {
return a.drawOrder() < b.drawOrder();
});
}
SampleActor::~SampleActor() {
}
void SampleActor::render(SkCanvas* canvas) const {
// Render the image nodes.
for (auto image : fActorImages) {
image.render(this, canvas);
}
}
SampleActorImage::SampleActorImage(ActorImage* actorImage, sk_sp<SkImage> texture, SkPaint* paint)
: fActorImage(actorImage)
, fTexture(texture)
, fPaint(paint) {
}
SampleActorImage::~SampleActorImage() {
}
void SampleActorImage::render(const SampleActor* actor, SkCanvas* canvas) const {
// 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) {
return;
}
// Split the vertex data.
std::vector<SkPoint> positions(vertexCount);
std::vector<SkPoint> texs(vertexCount);
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;
}
// Deform the position.
Vec2D position(attrPosition[0], attrPosition[1]);
if (fActorImage->connectedBoneCount() > 0) {
position = deform(position, attrBoneIdx, attrBoneWgt);
} else {
position = deform(position, nullptr, nullptr);
}
// Set the data.
positions[i].set(position[0], position[1]);
texs[i].set(attrTex[0] * fTexture->width(), attrTex[1] * fTexture->height());
}
// Create vertices.
sk_sp<SkVertices> vertices = SkVertices::MakeCopy(SkVertices::kTriangles_VertexMode,
vertexCount,
positions.data(),
texs.data(),
nullptr,
indexCount,
indexData);
// Determine the blend mode.
SkBlendMode blendMode;
switch (fActorImage->blendMode()) {
case BlendMode::Off: {
blendMode = SkBlendMode::kSrc;
break;
}
case BlendMode::Normal: {
blendMode = SkBlendMode::kSrcOver;
break;
}
case BlendMode::Additive: {
blendMode = SkBlendMode::kPlus;
break;
}
case BlendMode::Multiply: {
blendMode = SkBlendMode::kMultiply;
break;
}
case BlendMode::Screen: {
blendMode = SkBlendMode::kScreen;
break;
}
}
// Set the opacity.
fPaint->setAlpha(static_cast<U8CPU>(fActorImage->renderOpacity() * 255));
// Draw the vertices.
canvas->drawVertices(vertices, blendMode, *fPaint);
// Reset the opacity.
fPaint->setAlpha(255);
}
Vec2D SampleActorImage::deform(const Vec2D& position, float* boneIdx, float* boneWgt) const {
float px = position[0], py = position[1];
float px2 = px, py2 = py;
float influence[6] = { 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f };
// Apply the world transform.
Mat2D worldTransform = fActorImage->worldTransform();
px2 = worldTransform[0] * px + worldTransform[2] * py + worldTransform[4];
py2 = worldTransform[1] * px + worldTransform[3] * py + worldTransform[5];
// Apply deformations based on bone offsets.
if (boneIdx && boneWgt) {
float* matrices = fActorImage->boneInfluenceMatrices();
for (uint32_t i = 0; i < 4; i ++) {
int index = static_cast<int>(boneIdx[i]);
float weight = boneWgt[i];
for (int j = 0; j < 6; j ++) {
influence[j] += matrices[index * 6 + j] * weight;
}
}
px = influence[0] * px2 + influence[2] * py2 + influence[4];
py = influence[1] * px2 + influence[3] * py2 + influence[5];
} else {
px = px2;
py = py2;
}
// Return the transformed position.
return Vec2D(px, py);
}