2016-08-18 15:55:48 +00:00
|
|
|
/*
|
|
|
|
* Copyright 2016 Google Inc.
|
|
|
|
*
|
|
|
|
* Use of this source code is governed by a BSD-style license that can be
|
|
|
|
* found in the LICENSE file.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "SampleCode.h"
|
|
|
|
#include "SkCanvas.h"
|
|
|
|
#include "SkLightingShader.h"
|
|
|
|
#include "SkNormalSource.h"
|
|
|
|
#include "sk_tool_utils.h"
|
|
|
|
|
2016-08-19 19:41:48 +00:00
|
|
|
class ParentControl;
|
|
|
|
|
|
|
|
// Abstract base class for all components that a control panel must have
|
|
|
|
class Control : public SkRefCnt {
|
|
|
|
public:
|
|
|
|
Control(SkString name)
|
|
|
|
: fName(name)
|
|
|
|
, fParent(nullptr)
|
|
|
|
, fRelativePos(SkPoint::Make(0.0f, 0.0f)) {}
|
|
|
|
|
|
|
|
// Use this to propagate a click's position down to a control. Gets modulated by the component's
|
|
|
|
// relative position
|
|
|
|
bool click(const SkPoint& clickPos) {
|
|
|
|
SkPoint relativeClickPos = SkPoint::Make(clickPos.fX - fRelativePos.fX,
|
|
|
|
clickPos.fY - fRelativePos.fY);
|
|
|
|
return this->onClick(relativeClickPos);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Use this to draw the control and its appropriate children. Gets modulated by the component's
|
|
|
|
// relative position.
|
|
|
|
void drawContent(SkCanvas *canvas) {
|
|
|
|
canvas->save();
|
|
|
|
canvas->translate(fRelativePos.fX, fRelativePos.fY);
|
|
|
|
this->onDrawContent(canvas);
|
|
|
|
canvas->restore();
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Returns true when click position argumend lands over a control region in this control. Click
|
|
|
|
* position gets modulated by the component's relative position.
|
|
|
|
*
|
|
|
|
* @param click The position of the click in the coordinate space relative to the parent
|
|
|
|
*/
|
|
|
|
bool isInCtrlRegion(const SkPoint& click) {
|
|
|
|
SkPoint relativeClickPos = SkPoint::Make(click.fX - fRelativePos.fX,
|
|
|
|
click.fY - fRelativePos.fY);
|
|
|
|
return this->onIsInCtrlRegion(relativeClickPos);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Returns height of content drawn
|
|
|
|
virtual SkScalar height() const = 0;
|
|
|
|
|
|
|
|
// Sets the parent of this component. May only be used once. Height must remain constant after
|
|
|
|
// parent is set.
|
|
|
|
void setParent(ParentControl *parent, const SkPoint& relativePos) {
|
|
|
|
SkASSERT(parent);
|
|
|
|
SkASSERT(!fParent); // No chidren transfer since relativeY would get invalid for younger kid
|
|
|
|
|
|
|
|
fParent = parent;
|
|
|
|
fRelativePos = relativePos;
|
|
|
|
this->onSetParent();
|
|
|
|
}
|
|
|
|
|
|
|
|
// Overriden by sub-classes that need to recompute fields after parent is set. Called after
|
|
|
|
// setting fParent.
|
|
|
|
virtual void onSetParent() {}
|
|
|
|
|
|
|
|
// Overriden by sub-classes that need to know when a click is released.
|
|
|
|
virtual void onClickRelease() {}
|
|
|
|
|
|
|
|
protected:
|
|
|
|
|
|
|
|
// Draws a label for the component, using its name and a passed value. Does NOT modulate by
|
|
|
|
// relative height, expects CTM to have been adjusted in advance.
|
|
|
|
void drawLabel(SkCanvas *canvas, const SkString& valueStr) const {
|
|
|
|
// TODO Cache this
|
|
|
|
sk_sp<SkTypeface> fLabelTypeface =
|
|
|
|
sk_tool_utils::create_portable_typeface("sans-serif", SkFontStyle());
|
|
|
|
|
|
|
|
SkString label;
|
|
|
|
label.append(fName);
|
|
|
|
label.append(": ");
|
|
|
|
label.append(valueStr);
|
|
|
|
|
|
|
|
SkPaint labelPaint;
|
|
|
|
labelPaint.setTypeface(fLabelTypeface);
|
|
|
|
labelPaint.setAntiAlias(true);
|
|
|
|
labelPaint.setColor(0xFFFFFFFF);
|
|
|
|
labelPaint.setTextSize(12.0f);
|
|
|
|
|
|
|
|
canvas->drawText(label.c_str(), label.size(), 0, kLabelHeight - 6.0f, labelPaint);
|
|
|
|
}
|
|
|
|
|
|
|
|
SkString fName;
|
|
|
|
ParentControl* fParent;
|
|
|
|
|
|
|
|
static constexpr SkScalar kLabelHeight = 20.0f;
|
|
|
|
|
|
|
|
private:
|
|
|
|
// Overriden by sub-class to draw component. Do not call directly, drawContent() modulates by
|
|
|
|
// relative position.
|
|
|
|
virtual void onDrawContent(SkCanvas *canvas) = 0;
|
|
|
|
|
|
|
|
// Overriden by sub-class to handle clicks. Do not call directly, click() modulates by relative
|
|
|
|
// position. Return true if holding mouse capture
|
|
|
|
virtual bool onClick(const SkPoint& clickPos) { return false; };
|
|
|
|
|
|
|
|
// Overriden by sub-classes with controls. Should return true if clickPos lands inside a control
|
|
|
|
// region, to enable mouse caputre.
|
|
|
|
virtual bool onIsInCtrlRegion(const SkPoint& clickPos) const { return false; };
|
|
|
|
|
|
|
|
// The position of the control relative to it's parent
|
|
|
|
SkPoint fRelativePos;
|
|
|
|
};
|
|
|
|
|
|
|
|
class ParentControl : public Control { // Interface for all controls that have children
|
|
|
|
public:
|
|
|
|
ParentControl(const SkString& name) : INHERITED(name) {}
|
|
|
|
|
|
|
|
// Adds a child
|
|
|
|
virtual void add(sk_sp<Control> control) = 0;
|
|
|
|
|
|
|
|
// Returns the control's width. Used to propagate width down to components that don't specify it
|
|
|
|
virtual SkScalar width() const = 0;
|
|
|
|
|
|
|
|
private:
|
|
|
|
typedef Control INHERITED;
|
|
|
|
};
|
|
|
|
|
|
|
|
class ControlPanel : public ParentControl {
|
|
|
|
public:
|
|
|
|
|
|
|
|
ControlPanel(SkScalar width)
|
|
|
|
: ParentControl(SkString("ControlPanel"))
|
|
|
|
, fWidth(width)
|
|
|
|
, fHeight(0.0f)
|
|
|
|
, fSelectedControl(-1) {}
|
|
|
|
|
|
|
|
// Width unspecified, expectation is inheritance from parent
|
|
|
|
ControlPanel() : ControlPanel(-1.0f) {}
|
|
|
|
|
|
|
|
// Use this for introducing clicks on a ControlPanel from outside of the framework. It
|
|
|
|
// propagates click release or position down the chain. Returns false when click capture is
|
|
|
|
// being released.
|
|
|
|
bool inClick(SkView::Click *inClick) {
|
|
|
|
if (SkView::Click::State::kUp_State == inClick->fState) {
|
|
|
|
this->onClickRelease();
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return this->click(inClick->fCurr);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Add children
|
|
|
|
void add(sk_sp<Control> control) override {
|
|
|
|
SkASSERT(!fParent); // Validity of parent's relativeY and fHeight depends on immutability
|
|
|
|
fControls.push_back(control);
|
|
|
|
control->setParent(this, SkPoint::Make(0.0f, fHeight));
|
|
|
|
fHeight += control->height();
|
|
|
|
}
|
|
|
|
|
|
|
|
SkScalar width() const override {
|
|
|
|
return fParent ? fParent->width() : fWidth; // Width inherited from parent if there is one
|
|
|
|
}
|
|
|
|
|
|
|
|
SkScalar height() const override {
|
|
|
|
return fHeight;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Propagate click release to selected control, deselect control
|
|
|
|
void onClickRelease() override {
|
|
|
|
if (fSelectedControl >= 0) {
|
|
|
|
fControls[fSelectedControl]->onClickRelease();
|
|
|
|
}
|
|
|
|
fSelectedControl = -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Propagate onSetParent() down to children, some might need fParent->width() refresh
|
|
|
|
void onSetParent() override {
|
|
|
|
for (int i = 0; i < fControls.count(); i++) {
|
|
|
|
fControls[i]->onSetParent();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Holds a vertical shelf of controls. Can't be hierarchy root if not given a width value.
|
|
|
|
static sk_sp<ParentControl> Make() {
|
|
|
|
return sk_sp<ParentControl>(new ControlPanel());
|
|
|
|
}
|
|
|
|
|
|
|
|
// Holds a vertical shelf of controls. Only control that can be hooked from outside the
|
|
|
|
// framework.
|
|
|
|
static sk_sp<ParentControl> Make(SkScalar width) {
|
|
|
|
return sk_sp<ParentControl>(new ControlPanel(width));
|
|
|
|
}
|
|
|
|
|
|
|
|
protected:
|
|
|
|
// Returns true if control panel has mouse captured, false when it is ready to release
|
|
|
|
// capture
|
|
|
|
bool onClick(const SkPoint& click) override {
|
|
|
|
|
|
|
|
if (fSelectedControl == -1) { // If no child control selected, check every child
|
|
|
|
for (int i = 0; i < fControls.count(); i++) {
|
|
|
|
if (fControls[i]->isInCtrlRegion(click)) {
|
|
|
|
fSelectedControl = i;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (fSelectedControl >= 0) { // If child control selected, propagate click
|
|
|
|
bool keepSelection = fControls[fSelectedControl]->click(click);
|
|
|
|
if (!keepSelection) {
|
|
|
|
fSelectedControl = -1;
|
|
|
|
}
|
|
|
|
return keepSelection;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Draw all children
|
|
|
|
void onDrawContent(SkCanvas* canvas) override {
|
|
|
|
canvas->save();
|
|
|
|
for (int i = 0; i < fControls.count(); i++) {
|
|
|
|
fControls[i]->drawContent(canvas);
|
|
|
|
}
|
|
|
|
canvas->restore();
|
|
|
|
}
|
|
|
|
|
|
|
|
// Check all children's control regions
|
|
|
|
bool onIsInCtrlRegion(const SkPoint& clickPos) const override {
|
|
|
|
for (int i = 0; i < fControls.count(); i++) {
|
|
|
|
if (fControls[i]->isInCtrlRegion(clickPos)) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
SkScalar fWidth;
|
|
|
|
SkScalar fHeight;
|
|
|
|
|
|
|
|
SkTArray<sk_sp<Control>> fControls;
|
|
|
|
int fSelectedControl;
|
|
|
|
};
|
|
|
|
|
|
|
|
class DiscreteSliderControl : public Control {
|
|
|
|
public:
|
|
|
|
SkScalar height() const override {
|
|
|
|
return 2.0f * kLabelHeight;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Set width-dependant variables when new parent is set
|
|
|
|
void onSetParent() override {
|
|
|
|
fCtrlRegion = SkRect::MakeXYWH(0.0f, kLabelHeight, fParent->width(), kSliderHeight);
|
|
|
|
fSliderRange = fParent->width() - kSliderWidth;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Make a slider for an integer value. Snaps to discrete positions.
|
|
|
|
*
|
|
|
|
* @params name The name of the control, displayed in the label
|
|
|
|
* @params output Pointer to the integer that will be set by the slider
|
|
|
|
* @params min Min value for output.
|
|
|
|
* @params max Max value for output.
|
|
|
|
*/
|
|
|
|
static sk_sp<Control> Make(SkString name, int* output, int min, int max) {
|
|
|
|
return sk_sp<Control>(new DiscreteSliderControl(name, output, min, max));
|
|
|
|
}
|
|
|
|
|
|
|
|
protected:
|
|
|
|
void onDrawContent(SkCanvas* canvas) override {
|
|
|
|
SkASSERT(fParent);
|
|
|
|
int numChoices = fMax - fMin + 1;
|
|
|
|
fSlider.offsetTo(fSliderRange * ( (*fOutput)/SkIntToScalar(numChoices)
|
|
|
|
+ 1.0f/(2.0f * numChoices) ),
|
|
|
|
fSlider.fTop);
|
|
|
|
|
|
|
|
SkString valueStr;
|
|
|
|
valueStr.appendS32(*fOutput);
|
|
|
|
this->drawLabel(canvas, valueStr);
|
|
|
|
|
|
|
|
SkPaint sliderPaint;
|
|
|
|
sliderPaint.setColor(0xFFF3F3F3);
|
|
|
|
canvas->drawRect(fSlider, sliderPaint);
|
|
|
|
|
|
|
|
SkPaint ctrlRegionPaint;
|
|
|
|
ctrlRegionPaint.setColor(0xFFFFFFFF);
|
|
|
|
ctrlRegionPaint.setStyle(SkPaint::kStroke_Style);
|
|
|
|
ctrlRegionPaint.setStrokeWidth(2.0f);
|
|
|
|
canvas->drawRect(fCtrlRegion, ctrlRegionPaint);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool onClick(const SkPoint& clickPos) override {
|
|
|
|
SkASSERT(fParent);
|
|
|
|
SkScalar x = SkScalarPin(clickPos.fX, 0.0f, fSliderRange);
|
|
|
|
int numChoices = fMax - fMin + 1;
|
|
|
|
*fOutput = SkTMin(SkScalarFloorToInt(numChoices * x / fSliderRange) + fMin, fMax);
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool onIsInCtrlRegion(const SkPoint& clickPos) const override {
|
|
|
|
SkASSERT(fParent);
|
|
|
|
return fCtrlRegion.contains(SkRect::MakeXYWH(clickPos.fX, clickPos.fY, 1, 1));
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
DiscreteSliderControl(SkString name, int* output, int min, int max)
|
|
|
|
: INHERITED(name)
|
|
|
|
, fOutput(output)
|
|
|
|
, fMin(min)
|
|
|
|
, fMax(max) {
|
|
|
|
fSlider = SkRect::MakeXYWH(0, kLabelHeight, kSliderWidth, kSliderHeight);
|
|
|
|
}
|
|
|
|
|
|
|
|
int* fOutput;
|
|
|
|
int fMin;
|
|
|
|
int fMax;
|
|
|
|
SkRect fSlider; // The rectangle that slides
|
|
|
|
// The region in which the rectangle slides. Also the region in which mouse is caputred
|
|
|
|
SkRect fCtrlRegion;
|
|
|
|
SkScalar fSliderRange; // The width in pixels over which the slider can slide
|
|
|
|
|
|
|
|
static constexpr SkScalar kSliderHeight = 20.0f;
|
|
|
|
static constexpr SkScalar kSliderWidth = 10.0f;
|
|
|
|
|
|
|
|
typedef Control INHERITED;
|
|
|
|
};
|
|
|
|
|
|
|
|
class ControlSwitcher : public ParentControl {
|
|
|
|
public:
|
|
|
|
// Add children
|
|
|
|
void add(sk_sp<Control> control) override {
|
|
|
|
SkASSERT(!fParent); // Validity of parent's relativeY and fHeight depends on immutability
|
|
|
|
fControls.push_back(control);
|
|
|
|
control->setParent(this, SkPoint::Make(0.0f, kSelectorHeight));
|
|
|
|
fHeight = SkMaxScalar(fHeight, control->height()); // Setting height to max child height.
|
|
|
|
}
|
|
|
|
|
|
|
|
SkScalar width() const override { return fParent ? (fParent->width()) : 0; }
|
|
|
|
|
|
|
|
SkScalar height() const override {
|
|
|
|
return fHeight;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Propagate onClickRelease to control that currently captures mouse
|
|
|
|
void onClickRelease() override {
|
|
|
|
if (fCtrlOnClick) {
|
|
|
|
fCtrlOnClick->onClickRelease();
|
|
|
|
}
|
|
|
|
fCtrlOnClick = nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
void onSetParent() override {
|
|
|
|
for (int i = 0; i < fControls.count(); i++) {
|
|
|
|
fControls[i]->onSetParent(); // Propagate to children
|
|
|
|
}
|
|
|
|
|
|
|
|
// Finalize control selector
|
|
|
|
// TODO can be moved to constructor if list-initialized
|
|
|
|
if (!finalizedChildren) {
|
|
|
|
fControlSelector = DiscreteSliderControl::Make(
|
|
|
|
SkString(fName), &fSelectedControl, 0, fControls.count()-1);
|
|
|
|
fControlSelector->setParent(this, SkPoint::Make(0.0f, 0.0f));
|
|
|
|
fHeight += kSelectorHeight;
|
|
|
|
|
|
|
|
SkASSERT(fControlSelector->height() <= kSelectorHeight);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* A set of a selector and a list of controls. Displays the control from the list of controls
|
|
|
|
* with the index set by the aforementioned selector.
|
|
|
|
*
|
|
|
|
* @param name The name of the switcher. Will be displayed in the selector's label.
|
|
|
|
*/
|
|
|
|
static sk_sp<ParentControl> Make(const SkString& name) {
|
|
|
|
return sk_sp<ParentControl>(new ControlSwitcher(name));
|
|
|
|
}
|
|
|
|
|
|
|
|
protected:
|
|
|
|
// Draw selector and currently selected control
|
|
|
|
void onDrawContent(SkCanvas* canvas) override {
|
|
|
|
fControlSelector->drawContent(canvas);
|
|
|
|
fControls[fSelectedControl]->drawContent(canvas);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Returns true if control panel has mouse captured, false when it is ready to release
|
|
|
|
// capture
|
|
|
|
bool onClick(const SkPoint& click) override {
|
|
|
|
if (!fCtrlOnClick) {
|
|
|
|
if (fControlSelector->isInCtrlRegion(click)) {
|
|
|
|
fCtrlOnClick = fControlSelector.get();
|
|
|
|
} else if (fControls[fSelectedControl]->isInCtrlRegion(click)) {
|
|
|
|
fCtrlOnClick = fControls[fSelectedControl].get();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (fCtrlOnClick) {
|
|
|
|
return fCtrlOnClick->click(click);
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Is in control region of selector or currently selected control
|
|
|
|
bool onIsInCtrlRegion(const SkPoint& clickPos) const override {
|
|
|
|
if (fControlSelector->isInCtrlRegion(clickPos)) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
if (fControls[fSelectedControl]->isInCtrlRegion(clickPos)) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
ControlSwitcher(const SkString& name)
|
|
|
|
: INHERITED(name)
|
|
|
|
, fHeight(0.0)
|
|
|
|
, fSelectedControl(0)
|
|
|
|
, fCtrlOnClick(nullptr){}
|
|
|
|
|
|
|
|
bool finalizedChildren = false;
|
|
|
|
|
|
|
|
sk_sp<Control> fControlSelector;
|
|
|
|
SkScalar fHeight;
|
|
|
|
SkTArray<sk_sp<Control>> fControls;
|
|
|
|
int fSelectedControl;
|
|
|
|
|
|
|
|
Control* fCtrlOnClick;
|
|
|
|
|
|
|
|
static constexpr SkScalar kSelectorHeight = 40.0f;
|
|
|
|
|
|
|
|
typedef ParentControl INHERITED;
|
|
|
|
};
|
|
|
|
|
|
|
|
class ContinuousSliderControl : public Control {
|
|
|
|
public:
|
|
|
|
SkScalar height() const override {
|
|
|
|
return 2.0f * kLabelHeight;
|
|
|
|
}
|
|
|
|
|
|
|
|
void onSetParent() override {
|
|
|
|
fSlider = SkRect::MakeXYWH(0, kLabelHeight, kSliderWidth, kSliderHeight);
|
|
|
|
fCtrlRegion = SkRect::MakeXYWH(0.0f, kLabelHeight, fParent->width(), kSliderHeight);
|
|
|
|
fSliderRange = fParent->width() - kSliderWidth;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Make a slider for an SkScalar.
|
|
|
|
*
|
|
|
|
* @params name The name of the control, displayed in the label
|
|
|
|
* @params output Pointer to the SkScalar that will be set by the slider
|
|
|
|
* @params min Min value for output
|
|
|
|
* @params max Max value for output
|
|
|
|
*/
|
|
|
|
static sk_sp<Control> Make(const SkString& name, SkScalar* output, SkScalar min, SkScalar max) {
|
|
|
|
return sk_sp<Control>(new ContinuousSliderControl(name, output, min, max));
|
|
|
|
}
|
|
|
|
|
|
|
|
protected:
|
|
|
|
void onDrawContent(SkCanvas* canvas) override {
|
|
|
|
SkASSERT(fParent);
|
|
|
|
SkScalar x = fSliderRange * (*fOutput - fMin) / (fMax - fMin);
|
|
|
|
fSlider.offsetTo(SkScalarPin(x, 0.0f, fSliderRange), fSlider.fTop);
|
|
|
|
|
|
|
|
SkString valueStr;
|
|
|
|
valueStr.appendScalar(*fOutput);
|
|
|
|
this->drawLabel(canvas, valueStr);
|
|
|
|
|
|
|
|
SkPaint sliderPaint;
|
|
|
|
sliderPaint.setColor(0xFFF3F3F3);
|
|
|
|
canvas->drawRect(fSlider, sliderPaint);
|
|
|
|
|
|
|
|
SkPaint ctrlRegionPaint;
|
|
|
|
ctrlRegionPaint.setColor(0xFFFFFFFF);
|
|
|
|
ctrlRegionPaint.setStyle(SkPaint::kStroke_Style);
|
|
|
|
ctrlRegionPaint.setStrokeWidth(2.0f);
|
|
|
|
canvas->drawRect(fCtrlRegion, ctrlRegionPaint);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool onClick(const SkPoint& clickPos) override {
|
|
|
|
SkASSERT(fParent);
|
|
|
|
SkScalar x = SkScalarPin(clickPos.fX, 0.0f, fSliderRange);
|
|
|
|
*fOutput = (x/fSliderRange) * (fMax - fMin) + fMin;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool onIsInCtrlRegion(const SkPoint& clickPos) const override {
|
|
|
|
SkASSERT(fParent);
|
|
|
|
return fCtrlRegion.contains(SkRect::MakeXYWH(clickPos.fX, clickPos.fY, 1, 1));
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
ContinuousSliderControl(const SkString& name, SkScalar* output, SkScalar min, SkScalar max)
|
|
|
|
: INHERITED(name)
|
|
|
|
, fOutput(output)
|
|
|
|
, fMin(min)
|
|
|
|
, fMax(max) {}
|
|
|
|
|
|
|
|
SkScalar* fOutput;
|
|
|
|
SkScalar fMin;
|
|
|
|
SkScalar fMax;
|
|
|
|
SkRect fSlider;
|
|
|
|
SkRect fCtrlRegion;
|
|
|
|
SkScalar fSliderRange;
|
|
|
|
|
|
|
|
static constexpr SkScalar kSliderHeight = 20.0f;
|
|
|
|
static constexpr SkScalar kSliderWidth = 10.0f;
|
|
|
|
|
|
|
|
typedef Control INHERITED;
|
|
|
|
};
|
|
|
|
|
|
|
|
class RadialDirectionControl : public Control {
|
|
|
|
public:
|
|
|
|
SkScalar height() const override {
|
|
|
|
return kLabelHeight + 2.0f * kRegionRadius;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Make a direction selector.
|
|
|
|
*
|
|
|
|
* @params name The name of the control, displayed in the label
|
|
|
|
* @params output Pointer to the SkVector that will be set by the slider
|
|
|
|
*/
|
|
|
|
static sk_sp<Control> Make(const SkString& name, SkVector* output) {
|
|
|
|
return sk_sp<Control>(new RadialDirectionControl(name, output));
|
|
|
|
}
|
|
|
|
|
|
|
|
protected:
|
|
|
|
void onDrawContent(SkCanvas* canvas) override {
|
|
|
|
SkASSERT(fParent);
|
|
|
|
|
|
|
|
SkString valueStr;
|
|
|
|
valueStr.appendf("%.2f, %.2f", fOutput->fX, fOutput->fY);
|
|
|
|
this->drawLabel(canvas, valueStr);
|
|
|
|
|
|
|
|
SkPoint lineEnd = SkPoint::Make(fCtrlRegion.centerX(), fCtrlRegion.centerY())
|
|
|
|
+ (*fOutput * (kRegionRadius - kCapRadius));
|
|
|
|
SkPaint linePaint;
|
|
|
|
linePaint.setColor(0xFFF3F3F3);
|
|
|
|
linePaint.setStrokeWidth(kStrokeWidth);
|
|
|
|
linePaint.setAntiAlias(true);
|
|
|
|
linePaint.setStrokeCap(SkPaint::kRound_Cap);
|
|
|
|
canvas->drawLine(fCtrlRegion.centerX(), fCtrlRegion.centerY(),
|
|
|
|
lineEnd.fX, lineEnd.fY, linePaint);
|
|
|
|
|
|
|
|
SkPaint ctrlRegionPaint;
|
|
|
|
ctrlRegionPaint.setColor(0xFFFFFFFF);
|
|
|
|
ctrlRegionPaint.setStyle(SkPaint::kStroke_Style);
|
|
|
|
ctrlRegionPaint.setStrokeWidth(2.0f);
|
|
|
|
ctrlRegionPaint.setAntiAlias(true);
|
|
|
|
canvas->drawCircle(fCtrlRegion.centerX(), fCtrlRegion.centerY(), kRegionRadius,
|
|
|
|
ctrlRegionPaint);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool onClick(const SkPoint& clickPos) override {
|
|
|
|
SkASSERT(fParent);
|
|
|
|
fOutput->fX = clickPos.fX - fCtrlRegion.centerX();
|
|
|
|
fOutput->fY = clickPos.fY - fCtrlRegion.centerY();
|
|
|
|
fOutput->normalize();
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool onIsInCtrlRegion(const SkPoint& clickPos) const override {
|
|
|
|
SkASSERT(fParent);
|
|
|
|
return fCtrlRegion.contains(SkRect::MakeXYWH(clickPos.fX, clickPos.fY,
|
|
|
|
1, 1));
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
RadialDirectionControl(const SkString& name, SkVector* output)
|
|
|
|
: INHERITED(name)
|
|
|
|
, fOutput(output) {
|
|
|
|
fCtrlRegion = SkRect::MakeXYWH(0.0f, kLabelHeight,
|
|
|
|
kRegionRadius * 2.0f, kRegionRadius * 2.0f);
|
|
|
|
}
|
|
|
|
|
|
|
|
SkVector* fOutput;
|
|
|
|
SkRect fCtrlRegion;
|
|
|
|
|
|
|
|
static constexpr SkScalar kRegionRadius = 50.0f;
|
|
|
|
static constexpr SkScalar kStrokeWidth = 6.0f;
|
|
|
|
static constexpr SkScalar kCapRadius = kStrokeWidth / 2.0f;
|
|
|
|
|
|
|
|
typedef Control INHERITED;
|
|
|
|
};
|
|
|
|
|
|
|
|
class ColorDisplay: public Control {
|
|
|
|
public:
|
|
|
|
SkScalar height() const override {
|
|
|
|
return kHeight;
|
|
|
|
}
|
|
|
|
|
|
|
|
void onSetParent() override {
|
|
|
|
fDisplayRect = SkRect::MakeXYWH(0.0f, kPadding, fParent->width(), kHeight - kPadding);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Make a display that shows an SkColor3f.
|
|
|
|
*
|
|
|
|
* @params output Pointer to the SkColor3f that will be displayed
|
|
|
|
*/
|
|
|
|
static sk_sp<Control> Make(SkColor3f* input) {
|
|
|
|
return sk_sp<Control>(new ColorDisplay(SkString("ColorDisplay"), input));
|
|
|
|
}
|
|
|
|
|
|
|
|
protected:
|
|
|
|
void onDrawContent(SkCanvas* canvas) override {
|
|
|
|
SkASSERT(fParent);
|
|
|
|
|
|
|
|
SkPaint displayPaint;
|
|
|
|
displayPaint.setColor(SkColor4f::FromColor3f(*fInput, 1.0f).toSkColor());
|
|
|
|
canvas->drawRect(fDisplayRect, displayPaint);
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
ColorDisplay(const SkString& name, SkColor3f* input)
|
|
|
|
: INHERITED(name)
|
|
|
|
, fInput(input) {}
|
|
|
|
|
|
|
|
SkColor3f* fInput;
|
|
|
|
SkRect fDisplayRect;
|
|
|
|
|
|
|
|
static constexpr SkScalar kHeight = 24.0f;
|
|
|
|
static constexpr SkScalar kPadding = 4.0f;
|
|
|
|
|
|
|
|
typedef Control INHERITED;
|
|
|
|
};
|
2016-08-18 15:55:48 +00:00
|
|
|
|
|
|
|
class BevelView : public SampleView {
|
|
|
|
public:
|
|
|
|
BevelView()
|
|
|
|
: fShapeBounds(SkRect::MakeWH(kShapeBoundsSize, kShapeBoundsSize))
|
2016-08-19 19:41:48 +00:00
|
|
|
, fControlPanel(kCtrlRange) {
|
2016-08-18 15:55:48 +00:00
|
|
|
this->setBGColor(0xFF666868); // Slightly colorized gray for contrast
|
|
|
|
|
|
|
|
// Controls
|
2016-08-19 19:41:48 +00:00
|
|
|
fBevelWidth = 25.0f;
|
|
|
|
fBevelHeight = 25.0f;
|
|
|
|
fBevelType = 0;
|
|
|
|
|
|
|
|
int currLight = 0;
|
|
|
|
fLightDefs[currLight++] =
|
|
|
|
{SkVector::Make(0.0f, 1.0f), 1.0f, SkColor3f::Make(0.6f, 0.45f, 0.3f)};
|
|
|
|
fLightDefs[currLight++] =
|
|
|
|
{SkVector::Make(0.0f, -1.0f), 1.0f, SkColor3f::Make(0.3f, 0.45f, 0.6f)};
|
|
|
|
fLightDefs[currLight++] =
|
|
|
|
{SkVector::Make(1.0f, 0.0f), 1.0f, SkColor3f::Make(0.0f, 0.0f, 0.0f)};
|
|
|
|
// Making sure we initialized all lights
|
|
|
|
SkASSERT(currLight == kNumLights);
|
|
|
|
|
|
|
|
fControlPanel.add(ContinuousSliderControl::Make(SkString("BevelWidth"), &fBevelWidth,
|
|
|
|
1.0f, kShapeBoundsSize));
|
|
|
|
fControlPanel.add(ContinuousSliderControl::Make(SkString("BevelHeight"), &fBevelHeight,
|
|
|
|
-50.0f, 50.0f));
|
|
|
|
fControlPanel.add(DiscreteSliderControl::Make(SkString("BevelType"), &fBevelType,
|
|
|
|
0, 2));
|
|
|
|
sk_sp<ParentControl> lightCtrlSelector = ControlSwitcher::Make(SkString("SelectedLight"));
|
|
|
|
for (int i = 0; i < kNumLights; i++) {
|
|
|
|
SkString name("Light");
|
|
|
|
name.appendS32(i);
|
|
|
|
sk_sp<ParentControl> currLightPanel = ControlPanel::Make();
|
|
|
|
SkString dirName(name);
|
|
|
|
dirName.append("Dir");
|
|
|
|
currLightPanel->add(RadialDirectionControl::Make(dirName, &(fLightDefs[i].fDirXY)));
|
|
|
|
SkString heightName(name);
|
|
|
|
heightName.append("Height");
|
|
|
|
currLightPanel->add(ContinuousSliderControl::Make(heightName, &(fLightDefs[i].fDirZ),
|
|
|
|
0.0f, 2.0f));
|
|
|
|
SkString redName(name);
|
|
|
|
redName.append("Red");
|
|
|
|
currLightPanel->add(ContinuousSliderControl::Make(redName, &(fLightDefs[i].fColor.fX),
|
|
|
|
0.0f, 1.0f));
|
|
|
|
SkString greenName(name);
|
|
|
|
greenName.append("Green");
|
|
|
|
currLightPanel->add(ContinuousSliderControl::Make(greenName, &(fLightDefs[i].fColor.fY),
|
|
|
|
0.0f, 1.0f));
|
|
|
|
SkString blueName(name);
|
|
|
|
blueName.append("Blue");
|
|
|
|
currLightPanel->add(ContinuousSliderControl::Make(blueName, &(fLightDefs[i].fColor.fZ),
|
|
|
|
0.0f, 1.0f));
|
|
|
|
currLightPanel->add(ColorDisplay::Make(&(fLightDefs[i].fColor)));
|
|
|
|
lightCtrlSelector->add(currLightPanel);
|
|
|
|
}
|
|
|
|
fControlPanel.add(lightCtrlSelector);
|
2016-08-18 15:55:48 +00:00
|
|
|
|
2016-08-19 19:41:48 +00:00
|
|
|
fControlPanelSelected = false;
|
2016-08-18 15:55:48 +00:00
|
|
|
fDirtyNormalSource = true;
|
|
|
|
|
|
|
|
fLabelTypeface = sk_tool_utils::create_portable_typeface("sans-serif", SkFontStyle());
|
|
|
|
}
|
|
|
|
|
|
|
|
protected:
|
|
|
|
bool onQuery(SkEvent *evt) override {
|
|
|
|
if (SampleCode::TitleQ(*evt)) {
|
|
|
|
SampleCode::TitleR(evt, "Bevel");
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return this->INHERITED::onQuery(evt);
|
|
|
|
}
|
|
|
|
|
|
|
|
enum Shape {
|
|
|
|
kCircle_Shape,
|
|
|
|
kRect_Shape,
|
|
|
|
};
|
|
|
|
void drawShape(enum Shape shape, SkCanvas* canvas) {
|
|
|
|
canvas->save();
|
|
|
|
|
|
|
|
SkPaint paint;
|
|
|
|
|
|
|
|
if (fDirtyNormalSource) {
|
2016-08-19 19:41:48 +00:00
|
|
|
fNormalSource = SkNormalSource::MakeBevel((SkNormalSource::BevelType)fBevelType,
|
|
|
|
fBevelWidth, fBevelHeight);
|
2016-08-18 15:55:48 +00:00
|
|
|
fDirtyNormalSource = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
paint.setShader(SkLightingShader::Make(nullptr, fNormalSource, fLights));
|
|
|
|
paint.setAntiAlias(true);
|
|
|
|
paint.setColor(0xFFDDDDDD);
|
|
|
|
switch (shape) {
|
|
|
|
case kCircle_Shape:
|
|
|
|
canvas->drawCircle(fShapeBounds.centerX(), fShapeBounds.centerY(),
|
|
|
|
fShapeBounds.width()/2.0f, paint);
|
|
|
|
break;
|
|
|
|
case kRect_Shape:
|
|
|
|
canvas->drawRect(fShapeBounds, paint);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
SkDEBUGFAIL("Invalid shape enum for drawShape");
|
|
|
|
}
|
|
|
|
|
|
|
|
canvas->restore();
|
|
|
|
}
|
|
|
|
|
|
|
|
void onDrawContent(SkCanvas *canvas) override {
|
|
|
|
|
|
|
|
canvas->save();
|
2016-08-19 19:41:48 +00:00
|
|
|
canvas->resetMatrix(); // Force static control panel position
|
|
|
|
fControlPanel.drawContent(canvas);
|
|
|
|
canvas->restore();
|
2016-08-18 15:55:48 +00:00
|
|
|
|
2016-08-19 19:41:48 +00:00
|
|
|
SkLights::Builder builder;
|
|
|
|
for (int i = 0; i < kNumLights; i++) {
|
|
|
|
builder.add(SkLights::Light::MakeDirectional(fLightDefs[i].fColor,
|
|
|
|
SkPoint3::Make(fLightDefs[i].fDirXY.fX,
|
|
|
|
fLightDefs[i].fDirXY.fY,
|
|
|
|
fLightDefs[i].fDirZ)));
|
2016-08-18 15:55:48 +00:00
|
|
|
}
|
2016-08-19 19:41:48 +00:00
|
|
|
builder.add(SkLights::Light::MakeAmbient(SkColor3f::Make(0.4f, 0.4f, 0.4f)));
|
|
|
|
fLights = builder.finish();
|
2016-08-18 15:55:48 +00:00
|
|
|
|
|
|
|
// Draw shapes
|
|
|
|
SkScalar xPos = kCtrlRange + 25.0f;
|
|
|
|
SkScalar yPos = fShapeBounds.height();
|
|
|
|
for (Shape shape : { kCircle_Shape, kRect_Shape }) {
|
|
|
|
canvas->save();
|
|
|
|
canvas->translate(xPos, yPos);
|
|
|
|
this->drawShape(shape, canvas);
|
|
|
|
canvas->restore();
|
|
|
|
|
|
|
|
xPos += 1.2f * fShapeBounds.width();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
SkView::Click* onFindClickHandler(SkScalar x, SkScalar y, unsigned modi) override {
|
|
|
|
return new SkView::Click(this);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool onClick(Click *click) override {
|
2016-08-19 19:41:48 +00:00
|
|
|
// Control panel mouse handling
|
|
|
|
fControlPanelSelected = fControlPanel.inClick(click);
|
2016-08-18 15:55:48 +00:00
|
|
|
|
2016-08-19 19:41:48 +00:00
|
|
|
if (fControlPanelSelected) { // Control modification
|
2016-08-18 15:55:48 +00:00
|
|
|
fDirtyNormalSource = true;
|
|
|
|
|
|
|
|
this->inval(nullptr);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2016-08-19 19:41:48 +00:00
|
|
|
// TODO move shapes
|
|
|
|
this->inval(nullptr);
|
2016-08-18 15:55:48 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
static constexpr int kNumTestRects = 3;
|
|
|
|
|
|
|
|
static constexpr SkScalar kShapeBoundsSize = 120.0f;
|
|
|
|
|
|
|
|
static constexpr SkScalar kCtrlRange = 150.0f;
|
|
|
|
|
2016-08-19 19:41:48 +00:00
|
|
|
static constexpr int kNumLights = 3;
|
2016-08-18 15:55:48 +00:00
|
|
|
|
|
|
|
const SkRect fShapeBounds;
|
|
|
|
|
|
|
|
SkScalar fBevelWidth;
|
|
|
|
SkScalar fBevelHeight;
|
2016-08-19 19:41:48 +00:00
|
|
|
int fBevelType;
|
|
|
|
|
2016-08-18 15:55:48 +00:00
|
|
|
sk_sp<SkNormalSource> fNormalSource;
|
|
|
|
bool fDirtyNormalSource;
|
|
|
|
|
|
|
|
sk_sp<SkLights> fLights;
|
2016-08-19 19:41:48 +00:00
|
|
|
|
|
|
|
struct LightDef {
|
|
|
|
SkVector fDirXY;
|
|
|
|
SkScalar fDirZ;
|
|
|
|
SkColor3f fColor;
|
|
|
|
|
|
|
|
LightDef() {}
|
|
|
|
LightDef(SkVector dirXY, SkScalar dirZ, SkColor3f color)
|
|
|
|
: fDirXY(dirXY)
|
|
|
|
, fDirZ(dirZ)
|
|
|
|
, fColor(color) {}
|
|
|
|
};
|
|
|
|
LightDef fLightDefs[kNumLights];
|
|
|
|
|
|
|
|
ControlPanel fControlPanel;
|
|
|
|
bool fControlPanelSelected;
|
2016-08-18 15:55:48 +00:00
|
|
|
|
|
|
|
sk_sp<SkTypeface> fLabelTypeface;
|
|
|
|
|
|
|
|
typedef SampleView INHERITED;
|
|
|
|
};
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
static SkView* MyFactory() { return new BevelView; }
|
|
|
|
static SkViewRegister reg(MyFactory);
|
|
|
|
|