| /* |
| * Copyright (C) 2013 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 ANDROID_RSCPPSTRUCTS_H |
| #define ANDROID_RSCPPSTRUCTS_H |
| |
| #include "rsDefines.h" |
| #include "util/RefBase.h" |
| |
| #include <pthread.h> |
| |
| |
| /** |
| * Every row in an RS allocation is guaranteed to be aligned by this amount, and |
| * every row in a user-backed allocation must be aligned by this amount. |
| */ |
| #define RS_CPU_ALLOCATION_ALIGNMENT 16 |
| |
| struct dispatchTable; |
| |
| namespace android { |
| class Surface; |
| |
| namespace RSC { |
| |
| |
| typedef void (*ErrorHandlerFunc_t)(uint32_t errorNum, const char *errorText); |
| typedef void (*MessageHandlerFunc_t)(uint32_t msgNum, const void *msgData, size_t msgLen); |
| |
| class RS; |
| class BaseObj; |
| class Element; |
| class Type; |
| class Allocation; |
| class Script; |
| class ScriptC; |
| class Sampler; |
| |
| /** |
| * Possible error codes used by RenderScript. Once a status other than RS_SUCCESS |
| * is returned, the RenderScript context is considered dead and cannot perform any |
| * additional work. |
| */ |
| enum RSError { |
| RS_SUCCESS = 0, ///< No error |
| RS_ERROR_INVALID_PARAMETER = 1, ///< An invalid parameter was passed to a function |
| RS_ERROR_RUNTIME_ERROR = 2, ///< The RenderScript driver returned an error; this is |
| ///< often indicative of a kernel that crashed |
| RS_ERROR_INVALID_ELEMENT = 3, ///< An invalid Element was passed to a function |
| RS_ERROR_MAX = 9999 |
| |
| }; |
| |
| /** |
| * YUV formats supported by the RenderScript API. |
| */ |
| enum RSYuvFormat { |
| RS_YUV_NONE = 0, ///< No YUV data |
| RS_YUV_YV12 = 1, ///< YUV data in YV12 format |
| RS_YUV_NV21 = 2, ///< YUV data in NV21 format |
| RS_YUV_MAX = 3 |
| }; |
| |
| /** |
| * Flags that can control RenderScript behavior on a per-context level. |
| */ |
| enum RSInitFlags { |
| RS_INIT_SYNCHRONOUS = 1, ///< All RenderScript calls will be synchronous. May reduce latency. |
| RS_INIT_LOW_LATENCY = 2, ///< Prefer low latency devices over potentially higher throughput devices. |
| // Bitflag 4 is reserved for the context flag low power |
| RS_INIT_WAIT_FOR_ATTACH = 8, ///< Kernel execution will hold to give time for a debugger to be attached |
| RS_INIT_MAX = 16 |
| }; |
| |
| /** |
| * The RenderScript context. This class controls initialization, resource management, and teardown. |
| */ |
| class RS : public android::RSC::LightRefBase<RS> { |
| |
| public: |
| RS(); |
| virtual ~RS(); |
| |
| /** |
| * Initializes a RenderScript context. A context must be initialized before it can be used. |
| * @param[in] name Directory name to be used by this context. This should be equivalent to |
| * Context.getCacheDir(). |
| * @param[in] flags Optional flags for this context. |
| * @return true on success |
| */ |
| bool init(const char * name, uint32_t flags = 0); |
| |
| /** |
| * Sets the error handler function for this context. This error handler is |
| * called whenever an error is set. |
| * |
| * @param[in] func Error handler function |
| */ |
| void setErrorHandler(ErrorHandlerFunc_t func); |
| |
| /** |
| * Returns the current error handler function for this context. |
| * |
| * @return pointer to current error handler function or NULL if not set |
| */ |
| ErrorHandlerFunc_t getErrorHandler() { return mErrorFunc; } |
| |
| /** |
| * Sets the message handler function for this context. This message handler |
| * is called whenever a message is sent from a RenderScript kernel. |
| * |
| * @param[in] func Message handler function |
| */ |
| void setMessageHandler(MessageHandlerFunc_t func); |
| |
| /** |
| * Returns the current message handler function for this context. |
| * |
| * @return pointer to current message handler function or NULL if not set |
| */ |
| MessageHandlerFunc_t getMessageHandler() { return mMessageFunc; } |
| |
| /** |
| * Returns current status for the context. |
| * |
| * @return current error |
| */ |
| RSError getError(); |
| |
| /** |
| * Waits for any currently running asynchronous operations to finish. This |
| * should only be used for performance testing and timing. |
| */ |
| void finish(); |
| |
| RsContext getContext() { return mContext; } |
| void throwError(RSError error, const char *errMsg); |
| |
| static dispatchTable* dispatch; |
| |
| private: |
| static bool usingNative; |
| static bool initDispatch(int targetApi); |
| |
| bool init(const char * name, int targetApi, uint32_t flags); |
| static void * threadProc(void *); |
| |
| static bool gInitialized; |
| static pthread_mutex_t gInitMutex; |
| |
| pthread_t mMessageThreadId; |
| pid_t mNativeMessageThreadId; |
| bool mMessageRun; |
| |
| RsDevice mDev; |
| RsContext mContext; |
| RSError mCurrentError; |
| |
| ErrorHandlerFunc_t mErrorFunc; |
| MessageHandlerFunc_t mMessageFunc; |
| bool mInit; |
| |
| char mCacheDir[PATH_MAX+1]; |
| uint32_t mCacheDirLen; |
| |
| struct { |
| sp<const Element> U8; |
| sp<const Element> U8_2; |
| sp<const Element> U8_3; |
| sp<const Element> U8_4; |
| sp<const Element> I8; |
| sp<const Element> I8_2; |
| sp<const Element> I8_3; |
| sp<const Element> I8_4; |
| sp<const Element> U16; |
| sp<const Element> U16_2; |
| sp<const Element> U16_3; |
| sp<const Element> U16_4; |
| sp<const Element> I16; |
| sp<const Element> I16_2; |
| sp<const Element> I16_3; |
| sp<const Element> I16_4; |
| sp<const Element> U32; |
| sp<const Element> U32_2; |
| sp<const Element> U32_3; |
| sp<const Element> U32_4; |
| sp<const Element> I32; |
| sp<const Element> I32_2; |
| sp<const Element> I32_3; |
| sp<const Element> I32_4; |
| sp<const Element> U64; |
| sp<const Element> U64_2; |
| sp<const Element> U64_3; |
| sp<const Element> U64_4; |
| sp<const Element> I64; |
| sp<const Element> I64_2; |
| sp<const Element> I64_3; |
| sp<const Element> I64_4; |
| sp<const Element> F32; |
| sp<const Element> F32_2; |
| sp<const Element> F32_3; |
| sp<const Element> F32_4; |
| sp<const Element> F64; |
| sp<const Element> F64_2; |
| sp<const Element> F64_3; |
| sp<const Element> F64_4; |
| sp<const Element> BOOLEAN; |
| |
| sp<const Element> ELEMENT; |
| sp<const Element> TYPE; |
| sp<const Element> ALLOCATION; |
| sp<const Element> SAMPLER; |
| sp<const Element> SCRIPT; |
| sp<const Element> MESH; |
| sp<const Element> PROGRAM_FRAGMENT; |
| sp<const Element> PROGRAM_VERTEX; |
| sp<const Element> PROGRAM_RASTER; |
| sp<const Element> PROGRAM_STORE; |
| |
| sp<const Element> A_8; |
| sp<const Element> RGB_565; |
| sp<const Element> RGB_888; |
| sp<const Element> RGBA_5551; |
| sp<const Element> RGBA_4444; |
| sp<const Element> RGBA_8888; |
| |
| sp<const Element> YUV; |
| |
| sp<const Element> MATRIX_4X4; |
| sp<const Element> MATRIX_3X3; |
| sp<const Element> MATRIX_2X2; |
| } mElements; |
| |
| struct { |
| sp<const Sampler> CLAMP_NEAREST; |
| sp<const Sampler> CLAMP_LINEAR; |
| sp<const Sampler> CLAMP_LINEAR_MIP_LINEAR; |
| sp<const Sampler> WRAP_NEAREST; |
| sp<const Sampler> WRAP_LINEAR; |
| sp<const Sampler> WRAP_LINEAR_MIP_LINEAR; |
| sp<const Sampler> MIRRORED_REPEAT_NEAREST; |
| sp<const Sampler> MIRRORED_REPEAT_LINEAR; |
| sp<const Sampler> MIRRORED_REPEAT_LINEAR_MIP_LINEAR; |
| } mSamplers; |
| friend class Sampler; |
| friend class Element; |
| friend class ScriptC; |
| }; |
| |
| /** |
| * Base class for all RenderScript objects. Not for direct use by developers. |
| */ |
| class BaseObj : public android::RSC::LightRefBase<BaseObj> { |
| public: |
| void * getID() const; |
| virtual ~BaseObj(); |
| virtual void updateFromNative(); |
| virtual bool equals(sp<const BaseObj> obj); |
| |
| protected: |
| void *mID; |
| RS* mRS; |
| const char * mName; |
| |
| BaseObj(void *id, sp<RS> rs); |
| void checkValid(); |
| |
| static void * getObjID(sp<const BaseObj> o); |
| |
| }; |
| |
| /** |
| * This class provides the primary method through which data is passed to and |
| * from RenderScript kernels. An Allocation provides the backing store for a |
| * given Type. |
| * |
| * An Allocation also contains a set of usage flags that denote how the |
| * Allocation could be used. For example, an Allocation may have usage flags |
| * specifying that it can be used from a script as well as input to a |
| * Sampler. A developer must synchronize across these different usages using |
| * syncAll(int) in order to ensure that different users of the Allocation have |
| * a consistent view of memory. For example, in the case where an Allocation is |
| * used as the output of one kernel and as Sampler input in a later kernel, a |
| * developer must call syncAll(RS_ALLOCATION_USAGE_SCRIPT) prior to launching the |
| * second kernel to ensure correctness. |
| */ |
| class Allocation : public BaseObj { |
| protected: |
| sp<const Type> mType; |
| uint32_t mUsage; |
| sp<Allocation> mAdaptedAllocation; |
| |
| bool mConstrainedLOD; |
| bool mConstrainedFace; |
| bool mConstrainedY; |
| bool mConstrainedZ; |
| bool mReadAllowed; |
| bool mWriteAllowed; |
| bool mAutoPadding; |
| uint32_t mSelectedY; |
| uint32_t mSelectedZ; |
| uint32_t mSelectedLOD; |
| RsAllocationCubemapFace mSelectedFace; |
| |
| uint32_t mCurrentDimX; |
| uint32_t mCurrentDimY; |
| uint32_t mCurrentDimZ; |
| uint32_t mCurrentCount; |
| |
| void * getIDSafe() const; |
| void updateCacheInfo(sp<const Type> t); |
| |
| Allocation(void *id, sp<RS> rs, sp<const Type> t, uint32_t usage); |
| |
| void validateIsInt64(); |
| void validateIsInt32(); |
| void validateIsInt16(); |
| void validateIsInt8(); |
| void validateIsFloat32(); |
| void validateIsFloat64(); |
| void validateIsObject(); |
| |
| virtual void updateFromNative(); |
| |
| void validate2DRange(uint32_t xoff, uint32_t yoff, uint32_t w, uint32_t h); |
| void validate3DRange(uint32_t xoff, uint32_t yoff, uint32_t zoff, |
| uint32_t w, uint32_t h, uint32_t d); |
| |
| public: |
| |
| /** |
| * Return Type for the allocation. |
| * @return pointer to underlying Type |
| */ |
| sp<const Type> getType() const { |
| return mType; |
| } |
| |
| /** |
| * Enable/Disable AutoPadding for Vec3 elements. |
| * |
| * @param useAutoPadding True: enable AutoPadding; flase: disable AutoPadding |
| * |
| */ |
| void setAutoPadding(bool useAutoPadding) { |
| mAutoPadding = useAutoPadding; |
| } |
| |
| /** |
| * Propagate changes from one usage of the Allocation to other usages of the Allocation. |
| * @param[in] srcLocation source location with changes to propagate elsewhere |
| */ |
| void syncAll(RsAllocationUsageType srcLocation); |
| |
| /** |
| * Send a buffer to the output stream. The contents of the Allocation will |
| * be undefined after this operation. This operation is only valid if |
| * USAGE_IO_OUTPUT is set on the Allocation. |
| */ |
| void ioSendOutput(); |
| |
| /** |
| * Receive the latest input into the Allocation. This operation |
| * is only valid if USAGE_IO_INPUT is set on the Allocation. |
| */ |
| void ioGetInput(); |
| |
| #if !defined(RS_SERVER) && !defined(RS_COMPATIBILITY_LIB) |
| /** |
| * Returns the handle to a raw buffer that is being managed by the screen |
| * compositor. This operation is only valid for Allocations with USAGE_IO_INPUT. |
| * @return Surface associated with allocation |
| */ |
| sp<Surface> getSurface(); |
| |
| /** |
| * Associate a Surface with this Allocation. This |
| * operation is only valid for Allocations with USAGE_IO_OUTPUT. |
| * @param[in] s Surface to associate with allocation |
| */ |
| void setSurface(sp<Surface> s); |
| #endif |
| |
| /** |
| * Generate a mipmap chain. This is only valid if the Type of the Allocation |
| * includes mipmaps. This function will generate a complete set of mipmaps |
| * from the top level LOD and place them into the script memory space. If |
| * the Allocation is also using other memory spaces, a call to |
| * syncAll(Allocation.USAGE_SCRIPT) is required. |
| */ |
| void generateMipmaps(); |
| |
| /** |
| * Copy an array into part of this Allocation. |
| * @param[in] off offset of first Element to be overwritten |
| * @param[in] count number of Elements to copy |
| * @param[in] data array from which to copy |
| */ |
| void copy1DRangeFrom(uint32_t off, size_t count, const void *data); |
| |
| /** |
| * Copy part of an Allocation into part of this Allocation. |
| * @param[in] off offset of first Element to be overwritten |
| * @param[in] count number of Elements to copy |
| * @param[in] data Allocation from which to copy |
| * @param[in] dataOff offset of first Element in data to copy |
| */ |
| void copy1DRangeFrom(uint32_t off, size_t count, sp<const Allocation> data, uint32_t dataOff); |
| |
| /** |
| * Copy an array into part of this Allocation. |
| * @param[in] off offset of first Element to be overwritten |
| * @param[in] count number of Elements to copy |
| * @param[in] data array from which to copy |
| */ |
| void copy1DRangeTo(uint32_t off, size_t count, void *data); |
| |
| /** |
| * Copy entire array to an Allocation. |
| * @param[in] data array from which to copy |
| */ |
| void copy1DFrom(const void* data); |
| |
| /** |
| * Copy entire Allocation to an array. |
| * @param[in] data destination array |
| */ |
| void copy1DTo(void* data); |
| |
| /** |
| * Copy from an array into a rectangular region in this Allocation. The |
| * array is assumed to be tightly packed. |
| * @param[in] xoff X offset of region to update in this Allocation |
| * @param[in] yoff Y offset of region to update in this Allocation |
| * @param[in] w Width of region to update |
| * @param[in] h Height of region to update |
| * @param[in] data Array from which to copy |
| */ |
| void copy2DRangeFrom(uint32_t xoff, uint32_t yoff, uint32_t w, uint32_t h, |
| const void *data); |
| |
| /** |
| * Copy from this Allocation into a rectangular region in an array. The |
| * array is assumed to be tightly packed. |
| * @param[in] xoff X offset of region to copy from this Allocation |
| * @param[in] yoff Y offset of region to copy from this Allocation |
| * @param[in] w Width of region to update |
| * @param[in] h Height of region to update |
| * @param[in] data destination array |
| */ |
| void copy2DRangeTo(uint32_t xoff, uint32_t yoff, uint32_t w, uint32_t h, |
| void *data); |
| |
| /** |
| * Copy from an Allocation into a rectangular region in this Allocation. |
| * @param[in] xoff X offset of region to update in this Allocation |
| * @param[in] yoff Y offset of region to update in this Allocation |
| * @param[in] w Width of region to update |
| * @param[in] h Height of region to update |
| * @param[in] data Allocation from which to copy |
| * @param[in] dataXoff X offset of region to copy from in data |
| * @param[in] dataYoff Y offset of region to copy from in data |
| */ |
| void copy2DRangeFrom(uint32_t xoff, uint32_t yoff, uint32_t w, uint32_t h, |
| sp<const Allocation> data, uint32_t dataXoff, uint32_t dataYoff); |
| |
| /** |
| * Copy from a strided array into a rectangular region in this Allocation. |
| * @param[in] xoff X offset of region to update in this Allocation |
| * @param[in] yoff Y offset of region to update in this Allocation |
| * @param[in] w Width of region to update |
| * @param[in] h Height of region to update |
| * @param[in] data array from which to copy |
| * @param[in] stride stride of data in bytes |
| */ |
| void copy2DStridedFrom(uint32_t xoff, uint32_t yoff, uint32_t w, uint32_t h, |
| const void *data, size_t stride); |
| |
| /** |
| * Copy from a strided array into this Allocation. |
| * @param[in] data array from which to copy |
| * @param[in] stride stride of data in bytes |
| */ |
| void copy2DStridedFrom(const void *data, size_t stride); |
| |
| /** |
| * Copy from a rectangular region in this Allocation into a strided array. |
| * @param[in] xoff X offset of region to update in this Allocation |
| * @param[in] yoff Y offset of region to update in this Allocation |
| * @param[in] w Width of region to update |
| * @param[in] h Height of region to update |
| * @param[in] data destination array |
| * @param[in] stride stride of data in bytes |
| */ |
| void copy2DStridedTo(uint32_t xoff, uint32_t yoff, uint32_t w, uint32_t h, |
| void *data, size_t stride); |
| |
| /** |
| * Copy this Allocation into a strided array. |
| * @param[in] data destination array |
| * @param[in] stride stride of data in bytes |
| */ |
| void copy2DStridedTo(void *data, size_t stride); |
| |
| |
| /** |
| * Copy from an array into a 3D region in this Allocation. The |
| * array is assumed to be tightly packed. |
| * @param[in] xoff X offset of region to update in this Allocation |
| * @param[in] yoff Y offset of region to update in this Allocation |
| * @param[in] zoff Z offset of region to update in this Allocation |
| * @param[in] w Width of region to update |
| * @param[in] h Height of region to update |
| * @param[in] d Depth of region to update |
| * @param[in] data Array from which to copy |
| */ |
| void copy3DRangeFrom(uint32_t xoff, uint32_t yoff, uint32_t zoff, uint32_t w, |
| uint32_t h, uint32_t d, const void* data); |
| |
| /** |
| * Copy from an Allocation into a 3D region in this Allocation. |
| * @param[in] xoff X offset of region to update in this Allocation |
| * @param[in] yoff Y offset of region to update in this Allocation |
| * @param[in] zoff Z offset of region to update in this Allocation |
| * @param[in] w Width of region to update |
| * @param[in] h Height of region to update |
| * @param[in] d Depth of region to update |
| * @param[in] data Allocation from which to copy |
| * @param[in] dataXoff X offset of region in data to copy from |
| * @param[in] dataYoff Y offset of region in data to copy from |
| * @param[in] dataZoff Z offset of region in data to copy from |
| */ |
| void copy3DRangeFrom(uint32_t xoff, uint32_t yoff, uint32_t zoff, |
| uint32_t w, uint32_t h, uint32_t d, |
| sp<const Allocation> data, |
| uint32_t dataXoff, uint32_t dataYoff, uint32_t dataZoff); |
| |
| /** |
| * Copy a 3D region in this Allocation into an array. The |
| * array is assumed to be tightly packed. |
| * @param[in] xoff X offset of region to update in this Allocation |
| * @param[in] yoff Y offset of region to update in this Allocation |
| * @param[in] zoff Z offset of region to update in this Allocation |
| * @param[in] w Width of region to update |
| * @param[in] h Height of region to update |
| * @param[in] d Depth of region to update |
| * @param[in] data Array from which to copy |
| */ |
| void copy3DRangeTo(uint32_t xoff, uint32_t yoff, uint32_t zoff, uint32_t w, |
| uint32_t h, uint32_t d, void* data); |
| |
| /** |
| * Creates an Allocation for use by scripts with a given Type. |
| * @param[in] rs Context to which the Allocation will belong |
| * @param[in] type Type of the Allocation |
| * @param[in] mipmaps desired mipmap behavior for the Allocation |
| * @param[in] usage usage for the Allocation |
| * @return new Allocation |
| */ |
| static sp<Allocation> createTyped(sp<RS> rs, sp<const Type> type, |
| RsAllocationMipmapControl mipmaps, uint32_t usage); |
| |
| /** |
| * Creates an Allocation for use by scripts with a given Type and a backing pointer. For use |
| * with RS_ALLOCATION_USAGE_SHARED. |
| * @param[in] rs Context to which the Allocation will belong |
| * @param[in] type Type of the Allocation |
| * @param[in] mipmaps desired mipmap behavior for the Allocation |
| * @param[in] usage usage for the Allocation |
| * @param[in] pointer existing backing store to use for this Allocation if possible |
| * @return new Allocation |
| */ |
| static sp<Allocation> createTyped(sp<RS> rs, sp<const Type> type, |
| RsAllocationMipmapControl mipmaps, uint32_t usage, void * pointer); |
| |
| /** |
| * Creates an Allocation for use by scripts with a given Type with no mipmaps. |
| * @param[in] rs Context to which the Allocation will belong |
| * @param[in] type Type of the Allocation |
| * @param[in] usage usage for the Allocation |
| * @return new Allocation |
| */ |
| static sp<Allocation> createTyped(sp<RS> rs, sp<const Type> type, |
| uint32_t usage = RS_ALLOCATION_USAGE_SCRIPT); |
| /** |
| * Creates an Allocation with a specified number of given elements. |
| * @param[in] rs Context to which the Allocation will belong |
| * @param[in] e Element used in the Allocation |
| * @param[in] count Number of elements of the Allocation |
| * @param[in] usage usage for the Allocation |
| * @return new Allocation |
| */ |
| static sp<Allocation> createSized(sp<RS> rs, sp<const Element> e, size_t count, |
| uint32_t usage = RS_ALLOCATION_USAGE_SCRIPT); |
| |
| /** |
| * Creates a 2D Allocation with a specified number of given elements. |
| * @param[in] rs Context to which the Allocation will belong |
| * @param[in] e Element used in the Allocation |
| * @param[in] x Width in Elements of the Allocation |
| * @param[in] y Height of the Allocation |
| * @param[in] usage usage for the Allocation |
| * @return new Allocation |
| */ |
| static sp<Allocation> createSized2D(sp<RS> rs, sp<const Element> e, |
| size_t x, size_t y, |
| uint32_t usage = RS_ALLOCATION_USAGE_SCRIPT); |
| |
| |
| /** |
| * Get the backing pointer for a USAGE_SHARED allocation. |
| * @param[in] stride optional parameter. when non-NULL, will contain |
| * stride in bytes of a 2D Allocation |
| * @return pointer to data |
| */ |
| void * getPointer(size_t *stride = NULL); |
| }; |
| |
| /** |
| * An Element represents one item within an Allocation. An Element is roughly |
| * equivalent to a C type in a RenderScript kernel. Elements may be basic |
| * or complex. Some basic elements are: |
| |
| * - A single float value (equivalent to a float in a kernel) |
| * - A four-element float vector (equivalent to a float4 in a kernel) |
| * - An unsigned 32-bit integer (equivalent to an unsigned int in a kernel) |
| * - A single signed 8-bit integer (equivalent to a char in a kernel) |
| |
| * Basic Elements are comprised of a Element.DataType and a |
| * Element.DataKind. The DataType encodes C type information of an Element, |
| * while the DataKind encodes how that Element should be interpreted by a |
| * Sampler. Note that Allocation objects with DataKind USER cannot be used as |
| * input for a Sampler. In general, Allocation objects that are intended for |
| * use with a Sampler should use bitmap-derived Elements such as |
| * Element::RGBA_8888. |
| */ |
| |
| |
| class Element : public BaseObj { |
| public: |
| bool isComplex(); |
| |
| /** |
| * Elements could be simple, such as an int or a float, or a structure with |
| * multiple sub-elements, such as a collection of floats, float2, |
| * float4. This function returns zero for simple elements or the number of |
| * sub-elements otherwise. |
| * @return number of sub-elements |
| */ |
| size_t getSubElementCount() { |
| return mVisibleElementMapSize; |
| } |
| |
| /** |
| * For complex Elements, this returns the sub-element at a given index. |
| * @param[in] index index of sub-element |
| * @return sub-element |
| */ |
| sp<const Element> getSubElement(uint32_t index); |
| |
| /** |
| * For complex Elements, this returns the name of the sub-element at a given |
| * index. |
| * @param[in] index index of sub-element |
| * @return name of sub-element |
| */ |
| const char * getSubElementName(uint32_t index); |
| |
| /** |
| * For complex Elements, this returns the size of the sub-element at a given |
| * index. |
| * @param[in] index index of sub-element |
| * @return size of sub-element |
| */ |
| size_t getSubElementArraySize(uint32_t index); |
| |
| /** |
| * Returns the location of a sub-element within a complex Element. |
| * @param[in] index index of sub-element |
| * @return offset in bytes |
| */ |
| uint32_t getSubElementOffsetBytes(uint32_t index); |
| |
| /** |
| * Returns the data type used for the Element. |
| * @return data type |
| */ |
| RsDataType getDataType() const { |
| return mType; |
| } |
| |
| /** |
| * Returns the data kind used for the Element. |
| * @return data kind |
| */ |
| RsDataKind getDataKind() const { |
| return mKind; |
| } |
| |
| /** |
| * Returns the size in bytes of the Element. |
| * @return size in bytes |
| */ |
| size_t getSizeBytes() const { |
| return mSizeBytes; |
| } |
| |
| /** |
| * Returns the number of vector components for this Element. |
| * @return number of vector components |
| */ |
| uint32_t getVectorSize() const { |
| return mVectorSize; |
| } |
| |
| /** |
| * Utility function for returning an Element containing a single bool. |
| * @param[in] rs RenderScript context |
| * @return Element |
| */ |
| static sp<const Element> BOOLEAN(sp<RS> rs); |
| /** |
| * Utility function for returning an Element containing a single unsigned char. |
| * @param[in] rs RenderScript context |
| * @return Element |
| */ |
| static sp<const Element> U8(sp<RS> rs); |
| /** |
| * Utility function for returning an Element containing a single signed char. |
| * @param[in] rs RenderScript context |
| * @return Element |
| */ |
| static sp<const Element> I8(sp<RS> rs); |
| /** |
| * Utility function for returning an Element containing a single unsigned short. |
| * @param[in] rs RenderScript context |
| * @return Element |
| */ |
| static sp<const Element> U16(sp<RS> rs); |
| /** |
| * Utility function for returning an Element containing a single signed short. |
| * @param[in] rs RenderScript context |
| * @return Element |
| */ |
| static sp<const Element> I16(sp<RS> rs); |
| /** |
| * Utility function for returning an Element containing a single unsigned int. |
| * @param[in] rs RenderScript context |
| * @return Element |
| */ |
| static sp<const Element> U32(sp<RS> rs); |
| /** |
| * Utility function for returning an Element containing a single signed int. |
| * @param[in] rs RenderScript context |
| * @return Element |
| */ |
| static sp<const Element> I32(sp<RS> rs); |
| /** |
| * Utility function for returning an Element containing a single unsigned long long. |
| * @param[in] rs RenderScript context |
| * @return Element |
| */ |
| static sp<const Element> U64(sp<RS> rs); |
| /** |
| * Utility function for returning an Element containing a single signed long long. |
| * @param[in] rs RenderScript context |
| * @return Element |
| */ |
| static sp<const Element> I64(sp<RS> rs); |
| /** |
| * Utility function for returning an Element containing a single float. |
| * @param[in] rs RenderScript context |
| * @return Element |
| */ |
| static sp<const Element> F32(sp<RS> rs); |
| /** |
| * Utility function for returning an Element containing a single double. |
| * @param[in] rs RenderScript context |
| * @return Element |
| */ |
| static sp<const Element> F64(sp<RS> rs); |
| /** |
| * Utility function for returning an Element containing a single Element. |
| * @param[in] rs RenderScript context |
| * @return Element |
| */ |
| static sp<const Element> ELEMENT(sp<RS> rs); |
| /** |
| * Utility function for returning an Element containing a single Type. |
| * @param[in] rs RenderScript context |
| * @return Element |
| */ |
| static sp<const Element> TYPE(sp<RS> rs); |
| /** |
| * Utility function for returning an Element containing a single Allocation. |
| * @param[in] rs RenderScript context |
| * @return Element |
| */ |
| static sp<const Element> ALLOCATION(sp<RS> rs); |
| /** |
| * Utility function for returning an Element containing a single Sampler. |
| * @param[in] rs RenderScript context |
| * @return Element |
| */ |
| static sp<const Element> SAMPLER(sp<RS> rs); |
| /** |
| * Utility function for returning an Element containing a single Script. |
| * @param[in] rs RenderScript context |
| * @return Element |
| */ |
| static sp<const Element> SCRIPT(sp<RS> rs); |
| /** |
| * Utility function for returning an Element containing an ALPHA_8 pixel. |
| * @param[in] rs RenderScript context |
| * @return Element |
| */ |
| static sp<const Element> A_8(sp<RS> rs); |
| /** |
| * Utility function for returning an Element containing an RGB_565 pixel. |
| * @param[in] rs RenderScript context |
| * @return Element |
| */ |
| static sp<const Element> RGB_565(sp<RS> rs); |
| /** |
| * Utility function for returning an Element containing an RGB_888 pixel. |
| * @param[in] rs RenderScript context |
| * @return Element |
| */ |
| static sp<const Element> RGB_888(sp<RS> rs); |
| /** |
| * Utility function for returning an Element containing an RGBA_5551 pixel. |
| * @param[in] rs RenderScript context |
| * @return Element |
| */ |
| static sp<const Element> RGBA_5551(sp<RS> rs); |
| /** |
| * Utility function for returning an Element containing an RGBA_4444 pixel. |
| * @param[in] rs RenderScript context |
| * @return Element |
| */ |
| static sp<const Element> RGBA_4444(sp<RS> rs); |
| /** |
| * Utility function for returning an Element containing an RGBA_8888 pixel. |
| * @param[in] rs RenderScript context |
| * @return Element |
| */ |
| static sp<const Element> RGBA_8888(sp<RS> rs); |
| |
| /** |
| * Utility function for returning an Element containing a float2. |
| * @param[in] rs RenderScript context |
| * @return Element |
| */ |
| static sp<const Element> F32_2(sp<RS> rs); |
| /** |
| * Utility function for returning an Element containing a float3. |
| * @param[in] rs RenderScript context |
| * @return Element |
| */ |
| static sp<const Element> F32_3(sp<RS> rs); |
| /** |
| * Utility function for returning an Element containing a float4. |
| * @param[in] rs RenderScript context |
| * @return Element |
| */ |
| static sp<const Element> F32_4(sp<RS> rs); |
| /** |
| * Utility function for returning an Element containing a double2. |
| * @param[in] rs RenderScript context |
| * @return Element |
| */ |
| static sp<const Element> F64_2(sp<RS> rs); |
| /** |
| * Utility function for returning an Element containing a double3. |
| * @param[in] rs RenderScript context |
| * @return Element |
| */ |
| static sp<const Element> F64_3(sp<RS> rs); |
| /** |
| * Utility function for returning an Element containing a double4. |
| * @param[in] rs RenderScript context |
| * @return Element |
| */ |
| static sp<const Element> F64_4(sp<RS> rs); |
| /** |
| * Utility function for returning an Element containing a uchar2. |
| * @param[in] rs RenderScript context |
| * @return Element |
| */ |
| static sp<const Element> U8_2(sp<RS> rs); |
| /** |
| * Utility function for returning an Element containing a uchar3. |
| * @param[in] rs RenderScript context |
| * @return Element |
| */ |
| static sp<const Element> U8_3(sp<RS> rs); |
| /** |
| * Utility function for returning an Element containing a uchar4. |
| * @param[in] rs RenderScript context |
| * @return Element |
| */ |
| static sp<const Element> U8_4(sp<RS> rs); |
| /** |
| * Utility function for returning an Element containing a char2. |
| * @param[in] rs RenderScript context |
| * @return Element |
| */ |
| static sp<const Element> I8_2(sp<RS> rs); |
| /** |
| * Utility function for returning an Element containing a char3. |
| * @param[in] rs RenderScript context |
| * @return Element |
| */ |
| static sp<const Element> I8_3(sp<RS> rs); |
| /** |
| * Utility function for returning an Element containing a char4. |
| * @param[in] rs RenderScript context |
| * @return Element |
| */ |
| static sp<const Element> I8_4(sp<RS> rs); |
| /** |
| * Utility function for returning an Element containing a ushort2. |
| * @param[in] rs RenderScript context |
| * @return Element |
| */ |
| static sp<const Element> U16_2(sp<RS> rs); |
| /** |
| * Utility function for returning an Element containing a ushort3. |
| * @param[in] rs RenderScript context |
| * @return Element |
| */ |
| static sp<const Element> U16_3(sp<RS> rs); |
| /** |
| * Utility function for returning an Element containing a ushort4. |
| * @param[in] rs RenderScript context |
| * @return Element |
| */ |
| static sp<const Element> U16_4(sp<RS> rs); |
| /** |
| * Utility function for returning an Element containing a short2. |
| * @param[in] rs RenderScript context |
| * @return Element |
| */ |
| static sp<const Element> I16_2(sp<RS> rs); |
| /** |
| * Utility function for returning an Element containing a short3. |
| * @param[in] rs RenderScript context |
| * @return Element |
| */ |
| static sp<const Element> I16_3(sp<RS> rs); |
| /** |
| * Utility function for returning an Element containing a short4. |
| * @param[in] rs RenderScript context |
| * @return Element |
| */ |
| static sp<const Element> I16_4(sp<RS> rs); |
| /** |
| * Utility function for returning an Element containing a uint2. |
| * @param[in] rs RenderScript context |
| * @return Element |
| */ |
| static sp<const Element> U32_2(sp<RS> rs); |
| /** |
| * Utility function for returning an Element containing a uint3. |
| * @param[in] rs RenderScript context |
| * @return Element |
| */ |
| static sp<const Element> U32_3(sp<RS> rs); |
| /** |
| * Utility function for returning an Element containing a uint4. |
| * @param[in] rs RenderScript context |
| * @return Element |
| */ |
| static sp<const Element> U32_4(sp<RS> rs); |
| /** |
| * Utility function for returning an Element containing an int2. |
| * @param[in] rs RenderScript context |
| * @return Element |
| */ |
| static sp<const Element> I32_2(sp<RS> rs); |
| /** |
| * Utility function for returning an Element containing an int3. |
| * @param[in] rs RenderScript context |
| * @return Element |
| */ |
| static sp<const Element> I32_3(sp<RS> rs); |
| /** |
| * Utility function for returning an Element containing an int4. |
| * @param[in] rs RenderScript context |
| * @return Element |
| */ |
| static sp<const Element> I32_4(sp<RS> rs); |
| /** |
| * Utility function for returning an Element containing a ulong2. |
| * @param[in] rs RenderScript context |
| * @return Element |
| */ |
| static sp<const Element> U64_2(sp<RS> rs); |
| /** |
| * Utility function for returning an Element containing a ulong3. |
| * @param[in] rs RenderScript context |
| * @return Element |
| */ |
| static sp<const Element> U64_3(sp<RS> rs); |
| /** |
| * Utility function for returning an Element containing a ulong4. |
| * @param[in] rs RenderScript context |
| * @return Element |
| */ |
| static sp<const Element> U64_4(sp<RS> rs); |
| /** |
| * Utility function for returning an Element containing a long2. |
| * @param[in] rs RenderScript context |
| * @return Element |
| */ |
| static sp<const Element> I64_2(sp<RS> rs); |
| /** |
| * Utility function for returning an Element containing a long3. |
| * @param[in] rs RenderScript context |
| * @return Element |
| */ |
| static sp<const Element> I64_3(sp<RS> rs); |
| /** |
| * Utility function for returning an Element containing a long4. |
| * @param[in] rs RenderScript context |
| * @return Element |
| */ |
| static sp<const Element> I64_4(sp<RS> rs); |
| /** |
| * Utility function for returning an Element containing a YUV pixel. |
| * @param[in] rs RenderScript context |
| * @return Element |
| */ |
| static sp<const Element> YUV(sp<RS> rs); |
| /** |
| * Utility function for returning an Element containing an rs_matrix_4x4. |
| * @param[in] rs RenderScript context |
| * @return Element |
| */ |
| static sp<const Element> MATRIX_4X4(sp<RS> rs); |
| /** |
| * Utility function for returning an Element containing an rs_matrix_3x3. |
| * @param[in] rs RenderScript context |
| * @return Element |
| */ |
| static sp<const Element> MATRIX_3X3(sp<RS> rs); |
| /** |
| * Utility function for returning an Element containing an rs_matrix_2x2. |
| * @param[in] rs RenderScript context |
| * @return Element |
| */ |
| static sp<const Element> MATRIX_2X2(sp<RS> rs); |
| |
| void updateFromNative(); |
| |
| /** |
| * Create an Element with a given DataType. |
| * @param[in] rs RenderScript context |
| * @param[in] dt data type |
| * @return Element |
| */ |
| static sp<const Element> createUser(sp<RS> rs, RsDataType dt); |
| /** |
| * Create a vector Element with the given DataType |
| * @param[in] rs RenderScript |
| * @param[in] dt DataType |
| * @param[in] size vector size |
| * @return Element |
| */ |
| static sp<const Element> createVector(sp<RS> rs, RsDataType dt, uint32_t size); |
| /** |
| * Create an Element with a given DataType and DataKind. |
| * @param[in] rs RenderScript context |
| * @param[in] dt DataType |
| * @param[in] dk DataKind |
| * @return Element |
| */ |
| static sp<const Element> createPixel(sp<RS> rs, RsDataType dt, RsDataKind dk); |
| |
| /** |
| * Returns true if the Element can interoperate with this Element. |
| * @param[in] e Element to compare |
| * @return true if Elements can interoperate |
| */ |
| bool isCompatible(sp<const Element>e) const; |
| |
| /** |
| * Builder class for producing complex elements with matching field and name |
| * pairs. The builder starts empty. The order in which elements are added is |
| * retained for the layout in memory. |
| */ |
| class Builder { |
| private: |
| RS* mRS; |
| size_t mElementsCount; |
| size_t mElementsVecSize; |
| sp<const Element> * mElements; |
| char ** mElementNames; |
| size_t * mElementNameLengths; |
| uint32_t * mArraySizes; |
| bool mSkipPadding; |
| |
| public: |
| Builder(sp<RS> rs); |
| ~Builder(); |
| void add(sp<const Element> e, const char * name, uint32_t arraySize = 1); |
| sp<const Element> create(); |
| }; |
| |
| protected: |
| Element(void *id, sp<RS> rs, |
| sp<const Element> * elements, |
| size_t elementCount, |
| const char ** elementNames, |
| size_t * elementNameLengths, |
| uint32_t * arraySizes); |
| Element(void *id, sp<RS> rs, RsDataType dt, RsDataKind dk, bool norm, uint32_t size); |
| Element(sp<RS> rs); |
| virtual ~Element(); |
| |
| private: |
| void updateVisibleSubElements(); |
| |
| size_t mElementsCount; |
| size_t mVisibleElementMapSize; |
| |
| sp<const Element> * mElements; |
| char ** mElementNames; |
| size_t * mElementNameLengths; |
| uint32_t * mArraySizes; |
| uint32_t * mVisibleElementMap; |
| uint32_t * mOffsetInBytes; |
| |
| RsDataType mType; |
| RsDataKind mKind; |
| bool mNormalized; |
| size_t mSizeBytes; |
| size_t mVectorSize; |
| }; |
| |
| class FieldPacker { |
| protected: |
| unsigned char* mData; |
| size_t mPos; |
| size_t mLen; |
| |
| public: |
| FieldPacker(size_t len) |
| : mPos(0), mLen(len) { |
| mData = new unsigned char[len]; |
| } |
| |
| virtual ~FieldPacker() { |
| delete [] mData; |
| } |
| |
| void align(size_t v) { |
| if ((v & (v - 1)) != 0) { |
| // ALOGE("Non-power-of-two alignment: %zu", v); |
| return; |
| } |
| |
| while ((mPos & (v - 1)) != 0) { |
| mData[mPos++] = 0; |
| } |
| } |
| |
| void reset() { |
| mPos = 0; |
| } |
| |
| void reset(size_t i) { |
| if (i >= mLen) { |
| // ALOGE("Out of bounds: i (%zu) >= len (%zu)", i, mLen); |
| return; |
| } |
| mPos = i; |
| } |
| |
| void skip(size_t i) { |
| size_t res = mPos + i; |
| if (res > mLen) { |
| // ALOGE("Exceeded buffer length: i (%zu) > len (%zu)", i, mLen); |
| return; |
| } |
| mPos = res; |
| } |
| |
| void* getData() const { |
| return mData; |
| } |
| |
| size_t getLength() const { |
| return mLen; |
| } |
| |
| template <typename T> |
| void add(T t) { |
| align(sizeof(t)); |
| if (mPos + sizeof(t) <= mLen) { |
| memcpy(&mData[mPos], &t, sizeof(t)); |
| mPos += sizeof(t); |
| } |
| } |
| |
| /* |
| void add(rs_matrix4x4 m) { |
| for (size_t i = 0; i < 16; i++) { |
| add(m.m[i]); |
| } |
| } |
| |
| void add(rs_matrix3x3 m) { |
| for (size_t i = 0; i < 9; i++) { |
| add(m.m[i]); |
| } |
| } |
| |
| void add(rs_matrix2x2 m) { |
| for (size_t i = 0; i < 4; i++) { |
| add(m.m[i]); |
| } |
| } |
| */ |
| |
| void add(sp<BaseObj> obj) { |
| if (obj != NULL) { |
| add((uint32_t) (uintptr_t) obj->getID()); |
| } else { |
| add((uint32_t) 0); |
| } |
| } |
| }; |
| |
| /** |
| * A Type describes the Element and dimensions used for an Allocation or a |
| * parallel operation. |
| * |
| * A Type always includes an Element and an X dimension. A Type may be |
| * multidimensional, up to three dimensions. A nonzero value in the Y or Z |
| * dimensions indicates that the dimension is present. Note that a Type with |
| * only a given X dimension and a Type with the same X dimension but Y = 1 are |
| * not equivalent. |
| * |
| * A Type also supports inclusion of level of detail (LOD) or cube map |
| * faces. LOD and cube map faces are booleans to indicate present or not |
| * present. |
| * |
| * A Type also supports YUV format information to support an Allocation in a YUV |
| * format. The YUV formats supported are YV12 and NV21. |
| */ |
| class Type : public BaseObj { |
| protected: |
| friend class Allocation; |
| |
| uint32_t mDimX; |
| uint32_t mDimY; |
| uint32_t mDimZ; |
| RSYuvFormat mYuvFormat; |
| bool mDimMipmaps; |
| bool mDimFaces; |
| size_t mElementCount; |
| sp<const Element> mElement; |
| |
| Type(void *id, sp<RS> rs); |
| |
| void calcElementCount(); |
| virtual void updateFromNative(); |
| |
| public: |
| |
| /** |
| * Returns the YUV format. |
| * @return YUV format of the Allocation |
| */ |
| RSYuvFormat getYuvFormat() const { |
| return mYuvFormat; |
| } |
| |
| /** |
| * Returns the Element of the Allocation. |
| * @return YUV format of the Allocation |
| */ |
| sp<const Element> getElement() const { |
| return mElement; |
| } |
| |
| /** |
| * Returns the X dimension of the Allocation. |
| * @return X dimension of the allocation |
| */ |
| uint32_t getX() const { |
| return mDimX; |
| } |
| |
| /** |
| * Returns the Y dimension of the Allocation. |
| * @return Y dimension of the allocation |
| */ |
| uint32_t getY() const { |
| return mDimY; |
| } |
| |
| /** |
| * Returns the Z dimension of the Allocation. |
| * @return Z dimension of the allocation |
| */ |
| uint32_t getZ() const { |
| return mDimZ; |
| } |
| |
| /** |
| * Returns true if the Allocation has mipmaps. |
| * @return true if the Allocation has mipmaps |
| */ |
| bool hasMipmaps() const { |
| return mDimMipmaps; |
| } |
| |
| /** |
| * Returns true if the Allocation is a cube map |
| * @return true if the Allocation is a cube map |
| */ |
| bool hasFaces() const { |
| return mDimFaces; |
| } |
| |
| /** |
| * Returns number of accessible Elements in the Allocation |
| * @return number of accessible Elements in the Allocation |
| */ |
| size_t getCount() const { |
| return mElementCount; |
| } |
| |
| /** |
| * Returns size in bytes of all Elements in the Allocation |
| * @return size in bytes of all Elements in the Allocation |
| */ |
| size_t getSizeBytes() const { |
| return mElementCount * mElement->getSizeBytes(); |
| } |
| |
| /** |
| * Creates a new Type with the given Element and dimensions. |
| * @param[in] rs RenderScript context |
| * @param[in] e Element |
| * @param[in] dimX X dimension |
| * @param[in] dimY Y dimension |
| * @param[in] dimZ Z dimension |
| * @return new Type |
| */ |
| static sp<const Type> create(sp<RS> rs, sp<const Element> e, uint32_t dimX, uint32_t dimY, uint32_t dimZ); |
| |
| class Builder { |
| protected: |
| RS* mRS; |
| uint32_t mDimX; |
| uint32_t mDimY; |
| uint32_t mDimZ; |
| RSYuvFormat mYuvFormat; |
| bool mDimMipmaps; |
| bool mDimFaces; |
| sp<const Element> mElement; |
| |
| public: |
| Builder(sp<RS> rs, sp<const Element> e); |
| |
| void setX(uint32_t value); |
| void setY(uint32_t value); |
| void setZ(uint32_t value); |
| void setYuvFormat(RSYuvFormat format); |
| void setMipmaps(bool value); |
| void setFaces(bool value); |
| sp<const Type> create(); |
| }; |
| |
| }; |
| |
| /** |
| * The parent class for all executable Scripts. This should not be used by applications. |
| */ |
| class Script : public BaseObj { |
| private: |
| |
| protected: |
| Script(void *id, sp<RS> rs); |
| void forEach(uint32_t slot, sp<const Allocation> in, sp<const Allocation> out, |
| const void *v, size_t) const; |
| void bindAllocation(sp<Allocation> va, uint32_t slot) const; |
| void setVar(uint32_t index, const void *, size_t len) const; |
| void setVar(uint32_t index, sp<const BaseObj> o) const; |
| void invoke(uint32_t slot, const void *v, size_t len) const; |
| |
| |
| void invoke(uint32_t slot) const { |
| invoke(slot, NULL, 0); |
| } |
| void setVar(uint32_t index, float v) const { |
| setVar(index, &v, sizeof(v)); |
| } |
| void setVar(uint32_t index, double v) const { |
| setVar(index, &v, sizeof(v)); |
| } |
| void setVar(uint32_t index, int32_t v) const { |
| setVar(index, &v, sizeof(v)); |
| } |
| void setVar(uint32_t index, uint32_t v) const { |
| setVar(index, &v, sizeof(v)); |
| } |
| void setVar(uint32_t index, int64_t v) const { |
| setVar(index, &v, sizeof(v)); |
| } |
| void setVar(uint32_t index, bool v) const { |
| setVar(index, &v, sizeof(v)); |
| } |
| |
| public: |
| class FieldBase { |
| protected: |
| sp<const Element> mElement; |
| sp<Allocation> mAllocation; |
| |
| void init(sp<RS> rs, uint32_t dimx, uint32_t usages = 0); |
| |
| public: |
| sp<const Element> getElement() { |
| return mElement; |
| } |
| |
| sp<const Type> getType() { |
| return mAllocation->getType(); |
| } |
| |
| sp<const Allocation> getAllocation() { |
| return mAllocation; |
| } |
| |
| //void updateAllocation(); |
| }; |
| }; |
| |
| /** |
| * The parent class for all user-defined scripts. This is intended to be used by auto-generated code only. |
| */ |
| class ScriptC : public Script { |
| protected: |
| ScriptC(sp<RS> rs, |
| const void *codeTxt, size_t codeLength, |
| const char *cachedName, size_t cachedNameLength, |
| const char *cacheDir, size_t cacheDirLength); |
| |
| }; |
| |
| /** |
| * The parent class for all script intrinsics. Intrinsics provide highly optimized implementations of |
| * basic functions. This is not intended to be used directly. |
| */ |
| class ScriptIntrinsic : public Script { |
| protected: |
| sp<const Element> mElement; |
| ScriptIntrinsic(sp<RS> rs, int id, sp<const Element> e); |
| virtual ~ScriptIntrinsic(); |
| }; |
| |
| /** |
| * Intrinsic for converting RGB to RGBA by using a 3D lookup table. The incoming |
| * r,g,b values are use as normalized x,y,z coordinates into a 3D |
| * allocation. The 8 nearest values are sampled and linearly interpolated. The |
| * result is placed in the output. |
| */ |
| class ScriptIntrinsic3DLUT : public ScriptIntrinsic { |
| private: |
| ScriptIntrinsic3DLUT(sp<RS> rs, sp<const Element> e); |
| public: |
| /** |
| * Supported Element types are U8_4. Default lookup table is identity. |
| * @param[in] rs RenderScript context |
| * @param[in] e Element |
| * @return new ScriptIntrinsic |
| */ |
| static sp<ScriptIntrinsic3DLUT> create(sp<RS> rs, sp<const Element> e); |
| |
| /** |
| * Launch the intrinsic. |
| * @param[in] ain input Allocation |
| * @param[in] aout output Allocation |
| */ |
| void forEach(sp<Allocation> ain, sp<Allocation> aout); |
| |
| /** |
| * Sets the lookup table. The lookup table must use the same Element as the |
| * intrinsic. |
| * @param[in] lut new lookup table |
| */ |
| void setLUT(sp<Allocation> lut); |
| }; |
| |
| /** |
| * Intrinsic kernel for blending two Allocations. |
| */ |
| class ScriptIntrinsicBlend : public ScriptIntrinsic { |
| private: |
| ScriptIntrinsicBlend(sp<RS> rs, sp<const Element> e); |
| public: |
| /** |
| * Supported Element types are U8_4. |
| * @param[in] rs RenderScript context |
| * @param[in] e Element |
| * @return new ScriptIntrinsicBlend |
| */ |
| static sp<ScriptIntrinsicBlend> create(sp<RS> rs, sp<const Element> e); |
| /** |
| * sets dst = {0, 0, 0, 0} |
| * @param[in] in input Allocation |
| * @param[in] out output Allocation |
| */ |
| void forEachClear(sp<Allocation> in, sp<Allocation> out); |
| /** |
| * Sets dst = src |
| * @param[in] in input Allocation |
| * @param[in] out output Allocation |
| */ |
| void forEachSrc(sp<Allocation> in, sp<Allocation> out); |
| /** |
| * Sets dst = dst (NOP) |
| * @param[in] in input Allocation |
| * @param[in] out output Allocation |
| */ |
| void forEachDst(sp<Allocation> in, sp<Allocation> out); |
| /** |
| * Sets dst = src + dst * (1.0 - src.a) |
| * @param[in] in input Allocation |
| * @param[in] out output Allocation |
| */ |
| void forEachSrcOver(sp<Allocation> in, sp<Allocation> out); |
| /** |
| * Sets dst = dst + src * (1.0 - dst.a) |
| * @param[in] in input Allocation |
| * @param[in] out output Allocation |
| */ |
| void forEachDstOver(sp<Allocation> in, sp<Allocation> out); |
| /** |
| * Sets dst = src * dst.a |
| * @param[in] in input Allocation |
| * @param[in] out output Allocation |
| */ |
| void forEachSrcIn(sp<Allocation> in, sp<Allocation> out); |
| /** |
| * Sets dst = dst * src.a |
| * @param[in] in input Allocation |
| * @param[in] out output Allocation |
| */ |
| void forEachDstIn(sp<Allocation> in, sp<Allocation> out); |
| /** |
| * Sets dst = src * (1.0 - dst.a) |
| * @param[in] in input Allocation |
| * @param[in] out output Allocation |
| */ |
| void forEachSrcOut(sp<Allocation> in, sp<Allocation> out); |
| /** |
| * Sets dst = dst * (1.0 - src.a) |
| * @param[in] in input Allocation |
| * @param[in] out output Allocation |
| */ |
| void forEachDstOut(sp<Allocation> in, sp<Allocation> out); |
| /** |
| * Sets dst.rgb = src.rgb * dst.a + (1.0 - src.a) * dst.rgb |
| * @param[in] in input Allocation |
| * @param[in] out output Allocation |
| */ |
| void forEachSrcAtop(sp<Allocation> in, sp<Allocation> out); |
| /** |
| * Sets dst.rgb = dst.rgb * src.a + (1.0 - dst.a) * src.rgb |
| * @param[in] in input Allocation |
| * @param[in] out output Allocation |
| */ |
| void forEachDstAtop(sp<Allocation> in, sp<Allocation> out); |
| /** |
| * Sets dst = {src.r ^ dst.r, src.g ^ dst.g, src.b ^ dst.b, src.a ^ dst.a} |
| * @param[in] in input Allocation |
| * @param[in] out output Allocation |
| */ |
| void forEachXor(sp<Allocation> in, sp<Allocation> out); |
| /** |
| * Sets dst = src * dst |
| * @param[in] in input Allocation |
| * @param[in] out output Allocation |
| */ |
| void forEachMultiply(sp<Allocation> in, sp<Allocation> out); |
| /** |
| * Sets dst = min(src + dst, 1.0) |
| * @param[in] in input Allocation |
| * @param[in] out output Allocation |
| */ |
| void forEachAdd(sp<Allocation> in, sp<Allocation> out); |
| /** |
| * Sets dst = max(dst - src, 0.0) |
| * @param[in] in input Allocation |
| * @param[in] out output Allocation |
| */ |
| void forEachSubtract(sp<Allocation> in, sp<Allocation> out); |
| }; |
| |
| /** |
| * Intrinsic Gausian blur filter. Applies a Gaussian blur of the specified |
| * radius to all elements of an Allocation. |
| */ |
| class ScriptIntrinsicBlur : public ScriptIntrinsic { |
| private: |
| ScriptIntrinsicBlur(sp<RS> rs, sp<const Element> e); |
| public: |
| /** |
| * Supported Element types are U8 and U8_4. |
| * @param[in] rs RenderScript context |
| * @param[in] e Element |
| * @return new ScriptIntrinsicBlur |
| */ |
| static sp<ScriptIntrinsicBlur> create(sp<RS> rs, sp<const Element> e); |
| /** |
| * Sets the input of the blur. |
| * @param[in] in input Allocation |
| */ |
| void setInput(sp<Allocation> in); |
| /** |
| * Runs the intrinsic. |
| * @param[in] output Allocation |
| */ |
| void forEach(sp<Allocation> out); |
| /** |
| * Sets the radius of the blur. The supported range is 0 < radius <= 25. |
| * @param[in] radius radius of the blur |
| */ |
| void setRadius(float radius); |
| }; |
| |
| /** |
| * Intrinsic for applying a color matrix to allocations. This has the |
| * same effect as loading each element and converting it to a |
| * F32_N, multiplying the result by the 4x4 color matrix |
| * as performed by rsMatrixMultiply() and writing it to the output |
| * after conversion back to U8_N or F32_N. |
| */ |
| class ScriptIntrinsicColorMatrix : public ScriptIntrinsic { |
| private: |
| ScriptIntrinsicColorMatrix(sp<RS> rs, sp<const Element> e); |
| public: |
| /** |
| * Creates a new intrinsic. |
| * @param[in] rs RenderScript context |
| * @return new ScriptIntrinsicColorMatrix |
| */ |
| static sp<ScriptIntrinsicColorMatrix> create(sp<RS> rs); |
| /** |
| * Applies the color matrix. Supported types are U8 and F32 with |
| * vector lengths between 1 and 4. |
| * @param[in] in input Allocation |
| * @param[out] out output Allocation |
| */ |
| void forEach(sp<Allocation> in, sp<Allocation> out); |
| /** |
| * Set the value to be added after the color matrix has been |
| * applied. The default value is {0, 0, 0, 0}. |
| * @param[in] add float[4] of values |
| */ |
| void setAdd(float* add); |
| |
| /** |
| * Set the color matrix which will be applied to each cell of the |
| * image. The alpha channel will be copied. |
| * |
| * @param[in] m float[9] of values |
| */ |
| void setColorMatrix3(float* m); |
| /** |
| * Set the color matrix which will be applied to each cell of the |
| * image. |
| * |
| * @param[in] m float[16] of values |
| */ |
| void setColorMatrix4(float* m); |
| /** |
| * Set a color matrix to convert from RGB to luminance. The alpha |
| * channel will be a copy. |
| */ |
| void setGreyscale(); |
| /** |
| * Set the matrix to convert from RGB to YUV with a direct copy of |
| * the 4th channel. |
| */ |
| void setRGBtoYUV(); |
| /** |
| * Set the matrix to convert from YUV to RGB with a direct copy of |
| * the 4th channel. |
| */ |
| void setYUVtoRGB(); |
| }; |
| |
| /** |
| * Intrinsic for applying a 3x3 convolve to an allocation. |
| */ |
| class ScriptIntrinsicConvolve3x3 : public ScriptIntrinsic { |
| private: |
| ScriptIntrinsicConvolve3x3(sp<RS> rs, sp<const Element> e); |
| public: |
| /** |
| * Supported types U8 and F32 with vector lengths between 1 and |
| * 4. The default convolution kernel is the identity. |
| * @param[in] rs RenderScript context |
| * @param[in] e Element |
| * @return new ScriptIntrinsicConvolve3x3 |
| */ |
| static sp<ScriptIntrinsicConvolve3x3> create(sp<RS> rs, sp<const Element> e); |
| /** |
| * Sets input for intrinsic. |
| * @param[in] in input Allocation |
| */ |
| void setInput(sp<Allocation> in); |
| /** |
| * Launches the intrinsic. |
| * @param[in] out output Allocation |
| */ |
| void forEach(sp<Allocation> out); |
| /** |
| * Sets convolution kernel. |
| * @param[in] v float[9] of values |
| */ |
| void setCoefficients(float* v); |
| }; |
| |
| /** |
| * Intrinsic for applying a 5x5 convolve to an allocation. |
| */ |
| class ScriptIntrinsicConvolve5x5 : public ScriptIntrinsic { |
| private: |
| ScriptIntrinsicConvolve5x5(sp<RS> rs, sp<const Element> e); |
| public: |
| /** |
| * Supported types U8 and F32 with vector lengths between 1 and |
| * 4. The default convolution kernel is the identity. |
| * @param[in] rs RenderScript context |
| * @param[in] e Element |
| * @return new ScriptIntrinsicConvolve5x5 |
| */ |
| static sp<ScriptIntrinsicConvolve5x5> create(sp<RS> rs, sp<const Element> e); |
| /** |
| * Sets input for intrinsic. |
| * @param[in] in input Allocation |
| */ |
| void setInput(sp<Allocation> in); |
| /** |
| * Launches the intrinsic. |
| * @param[in] out output Allocation |
| */ |
| void forEach(sp<Allocation> out); |
| /** |
| * Sets convolution kernel. |
| * @param[in] v float[25] of values |
| */ |
| void setCoefficients(float* v); |
| }; |
| |
| /** |
| * Intrinsic for computing a histogram. |
| */ |
| class ScriptIntrinsicHistogram : public ScriptIntrinsic { |
| private: |
| ScriptIntrinsicHistogram(sp<RS> rs, sp<const Element> e); |
| sp<Allocation> mOut; |
| public: |
| /** |
| * Create an intrinsic for calculating the histogram of an uchar |
| * or uchar4 image. |
| * |
| * Supported elements types are U8_4, U8_3, U8_2, and U8. |
| * |
| * @param[in] rs The RenderScript context |
| * @param[in] e Element type for inputs |
| * |
| * @return ScriptIntrinsicHistogram |
| */ |
| static sp<ScriptIntrinsicHistogram> create(sp<RS> rs, sp<const Element> e); |
| /** |
| * Set the output of the histogram. 32 bit integer types are |
| * supported. |
| * |
| * @param[in] aout The output allocation |
| */ |
| void setOutput(sp<Allocation> aout); |
| /** |
| * Set the coefficients used for the dot product calculation. The |
| * default is {0.299f, 0.587f, 0.114f, 0.f}. |
| * |
| * Coefficients must be >= 0 and sum to 1.0 or less. |
| * |
| * @param[in] r Red coefficient |
| * @param[in] g Green coefficient |
| * @param[in] b Blue coefficient |
| * @param[in] a Alpha coefficient |
| */ |
| void setDotCoefficients(float r, float g, float b, float a); |
| /** |
| * Process an input buffer and place the histogram into the output |
| * allocation. The output allocation may be a narrower vector size |
| * than the input. In this case the vector size of the output is |
| * used to determine how many of the input channels are used in |
| * the computation. This is useful if you have an RGBA input |
| * buffer but only want the histogram for RGB. |
| * |
| * 1D and 2D input allocations are supported. |
| * |
| * @param[in] ain The input image |
| */ |
| void forEach(sp<Allocation> ain); |
| /** |
| * Process an input buffer and place the histogram into the output |
| * allocation. The dot product of the input channel and the |
| * coefficients from 'setDotCoefficients' are used to calculate |
| * the output values. |
| * |
| * 1D and 2D input allocations are supported. |
| * |
| * @param ain The input image |
| */ |
| void forEach_dot(sp<Allocation> ain); |
| }; |
| |
| /** |
| * Intrinsic for applying a per-channel lookup table. Each channel of |
| * the input has an independant lookup table. The tables are 256 |
| * entries in size and can cover the full value range of U8_4. |
| **/ |
| class ScriptIntrinsicLUT : public ScriptIntrinsic { |
| private: |
| sp<Allocation> LUT; |
| bool mDirty; |
| unsigned char mCache[1024]; |
| void setTable(unsigned int offset, unsigned char base, unsigned int length, unsigned char* lutValues); |
| ScriptIntrinsicLUT(sp<RS> rs, sp<const Element> e); |
| |
| public: |
| /** |
| * Supported elements types are U8_4. |
| * |
| * The defaults tables are identity. |
| * |
| * @param[in] rs The RenderScript context |
| * @param[in] e Element type for intputs and outputs |
| * |
| * @return ScriptIntrinsicLUT |
| */ |
| static sp<ScriptIntrinsicLUT> create(sp<RS> rs, sp<const Element> e); |
| /** |
| * Invoke the kernel and apply the lookup to each cell of ain and |
| * copy to aout. |
| * |
| * @param[in] ain Input allocation |
| * @param[in] aout Output allocation |
| */ |
| void forEach(sp<Allocation> ain, sp<Allocation> aout); |
| /** |
| * Sets entries in LUT for the red channel. |
| * @param[in] base base of region to update |
| * @param[in] length length of region to update |
| * @param[in] lutValues LUT values to use |
| */ |
| void setRed(unsigned char base, unsigned int length, unsigned char* lutValues); |
| /** |
| * Sets entries in LUT for the green channel. |
| * @param[in] base base of region to update |
| * @param[in] length length of region to update |
| * @param[in] lutValues LUT values to use |
| */ |
| void setGreen(unsigned char base, unsigned int length, unsigned char* lutValues); |
| /** |
| * Sets entries in LUT for the blue channel. |
| * @param[in] base base of region to update |
| * @param[in] length length of region to update |
| * @param[in] lutValues LUT values to use |
| */ |
| void setBlue(unsigned char base, unsigned int length, unsigned char* lutValues); |
| /** |
| * Sets entries in LUT for the alpha channel. |
| * @param[in] base base of region to update |
| * @param[in] length length of region to update |
| * @param[in] lutValues LUT values to use |
| */ |
| void setAlpha(unsigned char base, unsigned int length, unsigned char* lutValues); |
| virtual ~ScriptIntrinsicLUT(); |
| }; |
| |
| /** |
| * Intrinsic for performing a resize of a 2D allocation. |
| */ |
| class ScriptIntrinsicResize : public ScriptIntrinsic { |
| private: |
| sp<Allocation> mInput; |
| ScriptIntrinsicResize(sp<RS> rs, sp<const Element> e); |
| public: |
| /** |
| * Supported Element types are U8_4. Default lookup table is identity. |
| * @param[in] rs RenderScript context |
| * @param[in] e Element |
| * @return new ScriptIntrinsic |
| */ |
| static sp<ScriptIntrinsicResize> create(sp<RS> rs); |
| |
| /** |
| * Resize copy the input allocation to the output specified. The |
| * Allocation is rescaled if necessary using bi-cubic |
| * interpolation. |
| * @param[in] ain input Allocation |
| * @param[in] aout output Allocation |
| */ |
| void forEach_bicubic(sp<Allocation> aout); |
| |
| /** |
| * Set the input of the resize. |
| * @param[in] lut new lookup table |
| */ |
| void setInput(sp<Allocation> ain); |
| }; |
| |
| /** |
| * Intrinsic for converting an Android YUV buffer to RGB. |
| * |
| * The input allocation should be supplied in a supported YUV format |
| * as a YUV element Allocation. The output is RGBA; the alpha channel |
| * will be set to 255. |
| */ |
| class ScriptIntrinsicYuvToRGB : public ScriptIntrinsic { |
| private: |
| ScriptIntrinsicYuvToRGB(sp<RS> rs, sp<const Element> e); |
| public: |
| /** |
| * Create an intrinsic for converting YUV to RGB. |
| * |
| * Supported elements types are U8_4. |
| * |
| * @param[in] rs The RenderScript context |
| * @param[in] e Element type for output |
| * |
| * @return ScriptIntrinsicYuvToRGB |
| */ |
| static sp<ScriptIntrinsicYuvToRGB> create(sp<RS> rs, sp<const Element> e); |
| /** |
| * Set the input YUV allocation. |
| * |
| * @param[in] ain The input allocation. |
| */ |
| void setInput(sp<Allocation> in); |
| |
| /** |
| * Convert the image to RGB. |
| * |
| * @param[in] aout Output allocation. Must match creation element |
| * type. |
| */ |
| void forEach(sp<Allocation> out); |
| |
| }; |
| |
| /** |
| * Sampler object that defines how Allocations can be read as textures |
| * within a kernel. Samplers are used in conjunction with the rsSample |
| * runtime function to return values from normalized coordinates. |
| * |
| * Any Allocation used with a Sampler must have been created with |
| * RS_ALLOCATION_USAGE_GRAPHICS_TEXTURE; using a Sampler on an |
| * Allocation that was not created with |
| * RS_ALLOCATION_USAGE_GRAPHICS_TEXTURE is undefined. |
| **/ |
| class Sampler : public BaseObj { |
| private: |
| Sampler(sp<RS> rs, void* id); |
| Sampler(sp<RS> rs, void* id, RsSamplerValue min, RsSamplerValue mag, |
| RsSamplerValue wrapS, RsSamplerValue wrapT, float anisotropy); |
| RsSamplerValue mMin; |
| RsSamplerValue mMag; |
| RsSamplerValue mWrapS; |
| RsSamplerValue mWrapT; |
| float mAniso; |
| |
| public: |
| /** |
| * Creates a non-standard Sampler. |
| * @param[in] rs RenderScript context |
| * @param[in] min minification |
| * @param[in] mag magnification |
| * @param[in] wrapS S wrapping mode |
| * @param[in] wrapT T wrapping mode |
| * @param[in] anisotropy anisotropy setting |
| */ |
| static sp<Sampler> create(sp<RS> rs, RsSamplerValue min, RsSamplerValue mag, RsSamplerValue wrapS, RsSamplerValue wrapT, float anisotropy); |
| |
| /** |
| * @return minification setting for the sampler |
| */ |
| RsSamplerValue getMinification(); |
| /** |
| * @return magnification setting for the sampler |
| */ |
| RsSamplerValue getMagnification(); |
| /** |
| * @return S wrapping mode for the sampler |
| */ |
| RsSamplerValue getWrapS(); |
| /** |
| * @return T wrapping mode for the sampler |
| */ |
| RsSamplerValue getWrapT(); |
| /** |
| * @return anisotropy setting for the sampler |
| */ |
| float getAnisotropy(); |
| |
| /** |
| * Retrieve a sampler with min and mag set to nearest and wrap modes set to |
| * clamp. |
| * |
| * @param rs Context to which the sampler will belong. |
| * |
| * @return Sampler |
| */ |
| static sp<const Sampler> CLAMP_NEAREST(sp<RS> rs); |
| /** |
| * Retrieve a sampler with min and mag set to linear and wrap modes set to |
| * clamp. |
| * |
| * @param rs Context to which the sampler will belong. |
| * |
| * @return Sampler |
| */ |
| static sp<const Sampler> CLAMP_LINEAR(sp<RS> rs); |
| /** |
| * Retrieve a sampler with mag set to linear, min linear mipmap linear, and |
| * wrap modes set to clamp. |
| * |
| * @param rs Context to which the sampler will belong. |
| * |
| * @return Sampler |
| */ |
| static sp<const Sampler> CLAMP_LINEAR_MIP_LINEAR(sp<RS> rs); |
| /** |
| * Retrieve a sampler with min and mag set to nearest and wrap modes set to |
| * wrap. |
| * |
| * @param rs Context to which the sampler will belong. |
| * |
| * @return Sampler |
| */ |
| static sp<const Sampler> WRAP_NEAREST(sp<RS> rs); |
| /** |
| * Retrieve a sampler with min and mag set to linear and wrap modes set to |
| * wrap. |
| * |
| * @param rs Context to which the sampler will belong. |
| * |
| * @return Sampler |
| */ |
| static sp<const Sampler> WRAP_LINEAR(sp<RS> rs); |
| /** |
| * Retrieve a sampler with mag set to linear, min linear mipmap linear, and |
| * wrap modes set to wrap. |
| * |
| * @param rs Context to which the sampler will belong. |
| * |
| * @return Sampler |
| */ |
| static sp<const Sampler> WRAP_LINEAR_MIP_LINEAR(sp<RS> rs); |
| /** |
| * Retrieve a sampler with min and mag set to nearest and wrap modes set to |
| * mirrored repeat. |
| * |
| * @param rs Context to which the sampler will belong. |
| * |
| * @return Sampler |
| */ |
| static sp<const Sampler> MIRRORED_REPEAT_NEAREST(sp<RS> rs); |
| /** |
| * Retrieve a sampler with min and mag set to linear and wrap modes set to |
| * mirrored repeat. |
| * |
| * @param rs Context to which the sampler will belong. |
| * |
| * @return Sampler |
| */ |
| static sp<const Sampler> MIRRORED_REPEAT_LINEAR(sp<RS> rs); |
| /** |
| * Retrieve a sampler with min and mag set to linear and wrap modes set to |
| * mirrored repeat. |
| * |
| * @param rs Context to which the sampler will belong. |
| * |
| * @return Sampler |
| */ |
| static sp<const Sampler> MIRRORED_REPEAT_LINEAR_MIP_LINEAR(sp<RS> rs); |
| |
| }; |
| |
| class Byte2 { |
| public: |
| int8_t x, y; |
| |
| Byte2(int8_t initX, int8_t initY) |
| : x(initX), y(initY) {} |
| Byte2() : x(0), y(0) {} |
| }; |
| |
| class Byte3 { |
| public: |
| int8_t x, y, z; |
| |
| Byte3(int8_t initX, int8_t initY, int8_t initZ) |
| : x(initX), y(initY), z(initZ) {} |
| Byte3() : x(0), y(0), z(0) {} |
| }; |
| |
| class Byte4 { |
| public: |
| int8_t x, y, z, w; |
| |
| Byte4(int8_t initX, int8_t initY, int8_t initZ, int8_t initW) |
| : x(initX), y(initY), z(initZ), w(initW) {} |
| Byte4() : x(0), y(0), z(0), w(0) {} |
| }; |
| |
| class UByte2 { |
| public: |
| uint8_t x, y; |
| |
| UByte2(uint8_t initX, uint8_t initY) |
| : x(initX), y(initY) {} |
| UByte2() : x(0), y(0) {} |
| }; |
| |
| class UByte3 { |
| public: |
| uint8_t x, y, z; |
| |
| UByte3(uint8_t initX, uint8_t initY, uint8_t initZ) |
| : x(initX), y(initY), z(initZ) {} |
| UByte3() : x(0), y(0), z(0) {} |
| }; |
| |
| class UByte4 { |
| public: |
| uint8_t x, y, z, w; |
| |
| UByte4(uint8_t initX, uint8_t initY, uint8_t initZ, uint8_t initW) |
| : x(initX), y(initY), z(initZ), w(initW) {} |
| UByte4() : x(0), y(0), z(0), w(0) {} |
| }; |
| |
| class Short2 { |
| public: |
| short x, y; |
| |
| Short2(short initX, short initY) |
| : x(initX), y(initY) {} |
| Short2() : x(0), y(0) {} |
| }; |
| |
| class Short3 { |
| public: |
| short x, y, z; |
| |
| Short3(short initX, short initY, short initZ) |
| : x(initX), y(initY), z(initZ) {} |
| Short3() : x(0), y(0), z(0) {} |
| }; |
| |
| class Short4 { |
| public: |
| short x, y, z, w; |
| |
| Short4(short initX, short initY, short initZ, short initW) |
| : x(initX), y(initY), z(initZ), w(initW) {} |
| Short4() : x(0), y(0), z(0), w(0) {} |
| }; |
| |
| class UShort2 { |
| public: |
| uint16_t x, y; |
| |
| UShort2(uint16_t initX, uint16_t initY) |
| : x(initX), y(initY) {} |
| UShort2() : x(0), y(0) {} |
| }; |
| |
| class UShort3 { |
| public: |
| uint16_t x, y, z; |
| |
| UShort3(uint16_t initX, uint16_t initY, uint16_t initZ) |
| : x(initX), y(initY), z(initZ) {} |
| UShort3() : x(0), y(0), z(0) {} |
| }; |
| |
| class UShort4 { |
| public: |
| uint16_t x, y, z, w; |
| |
| UShort4(uint16_t initX, uint16_t initY, uint16_t initZ, uint16_t initW) |
| : x(initX), y(initY), z(initZ), w(initW) {} |
| UShort4() : x(0), y(0), z(0), w(0) {} |
| }; |
| |
| class Int2 { |
| public: |
| int x, y; |
| |
| Int2(int initX, int initY) |
| : x(initX), y(initY) {} |
| Int2() : x(0), y(0) {} |
| }; |
| |
| class Int3 { |
| public: |
| int x, y, z; |
| |
| Int3(int initX, int initY, int initZ) |
| : x(initX), y(initY), z(initZ) {} |
| Int3() : x(0), y(0), z(0) {} |
| }; |
| |
| class Int4 { |
| public: |
| int x, y, z, w; |
| |
| Int4(int initX, int initY, int initZ, int initW) |
| : x(initX), y(initY), z(initZ), w(initW) {} |
| Int4() : x(0), y(0), z(0), w(0) {} |
| }; |
| |
| class UInt2 { |
| public: |
| uint32_t x, y; |
| |
| UInt2(uint32_t initX, uint32_t initY) |
| : x(initX), y(initY) {} |
| UInt2() : x(0), y(0) {} |
| }; |
| |
| class UInt3 { |
| public: |
| uint32_t x, y, z; |
| |
| UInt3(uint32_t initX, uint32_t initY, uint32_t initZ) |
| : x(initX), y(initY), z(initZ) {} |
| UInt3() : x(0), y(0), z(0) {} |
| }; |
| |
| class UInt4 { |
| public: |
| uint32_t x, y, z, w; |
| |
| UInt4(uint32_t initX, uint32_t initY, uint32_t initZ, uint32_t initW) |
| : x(initX), y(initY), z(initZ), w(initW) {} |
| UInt4() : x(0), y(0), z(0), w(0) {} |
| }; |
| |
| class Long2 { |
| public: |
| int64_t x, y; |
| |
| Long2(int64_t initX, int64_t initY) |
| : x(initX), y(initY) {} |
| Long2() : x(0), y(0) {} |
| }; |
| |
| class Long3 { |
| public: |
| int64_t x, y, z; |
| |
| Long3(int64_t initX, int64_t initY, int64_t initZ) |
| : x(initX), y(initY), z(initZ) {} |
| Long3() : x(0), y(0), z(0) {} |
| }; |
| |
| class Long4 { |
| public: |
| int64_t x, y, z, w; |
| |
| Long4(int64_t initX, int64_t initY, int64_t initZ, int64_t initW) |
| : x(initX), y(initY), z(initZ), w(initW) {} |
| Long4() : x(0), y(0), z(0), w(0) {} |
| }; |
| |
| class ULong2 { |
| public: |
| uint64_t x, y; |
| |
| ULong2(uint64_t initX, uint64_t initY) |
| : x(initX), y(initY) {} |
| ULong2() : x(0), y(0) {} |
| }; |
| |
| class ULong3 { |
| public: |
| uint64_t x, y, z; |
| |
| ULong3(uint64_t initX, uint64_t initY, uint64_t initZ) |
| : x(initX), y(initY), z(initZ) {} |
| ULong3() : x(0), y(0), z(0) {} |
| }; |
| |
| class ULong4 { |
| public: |
| uint64_t x, y, z, w; |
| |
| ULong4(uint64_t initX, uint64_t initY, uint64_t initZ, uint64_t initW) |
| : x(initX), y(initY), z(initZ), w(initW) {} |
| ULong4() : x(0), y(0), z(0), w(0) {} |
| }; |
| |
| class Float2 { |
| public: |
| float x, y; |
| |
| Float2(float initX, float initY) |
| : x(initX), y(initY) {} |
| Float2() : x(0), y(0) {} |
| }; |
| |
| class Float3 { |
| public: |
| float x, y, z; |
| |
| Float3(float initX, float initY, float initZ) |
| : x(initX), y(initY), z(initZ) {} |
| Float3() : x(0.f), y(0.f), z(0.f) {} |
| }; |
| |
| class Float4 { |
| public: |
| float x, y, z, w; |
| |
| Float4(float initX, float initY, float initZ, float initW) |
| : x(initX), y(initY), z(initZ), w(initW) {} |
| Float4() : x(0.f), y(0.f), z(0.f), w(0.f) {} |
| }; |
| |
| class Double2 { |
| public: |
| double x, y; |
| |
| Double2(double initX, double initY) |
| : x(initX), y(initY) {} |
| Double2() : x(0), y(0) {} |
| }; |
| |
| class Double3 { |
| public: |
| double x, y, z; |
| |
| Double3(double initX, double initY, double initZ) |
| : x(initX), y(initY), z(initZ) {} |
| Double3() : x(0), y(0), z(0) {} |
| }; |
| |
| class Double4 { |
| public: |
| double x, y, z, w; |
| |
| Double4(double initX, double initY, double initZ, double initW) |
| : x(initX), y(initY), z(initZ), w(initW) {} |
| Double4() : x(0), y(0), z(0), w(0) {} |
| }; |
| |
| } |
| |
| } |
| |
| #endif |
