libs/hwui/Mesh.h - platform/frameworks/base - Git at Google

 /*
  * Copyright (C) 2022 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #ifndef MESH_H_
 #define MESH_H_

 #include <SkMesh.h>
 #include <include/gpu/ganesh/GrDirectContext.h>
 #include <include/gpu/ganesh/SkMeshGanesh.h>
 #include <jni.h>
 #include <log/log.h>

 #include <utility>

 namespace android {

 class MeshUniformBuilder {
 public:
     struct MeshUniform {
         template <typename T>
         std::enable_if_t<std::is_trivially_copyable<T>::value, MeshUniform> operator=(
                 const T& val) {
             if (!fVar) {
                 LOG_FATAL("Assigning to missing variable");
             } else if (sizeof(val) != fVar->sizeInBytes()) {
                 LOG_FATAL("Incorrect value size");
             } else {
                 void* dst = reinterpret_cast<void*>(
                         reinterpret_cast<uint8_t*>(fOwner->writableUniformData()) + fVar->offset);
                 memcpy(dst, &val, sizeof(val));
             }
         }

         MeshUniform& operator=(const SkMatrix& val) {
             if (!fVar) {
                 LOG_FATAL("Assigning to missing variable");
             } else if (fVar->sizeInBytes() != 9 * sizeof(float)) {
                 LOG_FATAL("Incorrect value size");
             } else {
                 float* data = reinterpret_cast<float*>(
                         reinterpret_cast<uint8_t*>(fOwner->writableUniformData()) + fVar->offset);
                 data[0] = val.get(0);
                 data[1] = val.get(3);
                 data[2] = val.get(6);
                 data[3] = val.get(1);
                 data[4] = val.get(4);
                 data[5] = val.get(7);
                 data[6] = val.get(2);
                 data[7] = val.get(5);
                 data[8] = val.get(8);
             }
             return *this;
         }

         template <typename T>
         bool set(const T val[], const int count) {
             static_assert(std::is_trivially_copyable<T>::value, "Value must be trivial copyable");
             if (!fVar) {
                 LOG_FATAL("Assigning to missing variable");
                 return false;
             } else if (sizeof(T) * count != fVar->sizeInBytes()) {
                 LOG_FATAL("Incorrect value size");
                 return false;
             } else {
                 void* dst = reinterpret_cast<void*>(
                         reinterpret_cast<uint8_t*>(fOwner->writableUniformData()) + fVar->offset);
                 memcpy(dst, val, sizeof(T) * count);
             }
             return true;
         }

         MeshUniformBuilder* fOwner;
         const SkRuntimeEffect::Uniform* fVar;
     };
     MeshUniform uniform(std::string_view name) { return {this, fMeshSpec->findUniform(name)}; }

     explicit MeshUniformBuilder(sk_sp<SkMeshSpecification> meshSpec) {
         fMeshSpec = sk_sp(meshSpec);
         fUniforms = (SkData::MakeZeroInitialized(meshSpec->uniformSize()));
     }

     sk_sp<SkData> fUniforms;

 private:
     void* writableUniformData() {
         if (!fUniforms->unique()) {
             fUniforms = SkData::MakeWithCopy(fUniforms->data(), fUniforms->size());
         }
         return fUniforms->writable_data();
     }

     sk_sp<SkMeshSpecification> fMeshSpec;
 };

 // Storage for CPU and GPU copies of the vertex and index data of a mesh.
 class MeshBufferData {
 public:
     MeshBufferData(std::vector<uint8_t> vertexData, int32_t vertexCount, int32_t vertexOffset,
                    std::vector<uint8_t> indexData, int32_t indexCount, int32_t indexOffset)
             : mVertexCount(vertexCount)
             , mVertexOffset(vertexOffset)
             , mIndexCount(indexCount)
             , mIndexOffset(indexOffset)
             , mVertexData(std::move(vertexData))
             , mIndexData(std::move(indexData)) {}

     void updateBuffers(GrDirectContext* context) const {
         GrDirectContext::DirectContextID currentId = context == nullptr
                                                              ? GrDirectContext::DirectContextID()
                                                              : context->directContextID();
         if (currentId == mSkiaBuffers.fGenerationId && mSkiaBuffers.fVertexBuffer != nullptr) {
             // Nothing to update since the Android API does not support partial updates yet.
             return;
         }

         mSkiaBuffers.fVertexBuffer =
 #ifdef __ANDROID__
                 SkMeshes::MakeVertexBuffer(context, mVertexData.data(), mVertexData.size());
 #else
                 SkMeshes::MakeVertexBuffer(mVertexData.data(), mVertexData.size());
 #endif
         if (mIndexCount != 0) {
             mSkiaBuffers.fIndexBuffer =
 #ifdef __ANDROID__
                     SkMeshes::MakeIndexBuffer(context, mIndexData.data(), mIndexData.size());
 #else
                     SkMeshes::MakeIndexBuffer(mIndexData.data(), mIndexData.size());
 #endif
         }
         mSkiaBuffers.fGenerationId = currentId;
     }

     SkMesh::VertexBuffer* vertexBuffer() const { return mSkiaBuffers.fVertexBuffer.get(); }

     sk_sp<SkMesh::VertexBuffer> refVertexBuffer() const { return mSkiaBuffers.fVertexBuffer; }
     int32_t vertexCount() const { return mVertexCount; }
     int32_t vertexOffset() const { return mVertexOffset; }

     sk_sp<SkMesh::IndexBuffer> refIndexBuffer() const { return mSkiaBuffers.fIndexBuffer; }
     int32_t indexCount() const { return mIndexCount; }
     int32_t indexOffset() const { return mIndexOffset; }

     const std::vector<uint8_t>& vertexData() const { return mVertexData; }
     const std::vector<uint8_t>& indexData() const { return mIndexData; }

 private:
     struct CachedSkiaBuffers {
         sk_sp<SkMesh::VertexBuffer> fVertexBuffer;
         sk_sp<SkMesh::IndexBuffer> fIndexBuffer;
         GrDirectContext::DirectContextID fGenerationId = GrDirectContext::DirectContextID();
     };

     mutable CachedSkiaBuffers mSkiaBuffers;
     int32_t mVertexCount = 0;
     int32_t mVertexOffset = 0;
     int32_t mIndexCount = 0;
     int32_t mIndexOffset = 0;
     std::vector<uint8_t> mVertexData;
     std::vector<uint8_t> mIndexData;
 };

 class Mesh {
 public:
     // A snapshot of the mesh for use by the render thread.
     //
     // After a snapshot is taken, future uniform changes to the original Mesh will not modify the
     // uniforms returned by makeSkMesh.
     class Snapshot {
     public:
         Snapshot() = delete;
         Snapshot(const Snapshot&) = default;
         Snapshot(Snapshot&&) = default;
         Snapshot& operator=(const Snapshot&) = default;
         Snapshot& operator=(Snapshot&&) = default;
         ~Snapshot() = default;

         const SkMesh& getSkMesh() const {
             SkMesh::VertexBuffer* vertexBuffer = mBufferData->vertexBuffer();
             LOG_FATAL_IF(vertexBuffer == nullptr,
                          "Attempt to obtain SkMesh when vertexBuffer has not been created, did you "
                          "forget to call MeshBufferData::updateBuffers with a GrDirectContext?");
             if (vertexBuffer != mMesh.vertexBuffer()) mMesh = makeSkMesh();
             return mMesh;
         }

     private:
         friend class Mesh;

         Snapshot(sk_sp<SkMeshSpecification> meshSpec, SkMesh::Mode mode,
                  std::shared_ptr<const MeshBufferData> bufferData, sk_sp<const SkData> uniforms,
                  const SkRect& bounds)
                 : mMeshSpec(std::move(meshSpec))
                 , mMode(mode)
                 , mBufferData(std::move(bufferData))
                 , mUniforms(std::move(uniforms))
                 , mBounds(bounds) {}

         SkMesh makeSkMesh() const {
             const MeshBufferData& d = *mBufferData;
             if (d.indexCount() != 0) {
                 return SkMesh::MakeIndexed(mMeshSpec, mMode, d.refVertexBuffer(), d.vertexCount(),
                                            d.vertexOffset(), d.refIndexBuffer(), d.indexCount(),
                                            d.indexOffset(), mUniforms,
                                            SkSpan<SkRuntimeEffect::ChildPtr>(), mBounds)
                         .mesh;
             }
             return SkMesh::Make(mMeshSpec, mMode, d.refVertexBuffer(), d.vertexCount(),
                                 d.vertexOffset(), mUniforms, SkSpan<SkRuntimeEffect::ChildPtr>(),
                                 mBounds)
                     .mesh;
         }

         mutable SkMesh mMesh;
         sk_sp<SkMeshSpecification> mMeshSpec;
         SkMesh::Mode mMode;
         std::shared_ptr<const MeshBufferData> mBufferData;
         sk_sp<const SkData> mUniforms;
         SkRect mBounds;
     };

     Mesh(sk_sp<SkMeshSpecification> meshSpec, SkMesh::Mode mode, std::vector<uint8_t> vertexData,
          int32_t vertexCount, int32_t vertexOffset, const SkRect& bounds)
             : Mesh(std::move(meshSpec), mode, std::move(vertexData), vertexCount, vertexOffset,
                    /* indexData = */ {}, /* indexCount = */ 0, /* indexOffset = */ 0, bounds) {}

     Mesh(sk_sp<SkMeshSpecification> meshSpec, SkMesh::Mode mode, std::vector<uint8_t> vertexData,
          int32_t vertexCount, int32_t vertexOffset, std::vector<uint8_t> indexData,
          int32_t indexCount, int32_t indexOffset, const SkRect& bounds)
             : mMeshSpec(std::move(meshSpec))
             , mMode(mode)
             , mBufferData(std::make_shared<MeshBufferData>(std::move(vertexData), vertexCount,
                                                            vertexOffset, std::move(indexData),
                                                            indexCount, indexOffset))
             , mUniformBuilder(mMeshSpec)
             , mBounds(bounds) {}

     Mesh(Mesh&&) = default;

     Mesh& operator=(Mesh&&) = default;

     [[nodiscard]] std::tuple<bool, SkString> validate();

     std::shared_ptr<const MeshBufferData> refBufferData() const { return mBufferData; }

     Snapshot takeSnapshot() const {
         return Snapshot(mMeshSpec, mMode, mBufferData, mUniformBuilder.fUniforms, mBounds);
     }

     MeshUniformBuilder* uniformBuilder() { return &mUniformBuilder; }

 private:
     sk_sp<SkMeshSpecification> mMeshSpec;
     SkMesh::Mode mMode;
     std::shared_ptr<MeshBufferData> mBufferData;
     MeshUniformBuilder mUniformBuilder;
     SkRect mBounds;
 };

 }  // namespace android

 #endif  // MESH_H_
	/*
	* Copyright (C) 2022 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#ifndef MESH_H_
	#define MESH_H_

	#include <SkMesh.h>
	#include <include/gpu/ganesh/GrDirectContext.h>
	#include <include/gpu/ganesh/SkMeshGanesh.h>
	#include <jni.h>
	#include <log/log.h>

	#include <utility>

	namespace android {

	class MeshUniformBuilder {
	public:
	struct MeshUniform {
	template <typename T>
	std::enable_if_t<std::is_trivially_copyable<T>::value, MeshUniform> operator=(
	const T& val) {
	if (!fVar) {
	LOG_FATAL("Assigning to missing variable");
	} else if (sizeof(val) != fVar->sizeInBytes()) {
	LOG_FATAL("Incorrect value size");
	} else {
	void* dst = reinterpret_cast<void*>(
	reinterpret_cast<uint8_t*>(fOwner->writableUniformData()) + fVar->offset);
	memcpy(dst, &val, sizeof(val));
	}
	}

	MeshUniform& operator=(const SkMatrix& val) {
	if (!fVar) {
	LOG_FATAL("Assigning to missing variable");
	} else if (fVar->sizeInBytes() != 9 * sizeof(float)) {
	LOG_FATAL("Incorrect value size");
	} else {
	float* data = reinterpret_cast<float*>(
	reinterpret_cast<uint8_t*>(fOwner->writableUniformData()) + fVar->offset);
	data[0] = val.get(0);
	data[1] = val.get(3);
	data[2] = val.get(6);
	data[3] = val.get(1);
	data[4] = val.get(4);
	data[5] = val.get(7);
	data[6] = val.get(2);
	data[7] = val.get(5);
	data[8] = val.get(8);
	}
	return *this;
	}

	template <typename T>
	bool set(const T val[], const int count) {
	static_assert(std::is_trivially_copyable<T>::value, "Value must be trivial copyable");
	if (!fVar) {
	LOG_FATAL("Assigning to missing variable");
	return false;
	} else if (sizeof(T) * count != fVar->sizeInBytes()) {
	LOG_FATAL("Incorrect value size");
	return false;
	} else {
	void* dst = reinterpret_cast<void*>(
	reinterpret_cast<uint8_t*>(fOwner->writableUniformData()) + fVar->offset);
	memcpy(dst, val, sizeof(T) * count);
	}
	return true;
	}

	MeshUniformBuilder* fOwner;
	const SkRuntimeEffect::Uniform* fVar;
	};
	MeshUniform uniform(std::string_view name) { return {this, fMeshSpec->findUniform(name)}; }

	explicit MeshUniformBuilder(sk_sp<SkMeshSpecification> meshSpec) {
	fMeshSpec = sk_sp(meshSpec);
	fUniforms = (SkData::MakeZeroInitialized(meshSpec->uniformSize()));
	}

	sk_sp<SkData> fUniforms;

	private:
	void* writableUniformData() {
	if (!fUniforms->unique()) {
	fUniforms = SkData::MakeWithCopy(fUniforms->data(), fUniforms->size());
	}
	return fUniforms->writable_data();
	}

	sk_sp<SkMeshSpecification> fMeshSpec;
	};

	// Storage for CPU and GPU copies of the vertex and index data of a mesh.
	class MeshBufferData {
	public:
	MeshBufferData(std::vector<uint8_t> vertexData, int32_t vertexCount, int32_t vertexOffset,
	std::vector<uint8_t> indexData, int32_t indexCount, int32_t indexOffset)
	: mVertexCount(vertexCount)
	, mVertexOffset(vertexOffset)
	, mIndexCount(indexCount)
	, mIndexOffset(indexOffset)
	, mVertexData(std::move(vertexData))
	, mIndexData(std::move(indexData)) {}

	void updateBuffers(GrDirectContext* context) const {
	GrDirectContext::DirectContextID currentId = context == nullptr
	? GrDirectContext::DirectContextID()
	: context->directContextID();
	if (currentId == mSkiaBuffers.fGenerationId && mSkiaBuffers.fVertexBuffer != nullptr) {
	// Nothing to update since the Android API does not support partial updates yet.
	return;
	}

	mSkiaBuffers.fVertexBuffer =
	#ifdef __ANDROID__
	SkMeshes::MakeVertexBuffer(context, mVertexData.data(), mVertexData.size());
	#else
	SkMeshes::MakeVertexBuffer(mVertexData.data(), mVertexData.size());
	#endif
	if (mIndexCount != 0) {
	mSkiaBuffers.fIndexBuffer =
	#ifdef __ANDROID__
	SkMeshes::MakeIndexBuffer(context, mIndexData.data(), mIndexData.size());
	#else
	SkMeshes::MakeIndexBuffer(mIndexData.data(), mIndexData.size());
	#endif
	}
	mSkiaBuffers.fGenerationId = currentId;
	}

	SkMesh::VertexBuffer* vertexBuffer() const { return mSkiaBuffers.fVertexBuffer.get(); }

	sk_sp<SkMesh::VertexBuffer> refVertexBuffer() const { return mSkiaBuffers.fVertexBuffer; }
	int32_t vertexCount() const { return mVertexCount; }
	int32_t vertexOffset() const { return mVertexOffset; }

	sk_sp<SkMesh::IndexBuffer> refIndexBuffer() const { return mSkiaBuffers.fIndexBuffer; }
	int32_t indexCount() const { return mIndexCount; }
	int32_t indexOffset() const { return mIndexOffset; }

	const std::vector<uint8_t>& vertexData() const { return mVertexData; }
	const std::vector<uint8_t>& indexData() const { return mIndexData; }

	private:
	struct CachedSkiaBuffers {
	sk_sp<SkMesh::VertexBuffer> fVertexBuffer;
	sk_sp<SkMesh::IndexBuffer> fIndexBuffer;
	GrDirectContext::DirectContextID fGenerationId = GrDirectContext::DirectContextID();
	};

	mutable CachedSkiaBuffers mSkiaBuffers;
	int32_t mVertexCount = 0;
	int32_t mVertexOffset = 0;
	int32_t mIndexCount = 0;
	int32_t mIndexOffset = 0;
	std::vector<uint8_t> mVertexData;
	std::vector<uint8_t> mIndexData;
	};

	class Mesh {
	public:
	// A snapshot of the mesh for use by the render thread.
	//
	// After a snapshot is taken, future uniform changes to the original Mesh will not modify the
	// uniforms returned by makeSkMesh.
	class Snapshot {
	public:
	Snapshot() = delete;
	Snapshot(const Snapshot&) = default;
	Snapshot(Snapshot&&) = default;
	Snapshot& operator=(const Snapshot&) = default;
	Snapshot& operator=(Snapshot&&) = default;
	~Snapshot() = default;

	const SkMesh& getSkMesh() const {
	SkMesh::VertexBuffer* vertexBuffer = mBufferData->vertexBuffer();
	LOG_FATAL_IF(vertexBuffer == nullptr,
	"Attempt to obtain SkMesh when vertexBuffer has not been created, did you "
	"forget to call MeshBufferData::updateBuffers with a GrDirectContext?");
	if (vertexBuffer != mMesh.vertexBuffer()) mMesh = makeSkMesh();
	return mMesh;
	}

	private:
	friend class Mesh;

	Snapshot(sk_sp<SkMeshSpecification> meshSpec, SkMesh::Mode mode,
	std::shared_ptr<const MeshBufferData> bufferData, sk_sp<const SkData> uniforms,
	const SkRect& bounds)
	: mMeshSpec(std::move(meshSpec))
	, mMode(mode)
	, mBufferData(std::move(bufferData))
	, mUniforms(std::move(uniforms))
	, mBounds(bounds) {}

	SkMesh makeSkMesh() const {
	const MeshBufferData& d = *mBufferData;
	if (d.indexCount() != 0) {
	return SkMesh::MakeIndexed(mMeshSpec, mMode, d.refVertexBuffer(), d.vertexCount(),
	d.vertexOffset(), d.refIndexBuffer(), d.indexCount(),
	d.indexOffset(), mUniforms,
	SkSpan<SkRuntimeEffect::ChildPtr>(), mBounds)
	.mesh;
	}
	return SkMesh::Make(mMeshSpec, mMode, d.refVertexBuffer(), d.vertexCount(),
	d.vertexOffset(), mUniforms, SkSpan<SkRuntimeEffect::ChildPtr>(),
	mBounds)
	.mesh;
	}

	mutable SkMesh mMesh;
	sk_sp<SkMeshSpecification> mMeshSpec;
	SkMesh::Mode mMode;
	std::shared_ptr<const MeshBufferData> mBufferData;
	sk_sp<const SkData> mUniforms;
	SkRect mBounds;
	};

	Mesh(sk_sp<SkMeshSpecification> meshSpec, SkMesh::Mode mode, std::vector<uint8_t> vertexData,
	int32_t vertexCount, int32_t vertexOffset, const SkRect& bounds)
	: Mesh(std::move(meshSpec), mode, std::move(vertexData), vertexCount, vertexOffset,
	/* indexData = / {}, / indexCount = / 0, / indexOffset = */ 0, bounds) {}

	Mesh(sk_sp<SkMeshSpecification> meshSpec, SkMesh::Mode mode, std::vector<uint8_t> vertexData,
	int32_t vertexCount, int32_t vertexOffset, std::vector<uint8_t> indexData,
	int32_t indexCount, int32_t indexOffset, const SkRect& bounds)
	: mMeshSpec(std::move(meshSpec))
	, mMode(mode)
	, mBufferData(std::make_shared<MeshBufferData>(std::move(vertexData), vertexCount,
	vertexOffset, std::move(indexData),
	indexCount, indexOffset))
	, mUniformBuilder(mMeshSpec)
	, mBounds(bounds) {}

	Mesh(Mesh&&) = default;

	Mesh& operator=(Mesh&&) = default;

	[[nodiscard]] std::tuple<bool, SkString> validate();

	std::shared_ptr<const MeshBufferData> refBufferData() const { return mBufferData; }

	Snapshot takeSnapshot() const {
	return Snapshot(mMeshSpec, mMode, mBufferData, mUniformBuilder.fUniforms, mBounds);
	}

	MeshUniformBuilder* uniformBuilder() { return &mUniformBuilder; }

	private:
	sk_sp<SkMeshSpecification> mMeshSpec;
	SkMesh::Mode mMode;
	std::shared_ptr<MeshBufferData> mBufferData;
	MeshUniformBuilder mUniformBuilder;
	SkRect mBounds;
	};

	} // namespace android

	#endif // MESH_H_