app/wallpapereffectsgeneration/TexturedMesh.java

/*
 * 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.
 */

package android.app.wallpapereffectsgeneration;

import android.annotation.IntDef;
import android.annotation.NonNull;
import android.annotation.SystemApi;
import android.graphics.Bitmap;
import android.os.Parcel;
import android.os.Parcelable;

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

/**
 * The textured mesh representation, including a texture (bitmap) to sample from when rendering,
 * and a mesh consisting of primitives such as triangles. The mesh is represented by an indices
 * array describing the set of primitives in the mesh, and a vertices array that the indices
 * refer to.
 *
 * @hide
 */
@SystemApi
public final class TexturedMesh implements Parcelable {
    /**
     * The texture to sample from when rendering mesh.
     */
    @NonNull
    private Bitmap mBitmap;

    /**
     * The set of primitives as pointers into the vertices.
     */
    @NonNull
    private int[] mIndices;

    /**
     * The specific vertices that the indices refer to.
     */
    @NonNull
    private float[] mVertices;

    /** @hide */
    @IntDef(prefix = {"INDICES_LAYOUT_"}, value = {
            INDICES_LAYOUT_UNDEFINED,
            INDICES_LAYOUT_TRIANGLES})
    @Retention(RetentionPolicy.SOURCE)
    public @interface IndicesLayoutType {
    }

    /** Undefined indices layout */
    public static final int INDICES_LAYOUT_UNDEFINED = 0;
    /**
     * Indices layout is triangle. Vertices are grouped into 3 and each
     * group forms a triangle.
     */
    public static final int INDICES_LAYOUT_TRIANGLES = 1;

    @IndicesLayoutType
    private int mIndicesLayoutType;

    /** @hide */
    @IntDef(prefix = {"VERTICES_LAYOUT_"}, value = {
            VERTICES_LAYOUT_UNDEFINED,
            VERTICES_LAYOUT_POSITION3_UV2})
    @Retention(RetentionPolicy.SOURCE)
    public @interface VerticesLayoutType {
    }

    /**
     * Undefined vertices layout.
     */
    public static final int VERTICES_LAYOUT_UNDEFINED = 0;
    /**
     * The vertices array uses 5 numbers to represent a point, in the format
     * of [x1, y1, z1, u1, v1, x2, y2, z2, u2, v2, ...].
     */
    public static final int VERTICES_LAYOUT_POSITION3_UV2 = 1;

    @VerticesLayoutType
    private int mVerticesLayoutType;

    private TexturedMesh(Parcel in) {
        this.mIndicesLayoutType = in.readInt();
        this.mVerticesLayoutType = in.readInt();
        this.mBitmap = in.readTypedObject(Bitmap.CREATOR);
        Parcel data = Parcel.obtain();
        try {
            byte[] bytes = in.readBlob();
            data.unmarshall(bytes, 0, bytes.length);
            data.setDataPosition(0);
            this.mIndices = data.createIntArray();
            this.mVertices = data.createFloatArray();
        } finally {
            data.recycle();
        }
    }

    private TexturedMesh(@NonNull Bitmap bitmap, @NonNull int[] indices,
            @NonNull float[] vertices, @IndicesLayoutType int indicesLayoutType,
            @VerticesLayoutType int verticesLayoutType) {
        mBitmap = bitmap;
        mIndices = indices;
        mVertices = vertices;
        mIndicesLayoutType = indicesLayoutType;
        mVerticesLayoutType = verticesLayoutType;
    }

    /** Get the bitmap, which is the texture to sample from when rendering. */
    @NonNull
    public Bitmap getBitmap() {
        return mBitmap;
    }

    /**
     * Get the indices as pointers to the vertices array. Depending on the getIndicesLayoutType(),
     * the primitives may have different shapes. For example, with INDICES_LAYOUT_TRIANGLES,
     * indices 0, 1, 2 forms a triangle, indices 3, 4, 5 form another triangle.
     */
    @NonNull
    public int[] getIndices() {
        return mIndices;
    }

