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