avatarViewer.js

'use strict';
define('avatarControl', [], function () {
    return window.AVATAR;
});

define('avatarViewer', ['jquery', 'avatarControl', 'avatarViewer.prerequisites'], function ($, avatarControl, prerequisites) {
    var avatarCanvas = $('.AvatarCanvas')[0],
        currentEquippingAsset = null,
        canEquipAsset = false;
    if (window.location.protocol == 'https:') {
        avatarControl.SetAssetsUrlRoot("https://download-ssl.xboxlive.com/");
    } else {
        avatarControl.SetAssetsUrlRoot("http://download.xboxlive.com/");
    }

    $('.zoomToBody').click(function () {
        avatarControl.ZoomToPreset(0);
    });

    $('.zoomToHead').click(function () {
        avatarControl.ZoomToPreset(1);
    });

    $('.zoomToUpper').click(function () {
        avatarControl.ZoomToPreset(2);
    });

    $('.zoomToLower').click(function () {
        avatarControl.ZoomToPreset(3);
    });

    function setLoading(isLoading) {
        $('.LoadingAvatarContainer').toggle(isLoading);
    }

    function handleAvatarLoaded() {
        if (window.onAvatarLoadingFinished) {
            window.onAvatarLoadingFinished();
        }
    }

    function handleGenderMismatchError() {
        if (window.onAvatarGenderMismatch) {
            window.onAvatarGenderMismatch();
        }
    }

    function handleUserWithNoAvatar() {
        if (window.onUserWithNoAvatar) {
            window.onUserWithNoAvatar();
        }
    }

    function handleLoadAvatarError() {
        if (window.onAvatarEditorGenericError) {
            window.onAvatarEditorGenericError(prerequisites.strings.loadAvatarError);
        }
    }

    function handleEquipAssetError() {
        if (window.onAvatarEditorGenericError) {
            window.onAvatarEditorGenericError(prerequisites.strings.equipAssetError);
        }
    }

    function equip(assetId) {
        var deferred = $.Deferred();

        $(avatarCanvas).show();
        setLoading(true);

        if (!canEquipAsset || currentEquippingAsset === assetId) {
            return deferred.reject();
        } else {
            currentEquippingAsset = assetId;
            avatarControl.EquipAsset(assetId).always(function () {
                currentEquippingAsset = null;
                setLoading(false);
            }).done(function () {
                deferred.resolve();
            }).fail(function (err) {
                switch (err.errorType) {
                    case 'GenderMismatchError':
                        handleGenderMismatchError();
                        break;
                    default:
                        handleEquipAssetError();
                        break;
                }
                deferred.reject(err);
            });
        }
        return deferred.promise();
    }

    function initialize(event, assetId) {
        var deferred = $.Deferred();
        prerequisites.getManifest().then(function (avatarManifest) {
            if (!avatarManifest) {
                handleUserWithNoAvatar();
                deferred.reject();
            }

            setLoading(true);
            var presetAsset = assetId || prerequisites.asset;
            if (presetAsset) {
                avatarControl.LoadManifest(avatarManifest, avatarCanvas);
                canEquipAsset = true;
                equip(presetAsset).done(function () {
                    handleAvatarLoaded();
                    deferred.resolve();
                }).fail(function (err) {
                    deferred.reject(err);
                });
            } else {
                avatarControl.LoadAvatar(avatarManifest, avatarCanvas).done(function () {
                    canEquipAsset = true;
                    handleAvatarLoaded();
                    setLoading(false);
                    deferred.resolve();
                }).fail(function (err) {
                    switch (err.errorType) {
                        case 'BabylonNotSupportedError':
                        case 'BodyMergeError':
                        case 'HeadMergeError':
                        case 'ImportMeshError':
                        case 'ShadersError':
                        default:
                            handleLoadAvatarError();
                            break;
                    }
                    $(avatarCanvas).hide();
                    deferred.reject(err);
                });
            }
        }).fail(function () {
            handleUserWithNoAvatar();
            deferred.reject();
        });

        return deferred.promise();
    }

    return {
        initialize: initialize,
        equip: equip
    }
});