    /**
     * Get the vertices that the index array refers to. Depending on the getVerticesLayoutType()
     * result, the vertices array can represent different per-vertex coordinates. For example,
     * with VERTICES_LAYOUT_POSITION3_UV2 type, vertices are in the format of
     * [x1, y1, z1, u1, v1, x2, y2, z2, u2, v2, ...].
     */
    @NonNull
    public float[] getVertices() {
        return mVertices;
    }

    /** Get the indices layout type. */
    @IndicesLayoutType
    @NonNull
    public int getIndicesLayoutType() {
        return mIndicesLayoutType;
    }

    /** Get the indices layout type. */
    @VerticesLayoutType
    @NonNull
    public int getVerticesLayoutType() {
        return mVerticesLayoutType;
    }

    @NonNull
    public static final Creator<TexturedMesh> CREATOR = new Creator<TexturedMesh>() {
        @Override
        public TexturedMesh createFromParcel(Parcel in) {
            return new TexturedMesh(in);
        }

        @Override
        public TexturedMesh[] newArray(int size) {
            return new TexturedMesh[size];
        }
    };

    @Override
    public void writeToParcel(@NonNull Parcel out, int flags) {
        out.writeInt(mIndicesLayoutType);
        out.writeInt(mVerticesLayoutType);
        out.writeTypedObject(mBitmap, flags);

        // Indices and vertices can reach 5MB. Write the data as a Blob,
        // which will be written to ashmem if too large.
        Parcel data = Parcel.obtain();
        try {
            data.writeIntArray(mIndices);
            data.writeFloatArray(mVertices);
            out.writeBlob(data.marshall());
        } finally {
            data.recycle();
        }
    }

    @Override
    public int describeContents() {
        return 0;
    }

    /**
     * A builder for {@link TexturedMesh}
     *
     * @hide
     */
    @SystemApi
    public static final class Builder {
        private Bitmap mBitmap;
        private int[] mIndices;
        private float[] mVertices;
        @IndicesLayoutType
        private int mIndicesLayoutType;
        @VerticesLayoutType
        private int mVerticesLayouttype;

        /**
         * Constructor with bitmap.
         *
         * @hide
         */
        @SystemApi
        public Builder(@NonNull Bitmap bitmap) {
            mBitmap = bitmap;
        }

        /**
         * Set the required indices. The indices should represent the primitives. For example,
         * with INDICES_LAYOUT_TRIANGLES, indices 0, 1, 2 forms a triangle, indices 3, 4, 5
         * form another triangle.
         */
        @NonNull
        public Builder setIndices(@NonNull int[] indices) {
            mIndices = indices;
            return this;
        }

        /**
         * Set the required vertices. The vertices array should represent per-vertex coordinates.
         * For example, with VERTICES_LAYOUT_POSITION3_UV2 type, vertices are in the format of
         * [x1, y1, z1, u1, v1, x2, y2, z2, u2, v2, ...].
         *
         */
        @NonNull
        public Builder setVertices(@NonNull float[] vertices) {
            mVertices = vertices;
            return this;
        }

        /**
         * Set the required indices layout type.
         */
        @NonNull
        public Builder setIndicesLayoutType(@IndicesLayoutType int indicesLayoutType) {
            mIndicesLayoutType = indicesLayoutType;
            return this;
        }

        /**
         * Set the required vertices layout type.
         */
        @NonNull
        public Builder setVerticesLayoutType(@VerticesLayoutType int verticesLayoutype) {
            mVerticesLayouttype = verticesLayoutype;
            return this;
        }

        /** Builds a TexturedMesh based on the given parameters. */
        @NonNull
        public TexturedMesh build() {
            return new TexturedMesh(mBitmap, mIndices, mVertices, mIndicesLayoutType,
                    mVerticesLayouttype);
        }
    }
}