(function () {
var LIVE2DCUBISMFRAMEWORK;
(function (LIVE2DCUBISMFRAMEWORK) {
var AnimationPoint = (function () {
function AnimationPoint (time, value) {
this.time = time
this.value = value
}
return AnimationPoint
}())
LIVE2DCUBISMFRAMEWORK.AnimationPoint = AnimationPoint
var AnimationUserDataBody = (function () {
function AnimationUserDataBody (time, value) {
this.time = time
this.value = value
}
;
return AnimationUserDataBody
}())
LIVE2DCUBISMFRAMEWORK.AnimationUserDataBody = AnimationUserDataBody
var BuiltinAnimationSegmentEvaluators = (function () {
function BuiltinAnimationSegmentEvaluators () {
}
BuiltinAnimationSegmentEvaluators.lerp = function (a, b, t) {
return new AnimationPoint((a.time + ((b.time - a.time) * t)), (a.value + ((b.value - a.value) * t)))
}
BuiltinAnimationSegmentEvaluators.LINEAR = function (points, offset, time) {
var p0 = points[offset + 0]
var p1 = points[offset + 1]
var t = (time - p0.time) / (p1.time - p0.time)
return (p0.value + ((p1.value - p0.value) * t))
}
BuiltinAnimationSegmentEvaluators.BEZIER = function (points, offset, time) {
var t = (time - points[offset + 0].time) / (points[offset + 3].time - points[offset].time)
var p01 = BuiltinAnimationSegmentEvaluators.lerp(points[offset + 0], points[offset + 1], t)
var p12 = BuiltinAnimationSegmentEvaluators.lerp(points[offset + 1], points[offset + 2], t)
var p23 = BuiltinAnimationSegmentEvaluators.lerp(points[offset + 2], points[offset + 3], t)
var p012 = BuiltinAnimationSegmentEvaluators.lerp(p01, p12, t)
var p123 = BuiltinAnimationSegmentEvaluators.lerp(p12, p23, t)
return BuiltinAnimationSegmentEvaluators.lerp(p012, p123, t).value
}
BuiltinAnimationSegmentEvaluators.STEPPED = function (points, offset, time) {
return points[offset + 0].value
}
BuiltinAnimationSegmentEvaluators.INVERSE_STEPPED = function (points, offset, time) {
return points[offset + 1].value
}
return BuiltinAnimationSegmentEvaluators
}())
LIVE2DCUBISMFRAMEWORK.BuiltinAnimationSegmentEvaluators = BuiltinAnimationSegmentEvaluators
var AnimationSegment = (function () {
function AnimationSegment (offset, evaluate) {
this.offset = offset
this.evaluate = evaluate
}
return AnimationSegment
}())
LIVE2DCUBISMFRAMEWORK.AnimationSegment = AnimationSegment
var AnimationTrack = (function () {
function AnimationTrack (targetId, points, segments) {
this.targetId = targetId
this.points = points
this.segments = segments
}
AnimationTrack.prototype.evaluate = function (time) {
var s = 0
var lastS = this.segments.length - 1
for (; s < lastS; ++s) {
if (this.points[this.segments[s + 1].offset].time < time) {
continue
}
break
}
return this.segments[s].evaluate(this.points, this.segments[s].offset, time)
}
return AnimationTrack
}())
LIVE2DCUBISMFRAMEWORK.AnimationTrack = AnimationTrack
var Animation = (function () {
function Animation (motion3Json) {
var _this = this
this.modelTracks = []
this.parameterTracks = []
this.partOpacityTracks = []
this.userDataBodys = []
this.duration = motion3Json.Meta.Duration
this.fps = motion3Json.Meta.Fps
this.loop = motion3Json.Meta.Loop
this.userDataCount = motion3Json.Meta.UserDataCount
this.totalUserDataSize = motion3Json.Meta.TotalUserDataSize
if (motion3Json.UserData != null) {
motion3Json.UserData.forEach(function (u) {
_this.userDataBodys.push(new AnimationUserDataBody(u.Time, u.Value))
})
console.assert(this.userDataBodys.length === this.userDataCount)
}
motion3Json.Curves.forEach(function (c) {
var s = c.Segments
var points = []
var segments = []
points.push(new AnimationPoint(s[0], s[1]))
for (var t = 2; t < s.length; t += 3) {
var offset = points.length - 1
var evaluate = BuiltinAnimationSegmentEvaluators.LINEAR
var type = s[t]
if (type === 1) {
evaluate = BuiltinAnimationSegmentEvaluators.BEZIER
points.push(new AnimationPoint(s[t + 1], s[t + 2]))
points.push(new AnimationPoint(s[t + 3], s[t + 4]))
t += 4
} else if (type === 2) {
evaluate = BuiltinAnimationSegmentEvaluators.STEPPED
} else if (type === 3) {
evaluate = BuiltinAnimationSegmentEvaluators.INVERSE_STEPPED
} else if (type !== 0) {
}
points.push(new AnimationPoint(s[t + 1], s[t + 2]))
segments.push(new AnimationSegment(offset, evaluate))
}
var track = new AnimationTrack(c.Id, points, segments)
if (c.Target === 'Model') {
_this.modelTracks.push(track)
} else if (c.Target === 'Parameter') {
_this.parameterTracks.push(track)
} else if (c.Target === 'PartOpacity') {
_this.partOpacityTracks.push(track)
} else {
}
})
}
Animation.fromMotion3Json = function (motion3Json) {
if (motion3Json == null) {
return null
}
var animation = new Animation(motion3Json)
return (animation.isValid)
? animation
: null
}
Animation.prototype.addAnimationCallback = function (callbackFunc) {
if (this._callbackFunctions == null) { this._callbackFunctions = [] }
this._callbackFunctions.push(callbackFunc)
}
Animation.prototype.removeAnimationCallback = function (callbackFunc) {
if (this._callbackFunctions != null) {
var _target = -1
for (var _index = 0; _index < this._callbackFunctions.length; _index++) {
if (this._callbackFunctions[_index] === callbackFunc) {
_target = _index
break
}
}
if (_target >= 0) { this._callbackFunctions.splice(_target, 1) }
}
}
Animation.prototype.clearAnimationCallback = function () {
this._callbackFunctions = []
}
Animation.prototype.callAnimationCallback = function (value) {
if (this._callbackFunctions.length > 0) { this._callbackFunctions.forEach(function (func) { func(value) }) }
}
Animation.prototype.evaluate = function (time, weight, blend, target, stackFlags, groups) {
if (groups === undefined) { groups = null }
if (weight <= 0.01) {
return
}
if (this.loop) {
while (time > this.duration) {
time -= this.duration
}
}
this.parameterTracks.forEach(function (t) {
var p = target.parameters.ids.indexOf(t.targetId)
if (p >= 0) {
var sample = t.evaluate(time)
if (stackFlags[0][p] !== true) {
target.parameters.values[p] = target.parameters.defaultValues[p]
stackFlags[0][p] = true
}
target.parameters.values[p] = blend(target.parameters.values[p], sample, t.evaluate(0), weight)
}
})
this.partOpacityTracks.forEach(function (t) {
var p = target.parts.ids.indexOf(t.targetId)
if (p >= 0) {
var sample = t.evaluate(time)
if (stackFlags[1][p] !== true) {
target.parts.opacities[p] = 1
stackFlags[1][p] = true
}
target.parts.opacities[p] = blend(target.parts.opacities[p], sample, t.evaluate(0), weight)
}
})
this.modelTracks.forEach(function (t) {
if (groups != null) {
var g = groups.getGroupById(t.targetId)
if (g != null && g.target === 'Parameter') {
for (var _i = 0, _a = g.ids; _i < _a.length; _i++) {
var tid = _a[_i]
var p = target.parameters.ids.indexOf(tid)
if (p >= 0) {
var sample = t.evaluate(time)
if (stackFlags[0][p] !== true) {
target.parameters.values[p] = target.parameters.defaultValues[p]
stackFlags[0][p] = true
}
target.parameters.values[p] = blend(target.parameters.values[p], sample, t.evaluate(0), weight)
}
}
}
}
})
if (this._callbackFunctions != null) {
for (var _i = 0, _a = this.userDataBodys; _i < _a.length; _i++) {
var ud = _a[_i]
if (this.isEventTriggered(ud.time, time, this._lastTime, this.duration)) { this.callAnimationCallback(ud.value) }
}
}
this._lastTime = time
}
Animation.prototype.isEventTriggered = function (timeEvaluate, timeForward, timeBack, duration) {
if (timeForward > timeBack) {
if (timeEvaluate > timeBack && timeEvaluate < timeForward) { return true }
} else {
if ((timeEvaluate > 0 && timeEvaluate < timeForward) || (timeEvaluate > timeBack && timeEvaluate < duration)) { return true }
}
return false
}
Object.defineProperty(Animation.prototype, 'isValid', {
get: function () {
return true
},
enumerable: true,
configurable: true
})
return Animation
}())
LIVE2DCUBISMFRAMEWORK.Animation = Animation
var BuiltinCrossfadeWeighters = (function () {
function BuiltinCrossfadeWeighters () {
}
BuiltinCrossfadeWeighters.LINEAR = function (time, duration) {
return (time / duration)
}
return BuiltinCrossfadeWeighters
}())
LIVE2DCUBISMFRAMEWORK.BuiltinCrossfadeWeighters = BuiltinCrossfadeWeighters
var AnimationState = (function () {
function AnimationState () {
}
return AnimationState
}())
LIVE2DCUBISMFRAMEWORK.AnimationState = AnimationState
var BuiltinAnimationBlenders = (function () {
function BuiltinAnimationBlenders () {
}
BuiltinAnimationBlenders.OVERRIDE = function (source, destination, initial, weight) {
return ((destination * weight) + source * (1 - weight))
}
BuiltinAnimationBlenders.ADD = function (source, destination, initial, weight) {
return (source + ((destination - initial) * weight))
}
BuiltinAnimationBlenders.MULTIPLY = function (source, destination, weight) {
return (source * (1 + ((destination - 1) * weight)))
}
return BuiltinAnimationBlenders
}())
LIVE2DCUBISMFRAMEWORK.BuiltinAnimationBlenders = BuiltinAnimationBlenders
var AnimationLayer = (function () {
function AnimationLayer () {
this.weight = 1
}
Object.defineProperty(AnimationLayer.prototype, 'currentAnimation', {
get: function () {
return this._animation
},
enumerable: true,
configurable: true
})
Object.defineProperty(AnimationLayer.prototype, 'currentTime', {
get: function () {
return this._time
},
set: function (value) {
this._time = value
},
enumerable: true,
configurable: true
})
Object.defineProperty(AnimationLayer.prototype, 'isPlaying', {
get: function () {
return this._play
},
enumerable: true,
configurable: true
})
AnimationLayer.prototype.play = function (animation, fadeDuration) {
if (fadeDuration === undefined) { fadeDuration = 0 }
if (this._animation && fadeDuration > 0) {
this._goalAnimation = animation
this._goalTime = 0
this._fadeTime = 0
this._fadeDuration = fadeDuration
} else {
this._animation = animation
this.currentTime = 0
this._play = true
}
}
AnimationLayer.prototype.resume = function () {
this._play = true
}
AnimationLayer.prototype.pause = function () {
this._play = false
}
AnimationLayer.prototype.stop = function () {
this._play = false
this.currentTime = 0
}
AnimationLayer.prototype._update = function (deltaTime) {
if (!this._play) {
return
}
this._time += deltaTime
this._goalTime += deltaTime
this._fadeTime += deltaTime
if (this._animation == null || (!this._animation.loop && this._time > this._animation.duration)) {
this.stop()
this._animation = null
}
}
AnimationLayer.prototype._evaluate = function (target, stackFlags) {
if (this._animation == null) {
return
}
var weight = (this.weight < 1)
? this.weight
: 1
var animationWeight = (this._goalAnimation != null)
? (weight * this.weightCrossfade(this._fadeTime, this._fadeDuration))
: weight
this._animation.evaluate(this._time, animationWeight, this.blend, target, stackFlags, this.groups)
if (this._goalAnimation != null) {
animationWeight = 1 - (weight * this.weightCrossfade(this._fadeTime, this._fadeDuration))
this._goalAnimation.evaluate(this._goalTime, animationWeight, this.blend, target, stackFlags, this.groups)
if (this._fadeTime > this._fadeDuration) {
this._animation = this._goalAnimation
this._time = this._goalTime
this._goalAnimation = null
}
}
}
return AnimationLayer
}())
LIVE2DCUBISMFRAMEWORK.AnimationLayer = AnimationLayer
var Animator = (function () {
function Animator (target, timeScale, layers) {
this._target = target
this.timeScale = timeScale
this._layers = layers
}
Object.defineProperty(Animator.prototype, 'target', {
get: function () {
return this._target
},
enumerable: true,
configurable: true
})
Object.defineProperty(Animator.prototype, 'isPlaying', {
get: function () {
var ret = false
this._layers.forEach(function (l) {
if (l.isPlaying) {
ret = true
}
})
return ret
},
enumerable: true,
configurable: true
})
Animator.prototype.addLayer = function (name, blender, weight) {
if (blender === undefined) { blender = BuiltinAnimationBlenders.OVERRIDE }
if (weight === undefined) { weight = 1 }
var layer = new AnimationLayer()
layer.blend = blender
layer.weightCrossfade = BuiltinCrossfadeWeighters.LINEAR
layer.weight = weight
layer.groups = this.groups
this._layers.set(name, layer)
}
Animator.prototype.getLayer = function (name) {
return this._layers.has(name)
? this._layers.get(name)
: null
}
Animator.prototype.removeLayer = function (name) {
return this._layers.has(name)
? this._layers.delete(name)
: null
}
Animator.prototype.clearLayers = function () {
this._layers.clear()
}
Animator.prototype.updateAndEvaluate = function (deltaTime) {
var _this = this
deltaTime *= ((this.timeScale > 0)
? this.timeScale
: 0)
if (deltaTime > 0.001) {
this._layers.forEach(function (l) {
l._update(deltaTime)
})
}
var paramStackFlags = new Array(this._target.parameters.count).fill(false) // eslint-disable-line no-array-constructor
var partsStackFlags = new Array(this._target.parts.count).fill(false) // eslint-disable-line no-array-constructor
var stackFlags = new Array(paramStackFlags, partsStackFlags) // eslint-disable-line no-array-constructor
this._layers.forEach(function (l) {
l._evaluate(_this._target, stackFlags)
})
}
Animator._create = function (target, timeScale, layers) {
var animator = new Animator(target, timeScale, layers)
return animator.isValid
? animator
: null
}
Object.defineProperty(Animator.prototype, 'isValid', {
get: function () {
return this._target != null
},
enumerable: true,
configurable: true
})
return Animator
}())
LIVE2DCUBISMFRAMEWORK.Animator = Animator
var AnimatorBuilder = (function () {
function AnimatorBuilder () {
this._timeScale = 1
this._layerNames = []
this._layerBlenders = []
this._layerCrossfadeWeighters = []
this._layerWeights = []
}
AnimatorBuilder.prototype.setTarget = function (value) {
this._target = value
return this
}
AnimatorBuilder.prototype.setTimeScale = function (value) {
this._timeScale = value
return this
}
AnimatorBuilder.prototype.addLayer = function (name, blender, weight) {
if (blender === undefined) { blender = BuiltinAnimationBlenders.OVERRIDE }
if (weight === undefined) { weight = 1 }
this._layerNames.push(name)
this._layerBlenders.push(blender)
this._layerCrossfadeWeighters.push(BuiltinCrossfadeWeighters.LINEAR)
this._layerWeights.push(weight)
return this
}
AnimatorBuilder.prototype.build = function () {
var layers = new Map()
for (var l = 0; l < this._layerNames.length; ++l) {
var layer = new AnimationLayer()
layer.blend = this._layerBlenders[l]
layer.weightCrossfade = this._layerCrossfadeWeighters[l]
layer.weight = this._layerWeights[l]
layers.set(this._layerNames[l], layer)
}
return Animator._create(this._target, this._timeScale, layers)
}
return AnimatorBuilder
}())
LIVE2DCUBISMFRAMEWORK.AnimatorBuilder = AnimatorBuilder
var PhysicsVector2 = (function () {
function PhysicsVector2 (x, y) {
this.x = x
this.y = y
}
PhysicsVector2.distance = function (a, b) {
return Math.abs(a.substract(b).length)
}
PhysicsVector2.dot = function (a, b) {
return ((a.x * b.x) + (a.y * b.y))
}
Object.defineProperty(PhysicsVector2.prototype, 'length', {
get: function () {
return Math.sqrt(PhysicsVector2.dot(this, this))
},
enumerable: true,
configurable: true
})
PhysicsVector2.prototype.add = function (vector2) {
return new PhysicsVector2(this.x + vector2.x, this.y + vector2.y)
}
PhysicsVector2.prototype.substract = function (vector2) {
return new PhysicsVector2(this.x - vector2.x, this.y - vector2.y)
}
PhysicsVector2.prototype.multiply = function (vector2) {
return new PhysicsVector2(this.x * vector2.x, this.y * vector2.y)
}
PhysicsVector2.prototype.multiplyByScalar = function (scalar) {
return this.multiply(new PhysicsVector2(scalar, scalar))
}
PhysicsVector2.prototype.divide = function (vector2) {
return new PhysicsVector2(this.x / vector2.x, this.y / vector2.y)
}
PhysicsVector2.prototype.divideByScalar = function (scalar) {
return this.divide(new PhysicsVector2(scalar, scalar))
}
PhysicsVector2.prototype.rotateByRadians = function (radians) {
var x = (this.x * Math.cos(radians)) - (this.y * Math.sin(radians))
var y = (this.x * Math.sin(radians)) + (this.y * Math.cos(radians))
return new PhysicsVector2(x, y)
}
PhysicsVector2.prototype.normalize = function () {
var length = this.length
var x = this.x / length
var y = this.y / length
return new PhysicsVector2(x, y)
}
PhysicsVector2.zero = new PhysicsVector2(0, 0)
return PhysicsVector2
}())
LIVE2DCUBISMFRAMEWORK.PhysicsVector2 = PhysicsVector2
var Physics = (function () {
function Physics () {
}
Physics.clampScalar = function (scalar, lower, upper) {
if (scalar < lower) {
return lower
}
if (scalar > upper) {
return upper
}
return scalar
}
Physics.directionToDegrees = function (from, to) {
var radians = Physics.directionToRadians(from, to)
var degrees = Physics.radiansToDegrees(radians)
return ((to.x - from.x) > 0)
? -degrees
: degrees
}
Physics.radiansToDegrees = function (radians) {
return ((radians * 180) / Math.PI)
}
Physics.radiansToDirection = function (radians) {
return new PhysicsVector2(Math.sin(radians), Math.cos(radians))
}
Physics.degreesToRadians = function (degrees) {
return ((degrees / 180) * Math.PI)
}
Physics.directionToRadians = function (from, to) {
var dot = PhysicsVector2.dot(from, to)
var magnitude = from.length * to.length
if (magnitude === 0) {
return 0
}
var cosTheta = (dot / magnitude)
return (Math.abs(cosTheta) <= 1.0)
? Math.acos(cosTheta)
: 0
}
Physics.gravity = new PhysicsVector2(0, -1)
Physics.wind = new PhysicsVector2(0, 0)
Physics.maximumWeight = 100
Physics.airResistance = 5
Physics.movementThreshold = 0.001
Physics.correctAngles = true
return Physics
}())
LIVE2DCUBISMFRAMEWORK.Physics = Physics
var PhysicsParticle = (function () {
function PhysicsParticle (initialPosition, mobility, delay, acceleration, radius) {
this.initialPosition = initialPosition
this.mobility = mobility
this.delay = delay
this.acceleration = acceleration
this.radius = radius
this.position = initialPosition
this.lastPosition = this.position
this.lastGravity = new PhysicsVector2(0, -1)
this.force = new PhysicsVector2(0, 0)
this.velocity = new PhysicsVector2(0, 0)
}
return PhysicsParticle
}())
LIVE2DCUBISMFRAMEWORK.PhysicsParticle = PhysicsParticle
var PhysicsFactorTuple = (function () {
function PhysicsFactorTuple (x, y, angle) {
this.x = x
this.y = y
this.angle = angle
}
PhysicsFactorTuple.prototype.add = function (factor) {
var x = this.x + factor.x
var y = this.y + factor.y
var angle = this.angle + factor.angle
return new PhysicsFactorTuple(x, y, angle)
}
return PhysicsFactorTuple
}())
LIVE2DCUBISMFRAMEWORK.PhysicsFactorTuple = PhysicsFactorTuple
var PhysicsNormalizationTuple = (function () {
function PhysicsNormalizationTuple (minimum, maximum, def) {
this.minimum = minimum
this.maximum = maximum
this.def = def
}
return PhysicsNormalizationTuple
}())
LIVE2DCUBISMFRAMEWORK.PhysicsNormalizationTuple = PhysicsNormalizationTuple
var PhysicsNormalizationOptions = (function () {
function PhysicsNormalizationOptions (position, angle) {
this.position = position
this.angle = angle
}
return PhysicsNormalizationOptions
}())
LIVE2DCUBISMFRAMEWORK.PhysicsNormalizationOptions = PhysicsNormalizationOptions
var PhysicsInput = (function () {
function PhysicsInput (targetId, weight, factor, invert) {
this.targetId = targetId
this.weight = weight
this.factor = factor
this.invert = invert
}
Object.defineProperty(PhysicsInput.prototype, 'normalizedWeight', {
get: function () {
return Physics.clampScalar(this.weight / Physics.maximumWeight, 0, 1)
},
enumerable: true,
configurable: true
})
PhysicsInput.prototype.evaluateFactor = function (parameterValue, parameterMinimum, parameterMaximum, parameterDefault, normalization) {
console.assert(parameterMaximum > parameterMinimum)
var parameterMiddle = this.getMiddleValue(parameterMinimum, parameterMaximum)
var value = parameterValue - parameterMiddle
switch (Math.sign(value)) {
case 1:
{
const parameterRange = parameterMaximum - parameterMiddle
if (parameterRange === 0) {
value = normalization.angle.def
} else {
const normalizationRange = normalization.angle.maximum - normalization.angle.def
if (normalizationRange === 0) {
value = normalization.angle.maximum
} else {
value *= Math.abs(normalizationRange / parameterRange)
value += normalization.angle.def
}
}
}
break
case -1:
{
const parameterRange = parameterMiddle - parameterMinimum
if (parameterRange === 0) {
value = normalization.angle.def
} else {
const normalizationRange = normalization.angle.def - normalization.angle.minimum
if (normalizationRange === 0) {
value = normalization.angle.minimum
} else {
value *= Math.abs(normalizationRange / parameterRange)
value += normalization.angle.def
}
}
}
break
case 0:
value = normalization.angle.def
break
}
var weight = (this.weight / Physics.maximumWeight)
value *= (this.invert) ? 1 : -1
return new PhysicsFactorTuple(value * this.factor.x * weight, value * this.factor.y * weight, value * this.factor.angle * weight)
}
PhysicsInput.prototype.getRangeValue = function (min, max) {
var maxValue = Math.max(min, max)
var minValue = Math.min(min, max)
return Math.abs(maxValue - minValue)
}
PhysicsInput.prototype.getMiddleValue = function (min, max) {
var minValue = Math.min(min, max)
return minValue + (this.getRangeValue(min, max) / 2)
}
return PhysicsInput
}())
LIVE2DCUBISMFRAMEWORK.PhysicsInput = PhysicsInput
var PhysicsOutput = (function () {
function PhysicsOutput (targetId, particleIndex, weight, angleScale, factor, invert) {
this.targetId = targetId
this.particleIndex = particleIndex
this.weight = weight
this.factor = factor
this.invert = invert
this.factor.angle *= angleScale
}
Object.defineProperty(PhysicsOutput.prototype, 'normalizedWeight', {
get: function () {
return Physics.clampScalar(this.weight / Physics.maximumWeight, 0, 1)
},
enumerable: true,
configurable: true
})
PhysicsOutput.prototype.evaluateValue = function (translation, particles) {
var value = (translation.x * this.factor.x) + (translation.y * this.factor.y)
if (this.factor.angle > 0) {
var parentGravity = Physics.gravity
if (Physics.correctAngles && this.particleIndex > 1) {
parentGravity = particles[this.particleIndex - 2].position
.substract(particles[this.particleIndex - 1].position)
}
var angleResult = (Physics.directionToRadians(parentGravity, translation))
value += (((translation.x - parentGravity.x) > 0) ? -angleResult : angleResult) * this.factor.angle
}
value *= ((this.invert)
? -1
: 1)
return value
}
return PhysicsOutput
}())
LIVE2DCUBISMFRAMEWORK.PhysicsOutput = PhysicsOutput
var PhysicsSubRig = (function () {
function PhysicsSubRig (input, output, particles, normalization) {
this.input = input
this.output = output
this.particles = particles
this.normalization = normalization
}
PhysicsSubRig.prototype._update = function (deltaTime, target) {
var _this = this
var parameters = target.parameters
var factor = new PhysicsFactorTuple(0, 0, 0)
this.input.forEach(function (i) {
var parameterIndex = parameters.ids.indexOf(i.targetId)
if (parameterIndex === -1) {
return
}
factor = factor.add(i.evaluateFactor(parameters.values[parameterIndex], parameters.minimumValues[parameterIndex], parameters.maximumValues[parameterIndex], parameters.defaultValues[parameterIndex], _this.normalization))
})
var a = Physics.degreesToRadians(-factor.angle)
var xy = new PhysicsVector2(factor.x, factor.y).rotateByRadians(a)
factor.x = xy.x
factor.y = xy.y
var factorRadians = a
var gravityDirection = Physics
.radiansToDirection(factorRadians)
.normalize()
this.particles.forEach(function (p, i) {
if (i === 0) {
p.position = new PhysicsVector2(factor.x, factor.y)
return
}
p.force = gravityDirection.multiplyByScalar(p.acceleration).add(Physics.wind)
p.lastPosition = p.position
var delay = p.delay * deltaTime * 30
var direction = p.position.substract(_this.particles[i - 1].position)
var distance = PhysicsVector2.distance(PhysicsVector2.zero, direction)
var angle = Physics.directionToDegrees(p.lastGravity, gravityDirection)
var radians = Physics.degreesToRadians(angle) / Physics.airResistance
direction = direction
.rotateByRadians(radians)
.normalize()
p.position = _this.particles[i - 1].position.add(direction.multiplyByScalar(distance))
var velocity = p.velocity.multiplyByScalar(delay)
var force = p.force
.multiplyByScalar(delay)
.multiplyByScalar(delay)
p.position = p.position
.add(velocity)
.add(force)
var newDirection = p.position
.substract(_this.particles[i - 1].position)
.normalize()
p.position = _this.particles[i - 1].position.add(newDirection.multiplyByScalar(p.radius))
if (Math.abs(p.position.x) < Physics.movementThreshold) {
p.position.x = 0
}
if (delay !== 0) {
p.velocity = p.position
.substract(p.lastPosition)
.divideByScalar(delay)
.multiplyByScalar(p.mobility)
} else {
p.velocity = PhysicsVector2.zero
}
p.force = PhysicsVector2.zero
p.lastGravity = gravityDirection
})
}
PhysicsSubRig.prototype._evaluate = function (target) {
var _this = this
var parameters = target.parameters
this.output.forEach(function (o) {
if (o.particleIndex < 1 || o.particleIndex >= _this.particles.length) {
return
}
var parameterIndex = parameters.ids.indexOf(o.targetId)
if (parameterIndex === -1) {
return
}
var translation = _this.particles[o.particleIndex - 1].position.substract(_this.particles[o.particleIndex].position)
var value = Physics.clampScalar(o.evaluateValue(translation, _this.particles), parameters.minimumValues[parameterIndex], parameters.maximumValues[parameterIndex])
var unclampedParameterValue = (parameters.values[parameterIndex] * (1 - o.normalizedWeight)) + (value * o.normalizedWeight)
parameters.values[parameterIndex] = Physics.clampScalar(unclampedParameterValue, parameters.minimumValues[parameterIndex], parameters.maximumValues[parameterIndex])
})
}
return PhysicsSubRig
}())
LIVE2DCUBISMFRAMEWORK.PhysicsSubRig = PhysicsSubRig
var PhysicsRig = (function () {
function PhysicsRig (target, timeScale, physics3Json) {
var _this = this
this.timeScale = 1
this.timeScale = timeScale
this._target = target
if (!target) {
return
}
this._subRigs = []
physics3Json.PhysicsSettings.forEach(function (r) {
var input = []
r.Input.forEach(function (i) {
var factor = new PhysicsFactorTuple(1, 0, 0)
if (i.Type === 'Y') {
factor.x = 0
factor.y = 1
} else if (i.Type === 'Angle') {
factor.x = 0
factor.angle = 1
}
input.push(new PhysicsInput(i.Source.Id, i.Weight, factor, i.Reflect))
})
var output = []
r.Output.forEach(function (o) {
var factor = new PhysicsFactorTuple(1, 0, 0)
if (o.Type === 'Y') {
factor.x = 0
factor.y = 1
} else if (o.Type === 'Angle') {
factor.x = 0
factor.angle = 1
}
output.push(new PhysicsOutput(o.Destination.Id, o.VertexIndex, o.Weight, o.Scale, factor, o.Reflect))
})
var particles = []
r.Vertices.forEach(function (p) {
var initialPosition = new PhysicsVector2(p.Position.X, p.Position.Y)
particles.push(new PhysicsParticle(initialPosition, p.Mobility, p.Delay, p.Acceleration, p.Radius))
})
var jsonOptions = r.Normalization
var positionsOption = new PhysicsNormalizationTuple(jsonOptions.Position.Minimum, jsonOptions.Position.Maximum, jsonOptions.Position.Default)
var anglesOption = new PhysicsNormalizationTuple(jsonOptions.Angle.Minimum, jsonOptions.Angle.Maximum, jsonOptions.Angle.Default)
var normalization = new PhysicsNormalizationOptions(positionsOption, anglesOption)
_this._subRigs.push(new PhysicsSubRig(input, output, particles, normalization))
})
}
PhysicsRig.prototype.updateAndEvaluate = function (deltaTime) {
var _this = this
deltaTime *= ((this.timeScale > 0)
? this.timeScale
: 0)
if (deltaTime > 0.01) {
this._subRigs.forEach(function (r) {
r._update(deltaTime, _this._target)
})
}
this._subRigs.forEach(function (r) {
r._evaluate(_this._target)
})
}
PhysicsRig._fromPhysics3Json = function (target, timeScale, physics3Json) {
var rig = new PhysicsRig(target, timeScale, physics3Json)
return (rig._isValid)
? rig
: null
}
Object.defineProperty(PhysicsRig.prototype, '_isValid', {
get: function () {
return this._target != null
},
enumerable: true,
configurable: true
})
return PhysicsRig
}())
LIVE2DCUBISMFRAMEWORK.PhysicsRig = PhysicsRig
var PhysicsRigBuilder = (function () {
function PhysicsRigBuilder () {
this._timeScale = 1
}
PhysicsRigBuilder.prototype.setTarget = function (value) {
this._target = value
return this
}
PhysicsRigBuilder.prototype.setTimeScale = function (value) {
this._timeScale = value
return this
}
PhysicsRigBuilder.prototype.setPhysics3Json = function (value) {
this._physics3Json = value
return this
}
PhysicsRigBuilder.prototype.build = function () {
return PhysicsRig._fromPhysics3Json(this._target, this._timeScale, this._physics3Json)
}
return PhysicsRigBuilder
}())
LIVE2DCUBISMFRAMEWORK.PhysicsRigBuilder = PhysicsRigBuilder
var UserData = (function () {
function UserData (target, userData3Json) {
var _this = this
this._target = target
if (!target) {
return
}
this._version = userData3Json.Version
this._userDataCount = userData3Json.Meta.UserDataCount
this._totalUserDataSize = userData3Json.Meta.TotalUserDataSize
if (userData3Json.UserData != null) {
this._userDataBodys = []
userData3Json.UserData.forEach(function (u) {
_this._userDataBodys.push(new UserDataBody(u.Target, u.Id, u.Value))
})
console.assert(this._userDataBodys.length === this._userDataCount)
}
}
UserData._fromUserData3Json = function (target, userData3Json) {
var userdata = new UserData(target, userData3Json)
return (userdata._isValid)
? userdata
: null
}
Object.defineProperty(UserData.prototype, '_isValid', {
get: function () {
return this._target != null
},
enumerable: true,
configurable: true
})
Object.defineProperty(UserData.prototype, 'userDataCount', {
get: function () {
if (this._userDataBodys == null) { return 0 }
return this._userDataCount
},
enumerable: true,
configurable: true
})
Object.defineProperty(UserData.prototype, 'totalUserDataSize', {
get: function () {
if (this._userDataBodys == null) { return 0 }
return this._totalUserDataSize
},
enumerable: true,
configurable: true
})
Object.defineProperty(UserData.prototype, 'userDataBodys', {
get: function () {
if (this._userDataBodys == null) { return null }
return this._userDataBodys
},
enumerable: true,
configurable: true
})
UserData.prototype.isExistUserDataById = function (id_) {
if (this._userDataBodys == null) { return false }
for (var _i = 0, _a = this._userDataBodys; _i < _a.length; _i++) {
var ud = _a[_i]
if (ud.id === id_) { return true }
}
return false
}
UserData.prototype.getUserDataValueById = function (id_) {
if (this._userDataBodys == null) { return null }
for (var _i = 0, _a = this._userDataBodys; _i < _a.length; _i++) {
var ud = _a[_i]
if (ud.id === id_) { return ud.value }
}
return null
}
UserData.prototype.getUserDataTargetById = function (id_) {
if (this._userDataBodys == null) { return null }
for (var _i = 0, _a = this._userDataBodys; _i < _a.length; _i++) {
var ud = _a[_i]
if (ud.id === id_) { return ud.target }
}
return null
}
UserData.prototype.getUserDataBodyById = function (id_) {
if (this._userDataBodys == null) { return null }
for (var _i = 0, _a = this._userDataBodys; _i < _a.length; _i++) {
var ud = _a[_i]
if (ud.id === id_) { return ud }
}
return null
}
return UserData
}())
LIVE2DCUBISMFRAMEWORK.UserData = UserData
var UserDataBuilder = (function () {
function UserDataBuilder () {
}
UserDataBuilder.prototype.setTarget = function (value) {
this._target = value
return this
}
UserDataBuilder.prototype.setUserData3Json = function (value) {
this._userData3Json = value
return value
}
UserDataBuilder.prototype.build = function () {
return UserData._fromUserData3Json(this._target, this._userData3Json)
}
return UserDataBuilder
}())
LIVE2DCUBISMFRAMEWORK.UserDataBuilder = UserDataBuilder
var UserDataBody = (function () {
function UserDataBody (target, id, value) {
this.target = target
this.id = id
this.value = value
}
return UserDataBody
}())
LIVE2DCUBISMFRAMEWORK.UserDataBody = UserDataBody
var UserDataTargetType;
(function (UserDataTargetType) {
UserDataTargetType[UserDataTargetType.UNKNOWN = 0] = 'UNKNOWN'
UserDataTargetType[UserDataTargetType.ArtMesh = 1] = 'ArtMesh'
})(UserDataTargetType || (UserDataTargetType = {}))
var Groups = (function () {
function Groups (model3Json) {
var _this = this
if (typeof (model3Json.Groups) !== 'undefined') {
this._groupBodys = []
model3Json.Groups.forEach(function (u) {
_this._groupBodys.push(new GroupBody(u.Target, u.Name, u.Ids))
})
} else {
this._groupBodys = null
}
}
Object.defineProperty(Groups.prototype, 'data', {
get: function () {
if (this._groupBodys == null) { return null }
return this._groupBodys
},
enumerable: true,
configurable: true
})
Groups.fromModel3Json = function (model3Json) {
return new Groups(model3Json)
}
Groups.prototype.getGroupById = function (targetId) {
if (this._groupBodys != null) {
for (var _i = 0, _a = this._groupBodys; _i < _a.length; _i++) {
var body = _a[_i]
if (body.name === targetId) { return body }
}
}
return null
}
return Groups
}())
LIVE2DCUBISMFRAMEWORK.Groups = Groups
var GroupBody = (function () {
function GroupBody (target, name, ids) {
this.target = target
this.name = name
this.ids = ids
}
return GroupBody
}())
LIVE2DCUBISMFRAMEWORK.GroupBody = GroupBody
})(LIVE2DCUBISMFRAMEWORK || (LIVE2DCUBISMFRAMEWORK = {}))
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b }) || // eslint-disable-line no-proto
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p] } // eslint-disable-line no-prototype-builtins
return extendStatics(d, b)
}
return function (d, b) {
extendStatics(d, b)
function __ () { this.constructor = d }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __())
}
})()
var LIVE2DCUBISMPIXI;
(function (LIVE2DCUBISMPIXI) {
var Model = (function (_super) {
__extends(Model, _super)
function Model (coreModel, textures, animator, physicsRig, userData, groups) {
var _this = _super.call(this) || this
_this._coreModel = coreModel
_this._textures = textures
_this._animator = animator
_this._physicsRig = physicsRig
_this._userData = userData
_this._groups = groups
_this._animator.groups = _this._groups
if (_this._coreModel == null) {
return _this
}
_this._meshes = new Array(_this._coreModel.drawables.ids.length)
for (var m = 0; m < _this._meshes.length; ++m) {
var uvs = _this._coreModel.drawables.vertexUvs[m].slice(0, _this._coreModel.drawables.vertexUvs[m].length)
for (var v = 1; v < uvs.length; v += 2) {
uvs[v] = 1 - uvs[v]
}
_this._meshes[m] = new CubismMesh(textures[_this._coreModel.drawables.textureIndices[m]], _this._coreModel.drawables.vertexPositions[m], uvs, _this._coreModel.drawables.indices[m], PIXI.DRAW_MODES.TRIANGLES)
_this._meshes[m].name = _this._coreModel.drawables.ids[m]
_this._meshes[m].scale.y *= -1
_this._meshes[m].isCulling = !Live2DCubismCore.Utils.hasIsDoubleSidedBit(_this._coreModel.drawables.constantFlags[m])
if (Live2DCubismCore.Utils.hasBlendAdditiveBit(_this._coreModel.drawables.constantFlags[m])) {
if (_this._coreModel.drawables.maskCounts[m] > 0) {
var addFilter = new PIXI.Filter()
addFilter.blendMode = PIXI.BLEND_MODES.ADD
_this._meshes[m].filters = [addFilter]
} else {
_this._meshes[m].blendMode = PIXI.BLEND_MODES.ADD
}
} else if (Live2DCubismCore.Utils.hasBlendMultiplicativeBit(_this._coreModel.drawables.constantFlags[m])) {
if (_this._coreModel.drawables.maskCounts[m] > 0) {
var multiplyFilter = new PIXI.Filter()
multiplyFilter.blendMode = PIXI.BLEND_MODES.MULTIPLY
_this._meshes[m].filters = [multiplyFilter]
} else {
_this._meshes[m].blendMode = PIXI.BLEND_MODES.MULTIPLY
}
}
_this.addChild(_this._meshes[m])
}
;
_this._maskSpriteContainer = new MaskSpriteContainer(coreModel, _this)
return _this
}
Object.defineProperty(Model.prototype, 'parameters', {
get: function () {
return this._coreModel.parameters
},
enumerable: true,
configurable: true
})
Object.defineProperty(Model.prototype, 'parts', {
get: function () {
return this._coreModel.parts
},
enumerable: true,
configurable: true
})
Object.defineProperty(Model.prototype, 'drawables', {
get: function () {
return this._coreModel.drawables
},
enumerable: true,
configurable: true
})
Object.defineProperty(Model.prototype, 'canvasinfo', {
get: function () {
return this._coreModel.canvasinfo
},
enumerable: true,
configurable: true
})
Object.defineProperty(Model.prototype, 'textures', {
get: function () {
return this._textures
},
enumerable: true,
configurable: true
})
Object.defineProperty(Model.prototype, 'animator', {
get: function () {
return this._animator
},
enumerable: true,
configurable: true
})
Object.defineProperty(Model.prototype, 'userData', {
get: function () {
return this._userData
},
enumerable: true,
configurable: true
})
Object.defineProperty(Model.prototype, 'meshes', {
get: function () {
return this._meshes
},
enumerable: true,
configurable: true
})
Object.defineProperty(Model.prototype, 'masks', {
get: function () {
return this._maskSpriteContainer
},
enumerable: true,
configurable: true
})
Object.defineProperty(Model.prototype, 'groups', {
get: function () {
return this._groups
},
enumerable: true,
configurable: true
})
Model.prototype.update = function (delta) {
var _this = this
var deltaTime = 0.016 * delta
this._animator.updateAndEvaluate(deltaTime)
if (this._physicsRig) {
this._physicsRig.updateAndEvaluate(deltaTime)
}
this._coreModel.update()
var sort = false
for (var m = 0; m < this._meshes.length; ++m) {
this._meshes[m].alpha = this._coreModel.drawables.opacities[m]
this._meshes[m].visible = Live2DCubismCore.Utils.hasIsVisibleBit(this._coreModel.drawables.dynamicFlags[m])
if (Live2DCubismCore.Utils.hasVertexPositionsDidChangeBit(this._coreModel.drawables.dynamicFlags[m])) {
this._meshes[m].vertices = this._coreModel.drawables.vertexPositions[m]
this._meshes[m].dirtyVertex = true
}
if (Live2DCubismCore.Utils.hasRenderOrderDidChangeBit(this._coreModel.drawables.dynamicFlags[m])) {
sort = true
}
}
if (sort) {
this.children.sort(function (a, b) {
var aIndex = _this._meshes.indexOf(a)
var bIndex = _this._meshes.indexOf(b)
var aRenderOrder = _this._coreModel.drawables.renderOrders[aIndex]
var bRenderOrder = _this._coreModel.drawables.renderOrders[bIndex]
return aRenderOrder - bRenderOrder
})
}
this._coreModel.drawables.resetDynamicFlags()
}
Model.prototype.destroy = function (options) {
if (this._coreModel !== null) {
this._coreModel.release()
}
_super.prototype.destroy.call(this, options)
this.masks.destroy()
this._meshes.forEach(function (m) {
m.destroy()
})
if (options === true || options.texture) {
this._textures.forEach(function (t) {
t.destroy()
})
}
}
Model.prototype.getModelMeshById = function (id) {
if (this._meshes == null) { return null }
for (var _i = 0, _a = this._meshes; _i < _a.length; _i++) {
var mesh = _a[_i]
if (mesh.name === id) { return mesh }
}
return null
}
Model.prototype.addParameterValueById = function (id, value) {
var p = this._coreModel.parameters.ids.indexOf(id)
if (p === -1) {
return
}
this._coreModel.parameters.values[p] = this._coreModel.parameters.values[p] + value
}
Model._create = function (coreModel, textures, animator, physicsRig, userData, groups) {
if (physicsRig === undefined) { physicsRig = null }
if (userData === undefined) { userData = null }
if (groups === undefined) { groups = null }
var model = new Model(coreModel, textures, animator, physicsRig, userData, groups)
if (!model.isValid) {
model.destroy()
return null
}
return model
}
Object.defineProperty(Model.prototype, 'isValid', {
get: function () {
return this._coreModel != null
},
enumerable: true,
configurable: true
})
return Model
}(PIXI.Container))
LIVE2DCUBISMPIXI.Model = Model
var MaskSpriteContainer = (function (_super) {
__extends(MaskSpriteContainer, _super)
function MaskSpriteContainer (coreModel, pixiModel) {
var _this = _super.call(this) || this
_this._maskShaderVertSrc = '\n attribute vec2 aVertexPosition;\n attribute vec2 aTextureCoord;\n uniform mat3 projectionMatrix;\n varying vec2 vTextureCoord;\n void main(void){\n gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);\n vTextureCoord = aTextureCoord;\n }\n '
_this._maskShaderFragSrc = '\n varying vec2 vTextureCoord;\n uniform sampler2D uSampler;\n void main(void){\n vec4 c = texture2D(uSampler, vTextureCoord);\n c.r = c.a;\n c.g = 0.0;\n c.b = 0.0;\n gl_FragColor = c;\n }\n '
_this._maskShader = new PIXI.Filter(_this._maskShaderVertSrc.toString(), _this._maskShaderFragSrc.toString())
var _maskCounts = coreModel.drawables.maskCounts
var _maskRelationList = coreModel.drawables.masks
_this._maskMeshContainers = []
_this._maskTextures = []
_this._maskSprites = []
for (var m = 0; m < pixiModel.meshes.length; ++m) {
if (_maskCounts[m] > 0) {
var newContainer = new PIXI.Container()
for (var n = 0; n < _maskRelationList[m].length; ++n) {
var meshMaskID = coreModel.drawables.masks[m][n]
var maskMesh = new CubismMesh(pixiModel.meshes[meshMaskID].texture, pixiModel.meshes[meshMaskID].vertices, pixiModel.meshes[meshMaskID].uvs, pixiModel.meshes[meshMaskID].indices, PIXI.DRAW_MODES.TRIANGLES)
maskMesh.name = pixiModel.meshes[meshMaskID].name
maskMesh.transform = pixiModel.meshes[meshMaskID].transform
maskMesh.worldTransform = pixiModel.meshes[meshMaskID].worldTransform
maskMesh.localTransform = pixiModel.meshes[meshMaskID].localTransform
maskMesh.isCulling = pixiModel.meshes[meshMaskID].isCulling
maskMesh.isMaskMesh = true
maskMesh.filters = [_this._maskShader]
newContainer.addChild(maskMesh)
}
newContainer.transform = pixiModel.transform
newContainer.worldTransform = pixiModel.worldTransform
newContainer.localTransform = pixiModel.localTransform
_this._maskMeshContainers.push(newContainer)
var newTexture = PIXI.RenderTexture.create(0, 0)
_this._maskTextures.push(newTexture)
var newSprite = new PIXI.Sprite(newTexture)
_this._maskSprites.push(newSprite)
_this.addChild(newSprite)
pixiModel.meshes[m].mask = newSprite
}
}
return _this
}
Object.defineProperty(MaskSpriteContainer.prototype, 'maskSprites', {
get: function () {
return this._maskSprites
},
enumerable: true,
configurable: true
})
Object.defineProperty(MaskSpriteContainer.prototype, 'maskMeshes', {
get: function () {
return this._maskMeshContainers
},
enumerable: true,
configurable: true
})
MaskSpriteContainer.prototype.destroy = function (options) {
this._maskSprites.forEach(function (m) {
m.destroy()
})
this._maskTextures.forEach(function (m) {
m.destroy()
})
this._maskMeshContainers.forEach(function (m) {
m.destroy()
})
this._maskShader = null
}
MaskSpriteContainer.prototype.update = function (appRenderer) {
for (var m = 0; m < this._maskSprites.length; ++m) {
appRenderer.render(this._maskMeshContainers[m], this._maskTextures[m], true, null, false)
}
}
MaskSpriteContainer.prototype.resize = function (viewWidth, viewHeight) {
for (var m = 0; m < this._maskTextures.length; ++m) {
this._maskTextures[m].resize(viewWidth, viewHeight, false)
}
}
return MaskSpriteContainer
}(PIXI.Container))
LIVE2DCUBISMPIXI.MaskSpriteContainer = MaskSpriteContainer
var ModelBuilder = (function () {
function ModelBuilder () {
this._textures = []
this._timeScale = 1
this._animatorBuilder = new LIVE2DCUBISMFRAMEWORK.AnimatorBuilder()
}
ModelBuilder.prototype.setMoc = function (value) {
this._moc = value
return this
}
ModelBuilder.prototype.setTimeScale = function (value) {
this._timeScale = value
return this
}
ModelBuilder.prototype.setPhysics3Json = function (value) {
if (!this._physicsRigBuilder) {
this._physicsRigBuilder = new LIVE2DCUBISMFRAMEWORK.PhysicsRigBuilder()
}
this._physicsRigBuilder.setPhysics3Json(value)
return this
}
ModelBuilder.prototype.setUserData3Json = function (value) {
if (!this._userDataBuilder) {
this._userDataBuilder = new LIVE2DCUBISMFRAMEWORK.UserDataBuilder()
}
this._userDataBuilder.setUserData3Json(value)
return this
}
ModelBuilder.prototype.addTexture = function (index, texture) {
this._textures.splice(index, 0, texture)
return this
}
ModelBuilder.prototype.addAnimatorLayer = function (name, blender, weight) {
if (blender === undefined) { blender = LIVE2DCUBISMFRAMEWORK.BuiltinAnimationBlenders.OVERRIDE }
if (weight === undefined) { weight = 1 }
this._animatorBuilder.addLayer(name, blender, weight)
return this
}
ModelBuilder.prototype.addGroups = function (groups) {
this._groups = groups
return this
}
ModelBuilder.prototype.buildFromModel3Json = function (loader, model3Obj, callbackFunc) {
var _this = this
var model3URL = model3Obj.url
var modelDir = model3URL.substring(0, model3URL.lastIndexOf('/') + 1)
var textureCount = 0
if (typeof (model3Obj.data.FileReferences.Moc) !== 'undefined') { loader.add('moc', modelDir + model3Obj.data.FileReferences.Moc, { xhrType: PIXI.loaders.Resource.XHR_RESPONSE_TYPE.BUFFER }) }
if (typeof (model3Obj.data.FileReferences.Textures) !== 'undefined') {
model3Obj.data.FileReferences.Textures.forEach(function (element) {
loader.add('texture' + textureCount, modelDir + element)
textureCount++
})
}
if (typeof (model3Obj.data.FileReferences.Physics) !== 'undefined') { loader.add('physics', modelDir + model3Obj.data.FileReferences.Physics, { xhrType: PIXI.loaders.Resource.XHR_RESPONSE_TYPE.JSON }) }
if (typeof (model3Obj.data.FileReferences.UserData) !== 'undefined') { loader.add('userdata', modelDir + model3Obj.data.FileReferences.UserData, { xhrType: PIXI.loaders.Resource.XHR_RESPONSE_TYPE.JSON }) }
if (typeof (model3Obj.data.Groups) !== 'undefined') { this._groups = LIVE2DCUBISMFRAMEWORK.Groups.fromModel3Json(model3Obj.data) }
loader.load(function (loader, resources) {
if (typeof (resources.moc) !== 'undefined') { _this.setMoc(Live2DCubismCore.Moc.fromArrayBuffer(resources.moc.data)) }
if (typeof (resources['texture' + 0]) !== 'undefined') {
for (var i = 0; i < textureCount; i++) { _this.addTexture(i, resources['texture' + i].texture) }
}
if (typeof (resources.physics) !== 'undefined') { _this.setPhysics3Json(resources.physics.data) }
if (typeof (resources.userdata) !== 'undefined') { _this.setUserData3Json(resources.userdata.data) }
var model = _this.build()
callbackFunc(model)
})
}
ModelBuilder.prototype.build = function () {
var coreModel = Live2DCubismCore.Model.fromMoc(this._moc)
if (coreModel == null) {
return null
}
var animator = this._animatorBuilder
.setTarget(coreModel)
.setTimeScale(this._timeScale)
.build()
var physicsRig = null
if (this._physicsRigBuilder) {
physicsRig = this._physicsRigBuilder
.setTarget(coreModel)
.setTimeScale(this._timeScale)
.build()
}
var userData = null
if (this._userDataBuilder) {
userData = this._userDataBuilder
.setTarget(coreModel)
.build()
}
return Model._create(coreModel, this._textures, animator, physicsRig, userData, this._groups)
}
return ModelBuilder
}())
LIVE2DCUBISMPIXI.ModelBuilder = ModelBuilder
var CubismMesh = (function (_super) {
__extends(CubismMesh, _super)
function CubismMesh () {
var _this = (_super !== null && _super.apply(this, arguments)) || this
_this.isCulling = false
_this.isMaskMesh = false
return _this
}
CubismMesh.prototype._renderWebGL = function (renderer) {
if (this.isMaskMesh === true) { renderer.state.setFrontFace(1) } else { renderer.state.setFrontFace(0) }
if (this.isCulling === true) { renderer.state.setCullFace(1) } else { renderer.state.setCullFace(0) }
_super.prototype._renderWebGL.call(this, renderer)
renderer.state.setFrontFace(0)
}
return CubismMesh
}(PIXI.mesh.Mesh))
LIVE2DCUBISMPIXI.CubismMesh = CubismMesh
})(LIVE2DCUBISMPIXI || (LIVE2DCUBISMPIXI = {}))
class L2D {
constructor (basePath) {
this.basePath = basePath
this.loader = new PIXI.loaders.Loader(this.basePath)
this.animatorBuilder = new LIVE2DCUBISMFRAMEWORK.AnimatorBuilder()
this.timeScale = 1
this.models = {}
}
setPhysics3Json (value) {
if (!this.physicsRigBuilder) {
this.physicsRigBuilder = new LIVE2DCUBISMFRAMEWORK.PhysicsRigBuilder()
}
this.physicsRigBuilder.setPhysics3Json(value)
return this
}
load (name, v) {
if (!this.models[name]) {
const modelDir = name + '/'
const modelPath = name + '.model3.json'
const textures = []
let textureCount = 0
const motionNames = []
const modelNames = []
// if (!modelNames.includes(name+'_model')){
this.loader.add(name + '_model', modelDir + modelPath, { xhrType: PIXI.loaders.Resource.XHR_RESPONSE_TYPE.JSON })
modelNames.push(name + '_model')
// }
this.loader.load((loader, resources) => {
const model3Obj = resources[name + '_model'].data
if (typeof (model3Obj.FileReferences.Moc) !== 'undefined') {
loader.add(name + '_moc', modelDir + model3Obj.FileReferences.Moc, { xhrType: PIXI.loaders.Resource.XHR_RESPONSE_TYPE.BUFFER })
}
if (typeof (model3Obj.FileReferences.Textures) !== 'undefined') {
model3Obj.FileReferences.Textures.forEach((element) => {
loader.add(name + '_texture' + textureCount, modelDir + element)
textureCount++
})
}
if (typeof (model3Obj.FileReferences.Physics) !== 'undefined') {
loader.add(name + '_physics', modelDir + model3Obj.FileReferences.Physics, { xhrType: PIXI.loaders.Resource.XHR_RESPONSE_TYPE.JSON })
}
if (typeof (model3Obj.FileReferences.Motions) !== 'undefined') {
for (const group in model3Obj.FileReferences.Motions) {
model3Obj.FileReferences.Motions[group].forEach((element) => {
const motionName = element.File.split('/').pop().split('.').shift()
if (!motionNames.includes(name + '_' + motionName)) {
loader.add(name + '_' + motionName, modelDir + element.File, { xhrType: PIXI.loaders.Resource.XHR_RESPONSE_TYPE.JSON })
motionNames.push(name + '_' + motionName)
} else {
var n = name + '_' + motionName + String(Date.now())
loader.add(n, modelDir + element.File, { xhrType: PIXI.loaders.Resource.XHR_RESPONSE_TYPE.JSON })
motionNames.push(name + '_' + motionName)
}
})
}
}
let groups = null
if (typeof (model3Obj.Groups) !== 'undefined') {
groups = LIVE2DCUBISMFRAMEWORK.Groups.fromModel3Json(model3Obj)
}
loader.load((l, r) => {
let moc = null
if (typeof (r[name + '_moc']) !== 'undefined') {
moc = Live2DCubismCore.Moc.fromArrayBuffer(r[name + '_moc'].data)
}
if (typeof (r[name + '_texture' + 0]) !== 'undefined') {
for (let i = 0; i < textureCount; i++) {
textures.splice(i, 0, r[name + '_texture' + i].texture)
}
}
if (typeof (r[name + '_physics']) !== 'undefined') {
this.setPhysics3Json(r[name + '_physics'].data)
}
const motions = new Map()
motionNames.forEach((element) => {
const n = element.split(name + '_').pop()
motions.set(n, LIVE2DCUBISMFRAMEWORK.Animation.fromMotion3Json(r[element].data))
})
let model = null
const coreModel = Live2DCubismCore.Model.fromMoc(moc)
if (coreModel == null) {
return
}
const animator = this.animatorBuilder
.setTarget(coreModel)
.setTimeScale(this.timeScale)
.build()
const physicsRig = this.physicsRigBuilder
.setTarget(coreModel)
.setTimeScale(this.timeScale)
.build()
const userData = null
model = LIVE2DCUBISMPIXI.Model._create(coreModel, textures, animator, physicsRig, userData, groups)
model.motions = motions
this.models[name] = model
v.changeCanvas(model)
})
})
} else {
v.changeCanvas(this.models[name])
}
}
}
class Live2dV3 { // eslint-disable-line no-unused-vars
constructor ({ basePath, modelName, width = 500, height = 300, el, sizeLimit, mobileLimit, sounds }) {
if (typeof Live2DCubismCore === 'undefined') {
console.error('live2dv3 failed to load:\nMissing live2dcubismcore.js\nPlease add "https://cdn.jsdelivr.net/gh/HCLonely/Live2dV3/js/live2dcubismcore.min.js" to the "<script>" tag.\nLook at https://github.com/HCLonely/Live2dV3')
return
}
if (typeof PIXI === 'undefined') {
console.error('live2dv3 failed to load:\nMissing pixi.js\nPlease add "https://cdn.jsdelivr.net/npm/pixi.js@4.6.1/dist/pixi.min.js" to the "<script>" tag.\nLook at https://github.com/HCLonely/Live2dV3')
return
}
if (!el) {
console.error('"el" parameter is required')
return
}
if (!this.isDom(el)) {
if (el.length > 0) {
if (this.isDom(el[0])) {
el = el[0]
} else {
console.error('live2dv3 failed to load:\n', el[0], 'is not a HTMLElement object')
return
}
} else {
console.error('live2dv3 failed to load:\n', el, 'is not a HTMLElement object')
return
}
}
if (sizeLimit && (document.documentElement.clientWidth < width || document.documentElement.clientHeight < height)) return
if (mobileLimit && /Mobile|Mac OS|Android|iPhone|iPad/i.test(navigator.userAgent)) return
window.console.log('Live2dV3: loading model "' + modelName + '"')
this.l2d = new L2D(basePath)
this.canvas = el
if (modelName) {
this.modelName = modelName
this.l2d.load(modelName, this)
}
this.app = new PIXI.Application(width, height, { transparent: true })
this.canvas.appendChild(this.app.view)
this.app.ticker.add((deltaTime) => {
if (!this.model) {
return
}
this.model.update(deltaTime)
this.model.masks.update(this.app.renderer)
})
window.onresize = (event) => {
if (event === undefined) { event = null }
this.app.view.style.width = width + 'px'
this.app.view.style.height = height + 'px'
this.app.renderer.resize(width, height)
if (this.model) {
this.model.position = new PIXI.Point((width * 0.5), (height * 0.5))
this.model.scale = new PIXI.Point((this.model.position.x * 0.06), (this.model.position.x * 0.06))
this.model.masks.resize(this.app.view.width, this.app.view.height)
}
}
this.isClick = false
this.app.view.addEventListener('mousedown', (event) => {
this.isClick = true
})
this.app.view.addEventListener('mousemove', (event) => {
if (this.isClick) {
this.isClick = false
if (this.model) {
this.model.inDrag = true
}
}
if (this.model) {
const mouseX = this.model.position.x - event.offsetX
const mouseY = this.model.position.y - event.offsetY
this.model.pointerX = -mouseX / this.app.view.height
this.model.pointerY = -mouseY / this.app.view.width
}
})
this.app.view.addEventListener('mouseup', (event) => {
if (!this.model) {
return
}
if (this.isClick) {
if (this.isHit('TouchHead', event.offsetX, event.offsetY)) {
this.startAnimation('touch_head', 'base')
} else if (this.isHit('TouchSpecial', event.offsetX, event.offsetY)) {
this.startAnimation('touch_special', 'base')
} else {
const bodyMotions = ['touch_body', 'main_1', 'main_2', 'main_3']
const currentMotion = bodyMotions[Math.floor(Math.random() * bodyMotions.length)]
this.startAnimation(currentMotion, 'base')
}
if (sounds && sounds.length > 0) {
const soundFile = sounds[Math.floor((Math.random() * sounds.length))]
const filePath = /^https?:\/\//.test(soundFile) ? soundFile : [basePath, modelName, soundFile].join('/').replace(/(?<!:)\/\//g, '/')
if (typeof Howl !== 'undefined') {
new Howl({ src: [filePath] }).play()
} else if (typeof Audio !== 'undefined') {
new Audio(filePath).play()
} else {
console.error('Current browser does not support playing sound.')
}
}
}
this.isClick = false
this.model.inDrag = false
})
}
changeCanvas (model) {
this.app.stage.removeChildren()
this.model = model
this.model.update = this.onUpdate
this.model.animator.addLayer('base', LIVE2DCUBISMFRAMEWORK.BuiltinAnimationBlenders.OVERRIDE, 1)
this.app.stage.addChild(this.model)
this.app.stage.addChild(this.model.masks)
window.onresize()
}
onUpdate (delta) {
const deltaTime = 0.016 * delta
if (!this.animator.isPlaying) {
const m = this.motions.get('idle')
this.animator.getLayer('base').play(m)
}
this._animator.updateAndEvaluate(deltaTime)
if (this.inDrag) {
this.addParameterValueById('ParamAngleX', this.pointerX * 30)
this.addParameterValueById('ParamAngleY', -this.pointerY * 30)
this.addParameterValueById('ParamBodyAngleX', this.pointerX * 10)
this.addParameterValueById('ParamBodyAngleY', -this.pointerY * 10)
this.addParameterValueById('ParamEyeBallX', this.pointerX)
this.addParameterValueById('ParamEyeBallY', -this.pointerY)
}
if (this._physicsRig) {
this._physicsRig.updateAndEvaluate(deltaTime)
}
this._coreModel.update()
let sort = false
for (let m = 0; m < this._meshes.length; ++m) {
this._meshes[m].alpha = this._coreModel.drawables.opacities[m]
this._meshes[m].visible = Live2DCubismCore.Utils.hasIsVisibleBit(this._coreModel.drawables.dynamicFlags[m])
if (Live2DCubismCore.Utils.hasVertexPositionsDidChangeBit(this._coreModel.drawables.dynamicFlags[m])) {
this._meshes[m].vertices = this._coreModel.drawables.vertexPositions[m]
this._meshes[m].dirtyVertex = true
}
if (Live2DCubismCore.Utils.hasRenderOrderDidChangeBit(this._coreModel.drawables.dynamicFlags[m])) {
sort = true
}
}
if (sort) {
this.children.sort((a, b) => {
const aIndex = this._meshes.indexOf(a)
const bIndex = this._meshes.indexOf(b)
const aRenderOrder = this._coreModel.drawables.renderOrders[aIndex]
const bRenderOrder = this._coreModel.drawables.renderOrders[bIndex]
return aRenderOrder - bRenderOrder
})
}
this._coreModel.drawables.resetDynamicFlags()
}
startAnimation (motionId, layerId) {
if (!this.model) {
return
}
const m = this.model.motions.get(motionId)
if (!m) {
return
}
const l = this.model.animator.getLayer(layerId)
if (!l) {
return
}
l.play(m)
}
isHit (id, posX, posY) {
if (!this.model) {
return false
}
const m = this.model.getModelMeshById(id)
if (!m) {
return false
}
const vertexOffset = 0
const vertexStep = 2
const vertices = m.vertices
let left = vertices[0]
let right = vertices[0]
let top = vertices[1]
let bottom = vertices[1]
for (let i = 1; i < 4; ++i) {
const x = vertices[vertexOffset + i * vertexStep]
const y = vertices[vertexOffset + i * vertexStep + 1]
if (x < left) {
left = x
}
if (x > right) {
right = x
}
if (y < top) {
top = y
}
if (y > bottom) {
bottom = y
}
}
const mouseX = m.worldTransform.tx - posX
const mouseY = m.worldTransform.ty - posY
const tx = -mouseX / m.worldTransform.a
const ty = -mouseY / m.worldTransform.d
return ((left <= tx) && (tx <= right) && (top <= ty) && (ty <= bottom))
}
isDom (e) {
if (typeof HTMLElement === 'object') {
return e instanceof HTMLElement
} else {
return e && typeof e === 'object' && e.nodeType === 1 && typeof e.nodeName === 'string'
}
}
loadModel (modelName) {
this.l2d.load(modelName || this.modelName, this)
}
}
const VERSION = '1.2.2'
let _a
if (navigator.userAgent.toLowerCase().indexOf('chrome') > -1) {
const args = [
'\n\n %c %c %c \u2730 Live2dV3 ' + VERSION + ' \u2730 %c \n%c https://github.com/HCLonely/Live2dV3 %c\n\n',
'background: #ff66a5; padding:5px 0;',
'background: #ff66a5; padding:5px 0;',
'color: #ff66a5; background: #030307; padding:5px 0;',
'background: #ff66a5; padding:5px 0;',
'background: #ffc3dc; padding:5px 0;',
'background: #ff66a5; padding:5px 0;'];
(_a = window.console).log.apply(_a, args)
} else if (window.console) {
window.console.log('Live2dV3 ' + VERSION + ' - https://github.com/HCLonely/Live2dV3')
}
window.l2dViewer = function (options) {
return new Live2dV3(options)
}
})()