Merge "SF: Switch computeBounds to return FloatRect" (415cc5ae) · Commits · e / os / android_frameworks_native

libs/ui/include/ui/FloatRect.h

+11 −0

Original line number	Diff line number	Diff line
		@@ -27,6 +27,17 @@ public:
		float getWidth() const { return right - left; }
		float getHeight() const { return bottom - top; }

		FloatRect intersect(const FloatRect& other) const {
		return {
		// Inline to avoid tromping on other min/max defines or adding a
		// dependency on STL
		(left > other.left) ? left : other.left,
		(top > other.top) ? top : other.top,
		(right < other.right) ? right : other.right,
		(bottom < other.bottom) ? bottom : other.bottom
		};
		}

		float left = 0.0f;
		float top = 0.0f;
		float right = 0.0f;

libs/ui/include/ui/Rect.h

+9 −0

Original line number	Diff line number	Diff line
		@@ -69,6 +69,15 @@ public:
		bottom = rb.y;
		}

		inline explicit Rect(const FloatRect& floatRect) {
		// Ideally we would use std::round, but we don't want to add an STL
		// dependency here, so we use an approximation
		left = static_cast<int32_t>(floatRect.left + 0.5f);
		top = static_cast<int32_t>(floatRect.top + 0.5f);
		right = static_cast<int32_t>(floatRect.right + 0.5f);
		bottom = static_cast<int32_t>(floatRect.bottom + 0.5f);
		}

		void makeInvalid();

		inline void clear() {

services/surfaceflinger/BufferLayer.cpp

+3 −2

Original line number	Diff line number	Diff line
		@@ -788,16 +788,17 @@ void BufferLayer::drawWithOpenGL(const RenderArea& renderArea, bool useIdentityT
		* minimal value)? Or, we could make GL behave like HWC -- but this feel
		* like more of a hack.
		*/
		Rect win(computeBounds());
		const Rect bounds{computeBounds()}; // Rounds from FloatRect

		Transform t = getTransform();
		Rect win = bounds;
		if (!s.finalCrop.isEmpty()) {
		win = t.transform(win);
		if (!win.intersect(s.finalCrop, &win)) {
		win.clear();
		}
		win = t.inverse().transform(win);
		if (!win.intersect(computeBounds(), &win)) {
		if (!win.intersect(bounds, &win)) {
		win.clear();
		}
		}

services/surfaceflinger/Layer.cpp

+20 −8

Original line number	Diff line number	Diff line
		@@ -285,6 +285,14 @@ static Rect reduce(const Rect& win, const Region& exclude) {
		return Region(win).subtract(exclude).getBounds();
		}

		static FloatRect reduce(const FloatRect& win, const Region& exclude) {
		if (CC_LIKELY(exclude.isEmpty())) {
		return win;
		}
		// Convert through Rect (by rounding) for lack of FloatRegion
		return Region(Rect{win}).subtract(exclude).getBounds().toFloatRect();
		}

		Rect Layer::computeScreenBounds(bool reduceTransparentRegion) const {
		const Layer::State& s(getDrawingState());
		Rect win(s.active.w, s.active.h);
		@@ -323,12 +331,12 @@ Rect Layer::computeScreenBounds(bool reduceTransparentRegion) const {
		return win;
		}

		Rect Layer::computeBounds() const {
		FloatRect Layer::computeBounds() const {
		const Layer::State& s(getDrawingState());
		return computeBounds(s.activeTransparentRegion);
		}

		Rect Layer::computeBounds(const Region& activeTransparentRegion) const {
		FloatRect Layer::computeBounds(const Region& activeTransparentRegion) const {
		const Layer::State& s(getDrawingState());
		Rect win(s.active.w, s.active.h);

		@@ -345,14 +353,16 @@ Rect Layer::computeBounds(const Region& activeTransparentRegion) const {
		}

		Transform t = getTransform();

		FloatRect floatWin = win.toFloatRect();
		if (p != nullptr) {
		win = t.transform(win);
		win.intersect(bounds, &win);
		win = t.inverse().transform(win);
		floatWin = t.transform(floatWin);
		floatWin = floatWin.intersect(bounds.toFloatRect());
		floatWin = t.inverse().transform(floatWin);
		}

		// subtract the transparent region and snap to the bounds
		return reduce(win, activeTransparentRegion);
		return reduce(floatWin, activeTransparentRegion);
		}

		Rect Layer::computeInitialCrop(const sp<const DisplayDevice>& hw) const {
		@@ -528,7 +538,9 @@ void Layer::setGeometry(const sp<const DisplayDevice>& displayDevice, uint32_t z
		Rect(activeCrop.right, activeCrop.top, s.active.w, activeCrop.bottom));
		}

		Rect frame(t.transform(computeBounds(activeTransparentRegion)));
		// computeBounds returns a FloatRect to provide more accuracy during the
		// transformation. We then round upon constructing 'frame'.
		Rect frame{t.transform(computeBounds(activeTransparentRegion))};
		if (!s.finalCrop.isEmpty()) {
		if (!frame.intersect(s.finalCrop, &frame)) {
		frame.clear();
		@@ -807,7 +819,7 @@ void Layer::computeGeometry(const RenderArea& renderArea, Mesh& mesh,
		const Layer::State& s(getDrawingState());
		const Transform renderAreaTransform(renderArea.getTransform());
		const uint32_t height = renderArea.getHeight();
		Rect win = computeBounds();
		FloatRect win = computeBounds();

		vec2 lt = vec2(win.left, win.top);
		vec2 lb = vec2(win.left, win.bottom);

services/surfaceflinger/Layer.h

+3 −2

Original line number	Diff line number	Diff line
		@@ -24,6 +24,7 @@
		#include <utils/String8.h>
		#include <utils/Timers.h>

		#include <ui/FloatRect.h>
		#include <ui/FrameStats.h>
		#include <ui/GraphicBuffer.h>
		#include <ui/PixelFormat.h>
		@@ -303,8 +304,8 @@ public:
		}

		void computeGeometry(const RenderArea& renderArea, Mesh& mesh, bool useIdentityTransform) const;
		Rect computeBounds(const Region& activeTransparentRegion) const;
		Rect computeBounds() const;
		FloatRect computeBounds(const Region& activeTransparentRegion) const;
		FloatRect computeBounds() const;

		int32_t getSequence() const { return sequence; }