Spaces:
Sleeping
Sleeping
File size: 4,057 Bytes
9a14526 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 | // @flow
import styleSpec from '../style-spec/reference/latest';
import {endsWith, extend, sphericalToCartesian} from '../util/util';
import {Evented} from '../util/evented';
import {
validateStyle,
validateLight,
emitValidationErrors
} from './validate_style';
import Color from '../style-spec/util/color';
import {number as interpolate} from '../style-spec/util/interpolate';
import type {StylePropertySpecification} from '../style-spec/style-spec';
import type EvaluationParameters from './evaluation_parameters';
import type {StyleSetterOptions} from '../style/style';
import {Properties, Transitionable, Transitioning, PossiblyEvaluated, DataConstantProperty} from './properties';
import type {
Property,
PropertyValue,
TransitionParameters
} from './properties';
import type {LightSpecification} from '../style-spec/types';
type LightPosition = {
x: number,
y: number,
z: number
};
class LightPositionProperty implements Property<[number, number, number], LightPosition> {
specification: StylePropertySpecification;
constructor() {
this.specification = styleSpec.light.position;
}
possiblyEvaluate(value: PropertyValue<[number, number, number], LightPosition>, parameters: EvaluationParameters): LightPosition {
return sphericalToCartesian(value.expression.evaluate(parameters));
}
interpolate(a: LightPosition, b: LightPosition, t: number): LightPosition {
return {
x: interpolate(a.x, b.x, t),
y: interpolate(a.y, b.y, t),
z: interpolate(a.z, b.z, t),
};
}
}
type Props = {|
"anchor": DataConstantProperty<"map" | "viewport">,
"position": LightPositionProperty,
"color": DataConstantProperty<Color>,
"intensity": DataConstantProperty<number>,
|};
const properties: Properties<Props> = new Properties({
"anchor": new DataConstantProperty(styleSpec.light.anchor),
"position": new LightPositionProperty(),
"color": new DataConstantProperty(styleSpec.light.color),
"intensity": new DataConstantProperty(styleSpec.light.intensity),
});
const TRANSITION_SUFFIX = '-transition';
/*
* Represents the light used to light extruded features.
*/
class Light extends Evented {
_transitionable: Transitionable<Props>;
_transitioning: Transitioning<Props>;
properties: PossiblyEvaluated<Props>;
constructor(lightOptions?: LightSpecification) {
super();
this._transitionable = new Transitionable(properties);
this.setLight(lightOptions);
this._transitioning = this._transitionable.untransitioned();
}
getLight() {
return this._transitionable.serialize();
}
setLight(light?: LightSpecification, options: StyleSetterOptions = {}) {
if (this._validate(validateLight, light, options)) {
return;
}
for (const name in light) {
const value = light[name];
if (endsWith(name, TRANSITION_SUFFIX)) {
this._transitionable.setTransition(name.slice(0, -TRANSITION_SUFFIX.length), value);
} else {
this._transitionable.setValue(name, value);
}
}
}
updateTransitions(parameters: TransitionParameters) {
this._transitioning = this._transitionable.transitioned(parameters, this._transitioning);
}
hasTransition() {
return this._transitioning.hasTransition();
}
recalculate(parameters: EvaluationParameters) {
this.properties = this._transitioning.possiblyEvaluate(parameters);
}
_validate(validate: Function, value: mixed, options?: {validate?: boolean}) {
if (options && options.validate === false) {
return false;
}
return emitValidationErrors(this, validate.call(validateStyle, extend({
value,
// Workaround for https://github.com/mapbox/mapbox-gl-js/issues/2407
style: {glyphs: true, sprite: true},
styleSpec
})));
}
}
export default Light;
|