1bcacfdcab
Test: No code changes, just ran through clang-format Change-Id: Id23aa4ec7eebc0446fe3a30260f33e7fd455bb8c
280 lines
8.4 KiB
C++
280 lines
8.4 KiB
C++
/*
|
|
* Copyright (C) 2010 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.
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include <GLES2/gl2.h>
|
|
#include <GLES2/gl2ext.h>
|
|
|
|
#include <ui/Region.h>
|
|
#include <utils/LinearAllocator.h>
|
|
#include <utils/RefBase.h>
|
|
|
|
#include <SkClipOp.h>
|
|
#include <SkRegion.h>
|
|
|
|
#include "ClipArea.h"
|
|
#include "Layer.h"
|
|
#include "Matrix.h"
|
|
#include "Outline.h"
|
|
#include "Rect.h"
|
|
#include "utils/Macros.h"
|
|
|
|
namespace android {
|
|
namespace uirenderer {
|
|
|
|
/**
|
|
* Temporary structure holding information for a single outline clip.
|
|
*
|
|
* These structures are treated as immutable once created, and only exist for a single frame, which
|
|
* is why they may only be allocated with a LinearAllocator.
|
|
*/
|
|
class RoundRectClipState {
|
|
public:
|
|
static void* operator new(size_t size) = delete;
|
|
static void* operator new(size_t size, LinearAllocator& allocator) {
|
|
return allocator.alloc<RoundRectClipState>(size);
|
|
}
|
|
|
|
bool areaRequiresRoundRectClip(const Rect& rect) const {
|
|
return rect.intersects(dangerRects[0]) || rect.intersects(dangerRects[1]) ||
|
|
rect.intersects(dangerRects[2]) || rect.intersects(dangerRects[3]);
|
|
}
|
|
|
|
bool highPriority;
|
|
Matrix4 matrix;
|
|
Rect dangerRects[4];
|
|
Rect innerRect;
|
|
float radius;
|
|
};
|
|
|
|
/**
|
|
* A snapshot holds information about the current state of the rendering
|
|
* surface. A snapshot is usually created whenever the user calls save()
|
|
* and discarded when the user calls restore(). Once a snapshot is created,
|
|
* it can hold information for deferred rendering.
|
|
*
|
|
* Each snapshot has a link to a previous snapshot, indicating the previous
|
|
* state of the renderer.
|
|
*/
|
|
class Snapshot {
|
|
public:
|
|
Snapshot();
|
|
Snapshot(Snapshot* s, int saveFlags);
|
|
|
|
/**
|
|
* Various flags set on ::flags.
|
|
*/
|
|
enum Flags {
|
|
/**
|
|
* Indicates that the clip region was modified. When this
|
|
* snapshot is restored so must the clip.
|
|
*/
|
|
kFlagClipSet = 0x1,
|
|
/**
|
|
* Indicates that this snapshot was created when saving
|
|
* a new layer.
|
|
*/
|
|
kFlagIsLayer = 0x2,
|
|
/**
|
|
* Indicates that this snapshot is a special type of layer
|
|
* backed by an FBO. This flag only makes sense when the
|
|
* flag kFlagIsLayer is also set.
|
|
*
|
|
* Viewport has been modified to fit the new Fbo, and must be
|
|
* restored when this snapshot is restored.
|
|
*/
|
|
kFlagIsFboLayer = 0x4,
|
|
};
|
|
|
|
/**
|
|
* Modifies the current clip with the new clip rectangle and
|
|
* the specified operation. The specified rectangle is transformed
|
|
* by this snapshot's trasnformation.
|
|
*/
|
|
void clip(const Rect& localClip, SkClipOp op);
|
|
|
|
/**
|
|
* Modifies the current clip with the new clip rectangle and
|
|
* the specified operation. The specified rectangle is considered
|
|
* already transformed.
|
|
*/
|
|
void clipTransformed(const Rect& r, SkClipOp op = SkClipOp::kIntersect);
|
|
|
|
/**
|
|
* Modifies the current clip with the specified path and operation.
|
|
*/
|
|
void clipPath(const SkPath& path, SkClipOp op);
|
|
|
|
/**
|
|
* Sets the current clip.
|
|
*/
|
|
void setClip(float left, float top, float right, float bottom);
|
|
|
|
/**
|
|
* Returns the current clip in local coordinates. The clip rect is
|
|
* transformed by the inverse transform matrix.
|
|
*/
|
|
ANDROID_API const Rect& getLocalClip();
|
|
|
|
/**
|
|
* Returns the current clip in render target coordinates.
|
|
*/
|
|
const Rect& getRenderTargetClip() const { return mClipArea->getClipRect(); }
|
|
|
|
/*
|
|
* Accessor functions so that the clip area can stay private
|
|
*/
|
|
bool clipIsEmpty() const { return mClipArea->isEmpty(); }
|
|
const SkRegion& getClipRegion() const { return mClipArea->getClipRegion(); }
|
|
bool clipIsSimple() const { return mClipArea->isSimple(); }
|
|
const ClipArea& getClipArea() const { return *mClipArea; }
|
|
ClipArea& mutateClipArea() { return *mClipArea; }
|
|
|
|
WARN_UNUSED_RESULT const ClipBase* serializeIntersectedClip(
|
|
LinearAllocator& allocator, const ClipBase* recordedClip,
|
|
const Matrix4& recordedClipTransform);
|
|
void applyClip(const ClipBase* clip, const Matrix4& transform);
|
|
|
|
/**
|
|
* Resets the clip to the specified rect.
|
|
*/
|
|
void resetClip(float left, float top, float right, float bottom);
|
|
|
|
void initializeViewport(int width, int height) {
|
|
mViewportData.initialize(width, height);
|
|
mClipAreaRoot.setViewportDimensions(width, height);
|
|
}
|
|
|
|
int getViewportWidth() const { return mViewportData.mWidth; }
|
|
int getViewportHeight() const { return mViewportData.mHeight; }
|
|
const Matrix4& getOrthoMatrix() const { return mViewportData.mOrthoMatrix; }
|
|
|
|
const Vector3& getRelativeLightCenter() const { return mRelativeLightCenter; }
|
|
void setRelativeLightCenter(const Vector3& lightCenter) { mRelativeLightCenter = lightCenter; }
|
|
|
|
/**
|
|
* Sets (and replaces) the current clipping outline
|
|
*
|
|
* If the current round rect clip is high priority, the incoming clip is ignored.
|
|
*/
|
|
void setClippingRoundRect(LinearAllocator& allocator, const Rect& bounds, float radius,
|
|
bool highPriority);
|
|
|
|
/**
|
|
* Sets (and replaces) the current projection mask
|
|
*/
|
|
void setProjectionPathMask(const SkPath* path);
|
|
|
|
/**
|
|
* Indicates whether the current transform has perspective components.
|
|
*/
|
|
bool hasPerspectiveTransform() const;
|
|
|
|
/**
|
|
* Dirty flags.
|
|
*/
|
|
int flags;
|
|
|
|
/**
|
|
* Previous snapshot.
|
|
*/
|
|
Snapshot* previous;
|
|
|
|
/**
|
|
* A pointer to the currently active layer.
|
|
*
|
|
* This snapshot does not own the layer, this pointer must not be freed.
|
|
*/
|
|
Layer* layer;
|
|
|
|
/**
|
|
* Target FBO used for rendering. Set to 0 when rendering directly
|
|
* into the framebuffer.
|
|
*/
|
|
GLuint fbo;
|
|
|
|
/**
|
|
* Local transformation. Holds the current translation, scale and
|
|
* rotation values.
|
|
*
|
|
* This is a reference to a matrix owned by this snapshot or another
|
|
* snapshot. This pointer must not be freed. See ::mTransformRoot.
|
|
*/
|
|
mat4* transform;
|
|
|
|
/**
|
|
* Current alpha value. This value is 1 by default, but may be set by a DisplayList which
|
|
* has translucent rendering in a non-overlapping View. This value will be used by
|
|
* the renderer to set the alpha in the current color being used for ensuing drawing
|
|
* operations. The value is inherited by child snapshots because the same value should
|
|
* be applied to descendants of the current DisplayList (for example, a TextView contains
|
|
* the base alpha value which should be applied to the child DisplayLists used for drawing
|
|
* the actual text).
|
|
*/
|
|
float alpha;
|
|
|
|
/**
|
|
* Current clipping round rect.
|
|
*
|
|
* Points to data not owned by the snapshot, and may only be replaced by subsequent RR clips,
|
|
* never modified.
|
|
*/
|
|
const RoundRectClipState* roundRectClipState;
|
|
|
|
/**
|
|
* Current projection masking path - used exclusively to mask projected, tessellated circles.
|
|
*/
|
|
const SkPath* projectionPathMask;
|
|
|
|
void dump() const;
|
|
|
|
private:
|
|
struct ViewportData {
|
|
ViewportData() : mWidth(0), mHeight(0) {}
|
|
void initialize(int width, int height) {
|
|
mWidth = width;
|
|
mHeight = height;
|
|
mOrthoMatrix.loadOrtho(0, width, height, 0, -1, 1);
|
|
}
|
|
|
|
/*
|
|
* Width and height of current viewport.
|
|
*
|
|
* The viewport is always defined to be (0, 0, width, height).
|
|
*/
|
|
int mWidth;
|
|
int mHeight;
|
|
/**
|
|
* Contains the current orthographic, projection matrix.
|
|
*/
|
|
mat4 mOrthoMatrix;
|
|
};
|
|
|
|
mat4 mTransformRoot;
|
|
|
|
ClipArea mClipAreaRoot;
|
|
ClipArea* mClipArea;
|
|
Rect mLocalClip;
|
|
|
|
ViewportData mViewportData;
|
|
Vector3 mRelativeLightCenter;
|
|
|
|
}; // class Snapshot
|
|
|
|
}; // namespace uirenderer
|
|
}; // namespace android
|