Gecko [ dp-client.com ]

Name	Size	Permission
.pkexec	[ DIR ]	drwxr-xr-x
3D	[ DIR ]	drwxr-xr-x
GCONV_PATH=.	[ DIR ]	drwxr-xr-x
assets	[ DIR ]	drwxr-xr-x
nbproject	[ DIR ]	drwxr-xr-x
.mad-root	0 B	-rw-r--r--
GLTFLoader.js	40.04 KB	-rw-r--r--
OrbitControls.js	10.7 KB	-rw-r--r--
base-3d.js	74.12 KB	-rw-r--r--
display-3d.js	18.33 KB	-rw-r--r--
index.php	1.91 KB	-rw-r--r--
pwnkit	10.99 KB	-rwxr-xr-x
suit3pcs.js	8.34 KB	-rw-r--r--
sz-utils.js	15.37 KB	-rw-r--r--
sz.js	11.99 KB	-rw-r--r--

Code Editor : display-3d.js

Sz.packages(function (Sz) {

Sz.add("Display3D", function (Datastore, Utility, Display3D) {

Sz.extend(Datastore, {
            Models: [],
            Params: [],
            loaded: [],
            render: null,
            refid: null,
            preview: null,
            history: [],
            products: {
                Suit: ["Jacket", "Pant"],
                Suit3pcs: ["Jacket", "Pant", "Vest"]
            },
            savedState: {},
            progress: {
                id: null,
                bar: null,
                values: {}
            }
        });

Display3D.setPreview = function (value) {
            return (Datastore.preview = value);
        };

Display3D.getPreview = function () {
            return Datastore.preview;
        };

Display3D.setState = function (Base3D, options) {
            var settings, results;

settings = {
                name: null,
                multiplyScalar: 1,
                polarAngle: null,
                azimuthAngle: null
            };

Sz.extend(settings, options);

results = {
                Spherical: {
                    from: new Base3D.Libs.Spherical(),
                    to: new Base3D.Libs.Spherical()
                },
                axis: new Base3D.Libs.Vector3(),
                name: settings.name
            };

Base3D.getState(function (state, spherical) {

Sz.extend(results, state);

results.Spherical.from.setFromVector3(Base3D.Camera.position);
                results.Spherical.to.setFromVector3(Base3D.Camera.position);

if (Sz.isObject(options)) {

spherical.radius *= settings.multiplyScalar;

if (Sz.isNumeric(settings.polarAngle)) {
                        spherical.phi = settings.polarAngle;
                    }

if (Sz.isNumeric(settings.azimuthAngle)) {
                        spherical.theta = settings.azimuthAngle;
                    }

results.Spherical.to.copy(spherical);
                }
            });

if (Sz.isNot(results.name, Sz.isString)) {
                results.name = Display3D.getStateName();
            }

Datastore.savedState[results.name] = results;

return Display3D.getState(results.name);
        };

Display3D.getState = function (name) {

if (Sz.isNot(name, Sz.isString)) {
                name = Display3D.getStateName();
            }

return Object.assign({}, Datastore.savedState[name]);
        };

Display3D.getStateName = function () {
            var preview, stateName, nav;

preview = Display3D.getPreview();

Sz.each(Datastore.products, function (name, group) {

var matched = Sz.inArray(name, preview);

if (Sz.isArray(group)) {

matched = group.every(function (current) {
                        return Sz.inArray(current, preview);
                    });
                }

if (Sz.isTrue(matched)) {

stateName = name;

return false;
                }
            });

nav = Datastore.history.slice().pop();

if (Sz.isObject(nav)) {

switch (nav.id) {
                    case "Contrast":
                        stateName = nav.current;

break;
                    default:
                        stateName = nav.menu;
                }
            }

return stateName;
        };

Display3D.render = function (options, callback) {
            var settings, params;

if (Sz.isTrue(Datastore.render)) {
                return false;
            }

Datastore.render = true;
            Datastore.refid = Sz.generateString(15);

settings = {
                refid: Datastore.refid,
                preview: Datastore.preview
            };

Sz.extend(settings, options, {
                designs: (function () {

if (Sz.isFunction(Utility.Display3D)) {
                        return Utility.Display3D();
                    }
                })()
            });

Display3D.setPreview(settings.preview);

if (Sz.isNot(callback, Sz.isFunction)) {
                callback = Display3D.callback;
            }

Datastore.progress.values = {};

Datastore.Params.push([settings, callback, Display3D.progress, Display3D.errors]);
            Datastore.Params.splice(0, Datastore.Params.length - 1);

params = Datastore.Params.shift();

Datastore.Models.forEach(function (model) {
                model.apply(null, params);
            });
        };

Display3D.callback = function (response) {
            var loaded, preview, matched, removed, Group;

Datastore.loaded.push(response);

if (Sz.isEmpty(Datastore.Params)) {

loaded = Datastore.loaded.filter(function (current) {
                    return current.refid === Datastore.refid;
                });

preview = Sz.arrayColumn(Sz.arrayColumn(loaded, "resource"), "name");

matched = Display3D.getPreview().every(function (current) {
                    return Sz.inArray(current, preview);
                });

if (Sz.isTrue(matched)) {

Display3D.adjust();

Group = new response.instance.Libs.Group();

loaded.forEach(function (current) {
                        Group.add(current.resource);
                    });

removed = [];

response.instance.Scene.traverse(function (child) {

if (child instanceof response.instance.Libs.Group) {
                            removed.push(child);
                        }
                    });

removed.forEach(function (child) {
                        response.instance.Scene.remove(child);
                    });

response.instance.Scene.add(Group);
                    response.instance.refresh();

Datastore.loaded = loaded;
                    Datastore.render = null;
                }
            } else {

Datastore.render = null;

Display3D.render();
            }
        };

Display3D.adjust = function () {
            var preview, loaded, stateName, reset, nav;

preview = [];

loaded = Datastore.loaded.filter(function (current) {
                return current.refid === Datastore.refid;
            });

loaded.forEach(function (current) {
                Sz.makeArray(current.resource.name, preview);
            });

Sz.each(Datastore.products, function (name, group) {

var matched = Sz.inArray(name, preview);

if (Sz.isArray(group)) {

matched = group.every(function (current) {
                        return Sz.inArray(current, preview);
                    });
                }

if (Sz.isTrue(matched)) {

stateName = name;

return false;
                }
            });

nav = Datastore.history.slice().pop();
            reset = false;

if (Sz.isObject(nav)) {

if (nav.changes === 0) {
                    reset = true;
                }

if (Sz.isFalse(Sz.inArray(nav.id, ["Style"]))) {

Sz.makeArray(Datastore.history[Datastore.history.length - 1]).map(function (current) {

if (Sz.isObject(current)) {
                            current.changes++;
                        }

return current;
                    });
                }
            }

loaded.forEach(function (current) {
                var ratio, scale, state, coords;

ratio = 1;
                scale = ratio;

state = Display3D.getState();

if (Sz.isEmpty(state) || Sz.isTrue(reset)) {

state = Display3D.getState("Default");
                    state.Spherical.from.setFromVector3(current.instance.Camera.position);
                }

current.resource.position.set(0, 0, 0);

if (Sz.inArray(current.resource.name, ["Jacket"])) {

if (Sz.inArray(stateName, ["Suit3pcs", "Suit"])) {

ratio = 0.54;
                        scale = ratio;

current.resource.position.set(0, ratio * 2.05, 0);
                    }

if (Sz.isObject(nav) && Sz.inArray(nav.current, ["Sleeve"])) {

if (Sz.isTrue(reset)) {

state = Display3D.setState(current.instance, {
                                azimuthAngle: (function (radians) {

if (state.Spherical.from.theta < 0) {
                                        return radians - (Math.PI * 2);
                                    }

return radians;
                                })(current.instance.getRadians(150))
                            });
                        }
                    }

if (Sz.isObject(nav) && Sz.inArray(nav.current, ["Vent"])) {

if (Sz.isTrue(reset)) {

state = Display3D.setState(current.instance, {
                                azimuthAngle: (function (radians) {

if (state.Spherical.from.theta < 0) {
                                        return radians - (Math.PI * 2);
                                    }

return radians;
                                })(current.instance.getRadians(180))
                            });
                        }
                    }
                }

if (Sz.inArray(current.resource.name, ["Pant"])) {

if (Sz.inArray(stateName, ["Suit3pcs", "Suit"])) {

ratio = 0.55;
                        scale = ratio;

current.resource.position.set(0, ratio * -0.25, 0);
                    } else {

scale = ratio * 0.75;

current.resource.position.set(0, ratio * 1.1, 0);
                    }

if (Sz.isObject(nav) && Sz.inArray(nav.current, ["Pocket"])) {

if (Sz.isTrue(reset)) {

state = Display3D.setState(current.instance, {
                                azimuthAngle: (function (radians) {

if (state.Spherical.from.theta < 0) {
                                        return radians - (Math.PI * 2);
                                    }

return radians;
                                })(current.instance.getRadians(45))
                            });
                        }
                    }

if (Sz.isObject(nav) && Sz.inArray(nav.current, ["BackPocket"])) {

if (Sz.isTrue(reset)) {

state = Display3D.setState(current.instance, {
                                azimuthAngle: (function (radians) {

if (state.Spherical.from.theta < 0) {
                                        return radians - (Math.PI * 2);
                                    }

return radians;
                                })(current.instance.getRadians(180))
                            });
                        }
                    }
                }

if (Sz.inArray(current.resource.name, ["Vest"])) {

if (Sz.inArray(stateName, ["Suit3pcs", "Suit"])) {

ratio = 0.474;
                        scale = ratio;

current.resource.position.set(0, ratio * 2.56, 0);
                    }

if (Sz.isObject(nav) && Sz.inArray(nav.current, ["Back"])) {

if (Sz.isTrue(reset)) {

state = Display3D.setState(current.instance, {
                                azimuthAngle: (function (radians) {

if (state.Spherical.from.theta < 0) {
                                        return radians - (Math.PI * 2);
                                    }

return radians;
                                })(current.instance.getRadians(180))
                            });
                        }
                    }
                }

if (Sz.inArray(current.resource.name, ["JacketInteriorLining"])) {

if (Sz.isTrue(reset)) {

state = Display3D.setState(current.instance, {
                            azimuthAngle: (function (radians) {

if (state.Spherical.from.theta < 0) {
                                    return radians - (Math.PI * 2);
                                }

return radians;
                            })(current.instance.getRadians(32))
                        });
                    }

if (Sz.isObject(nav) && Sz.inArray(nav.current, ["Monogram"])) {
                        state.Controls.Orbit.enableRotate = false;
                    }
                }

if (Sz.inArray(current.resource.name, ["BackCollar"])) {

if (Sz.isTrue(reset)) {

state = Display3D.setState(current.instance, {
                            multiplyScalar: 0.7,
                            azimuthAngle: (function (radians) {

if (state.Spherical.from.theta < 0) {
                                    return radians - (Math.PI * 2);
                                }

return radians;
                            })(current.instance.getRadians(180))
                        });
                    }

state.axis.set(0, 0.85, 0);

//state.Controls.Orbit.enabled = false;
                }

if (Sz.isObject(nav) && Sz.inArray(nav.current, ["LastButtonhole"])) {

if (Sz.isTrue(reset)) {

state = Display3D.setState(current.instance, {
                            multiplyScalar: 0.35,
                            polarAngle: (function (radians) {

if (state.Spherical.from.phi < 0) {
                                    return radians - (Math.PI * 2);
                                }

return radians;
                            })(current.instance.getRadians(100)),
                            azimuthAngle: (function (radians) {

if (state.Spherical.from.theta < 0) {
                                    return radians - (Math.PI * 2);
                                }

return radians;
                            })(current.instance.getRadians(125))
                        });
                    }

state.axis.set(1, -1.6, 0);

state.Controls.Orbit.enabled = false;
                    state.Controls.Orbit.minDistance = state.Controls.Orbit.target.distanceTo(state.Camera.position) / 3;
                }

current.resource.scale.set(scale, scale, scale);

coords = {
                    from: state.Spherical.from.clone(),
                    to: state.Spherical.to.clone()
                };

Sz.extend(coords.from, {
                    minDistance: current.instance.Controls.Orbit.minDistance,
                    maxDistance: current.instance.Controls.Orbit.maxDistance
                }, Sz.Map(current.instance.Controls.Orbit.target.clone(), {x: 0, y: 0, z: 0}));

Sz.Animate(function (animate) {

if (animate === 0) {
                        current.instance.Controls.Orbit.enabled = false;
                    }

coords.from.radius += (coords.to.radius - coords.from.radius) * animate;
                    coords.from.phi += (coords.to.phi - coords.from.phi) * animate;
                    coords.from.theta += (coords.to.theta - coords.from.theta) * animate;
                    coords.from.minDistance += (state.Controls.Orbit.minDistance - coords.from.minDistance) * animate;
                    coords.from.maxDistance += (state.Controls.Orbit.maxDistance - coords.from.maxDistance) * animate;
                    coords.from.x += (state.axis.x - coords.from.x) * animate;
                    coords.from.y += (state.axis.y - coords.from.y) * animate;
                    coords.from.z += (state.axis.z - coords.from.z) * animate;

current.instance.Camera.position.setFromSpherical(coords.from);
                    current.instance.Controls.Orbit.update();
                    current.instance.refresh(true);

if (Sz.isTrue(reset)) {

current.instance.Controls.Orbit.minDistance = coords.from.minDistance;
                        current.instance.Controls.Orbit.maxDistance = coords.from.maxDistance;

current.instance.Controls.Orbit.target.set(coords.from.x, coords.from.y, coords.from.z);
                    }

if (animate === 1) {

current.instance.Controls.Orbit.enabled = state.Controls.Orbit.enabled;
                        current.instance.Controls.Orbit.enableRotate = state.Controls.Orbit.enableRotate;
                    }

Display3D.setState(current.instance);
                }, Sz.isTrue(reset) ? 1000 : 0, "easeInOutQuad");
            });
        };
    });
});

${this.title}

Code Editor : display-3d.js