// import polyfills. Done as an export to make sure polyfills are imported first
export * from './polyfill';

// export core
export * from './core';

// export libs
import deprecation from './deprecation';//旧版存在，但是新版pixi已不再支持的特性做兼容性提示
import * as accessibility from './accessibility';
import * as extract from './extract';//such like saving an Image
import * as extras from './extras';
import * as filters from './filters';//WebGL-Only
import * as interaction from './interaction';//events
import * as loaders from './loaders';//loading assets, data, and other resources dynamically.
import * as mesh from './mesh';
import * as particles from './particles';
import * as prepare from './prepare';

export * from './const';//所有静态变量
export * from './math';//数学相关计算

import * as utils from './utils';//一些小的工具方法
import * as ticker from './ticker';//时钟类，控制渲染帧率
import settings from './settings';
import CanvasRenderer from './renderers/canvas/CanvasRenderer';
import WebGLRenderer from './renderers/webgl/WebGLRenderer';

export { settings, utils, ticker, CanvasRenderer, WebGLRenderer };

export { default as glCore } from 'pixi-gl-core';

export { default as Bounds } from './display/Bounds';
export { default as DisplayObject } from './display/DisplayObject';//可展示对象的基础，基础到直接继承自EventEmitter类,但是他却是一个抽象类，作为所有待展示对象的基类,继承之后复写了才有意义。

export { default as Container } from './display/Container';//最强大的基础类
export { default as Transform } from './display/Transform';
export { default as TransformStatic } from './display/TransformStatic';
export { default as TransformBase } from './display/TransformBase';
export { default as Sprite } from './sprites/Sprite';
export { default as CanvasSpriteRenderer } from './sprites/canvas/CanvasSpriteRenderer';
export { default as CanvasTinter } from './sprites/canvas/CanvasTinter';
export { default as SpriteRenderer } from './sprites/webgl/SpriteRenderer';
export { default as Text } from './text/Text';
export { default as TextStyle } from './text/TextStyle';
export { default as TextMetrics } from './text/TextMetrics';
export { default as Graphics } from './graphics/Graphics';//图形
export { default as GraphicsData } from './graphics/GraphicsData';
export { default as GraphicsRenderer } from './graphics/webgl/GraphicsRenderer';
export { default as CanvasGraphicsRenderer } from './graphics/canvas/CanvasGraphicsRenderer';
export { default as Spritesheet } from './textures/Spritesheet';
export { default as Texture } from './textures/Texture';
export { default as BaseTexture } from './textures/BaseTexture';
export { default as RenderTexture } from './textures/RenderTexture';
export { default as BaseRenderTexture } from './textures/BaseRenderTexture';
export { default as VideoBaseTexture } from './textures/VideoBaseTexture';
export { default as TextureUvs } from './textures/TextureUvs';
export { default as CanvasRenderTarget } from './renderers/canvas/utils/CanvasRenderTarget';
export { default as Shader } from './Shader';
export { default as WebGLManager } from './renderers/webgl/managers/WebGLManager';
export { default as ObjectRenderer } from './renderers/webgl/utils/ObjectRenderer';
export { default as RenderTarget } from './renderers/webgl/utils/RenderTarget';
export { default as Quad } from './renderers/webgl/utils/Quad';
export { default as SpriteMaskFilter } from './renderers/webgl/filters/spriteMask/SpriteMaskFilter';
export { default as Filter } from './renderers/webgl/filters/Filter';
export { default as Application } from './Application';
export { autoDetectRenderer } from './autoDetectRenderer';

//Cytoscape qbezierAt
math.qbezierAt = function( p0, p1, p2, t ){
  return (1 - t) * (1 - t) * p0 + 2 * (1 - t) * t * p1 + t * t * p2;
};

function linkArc(d) {
  var dx = d.target.x - d.source.x,
      dy = d.target.y - d.source.y,
      dr = Math.sqrt(dx * dx + dy * dy);
  return "M" + d.source.x + "," + d.source.y + "A" + dr + "," + dr + " 0 0,1 " + d.target.x + "," + d.target.y;
}

//这个三角形默认按顶角为50°，两个底角为65°来算，两边长先按一半nodeWidth来算吧
let t_nodeRadius = nodeWidth;
if (!targetFlag && sourcePos.width) t_nodeRadius = sourcePos.width;
if (targetFlag && targetPos.width) t_nodeRadius = targetPos.width;

//边界判定 => 贴一起了就别显示啦
if ((Math.abs(source.y - target.y) < t_nodeRadius * 1.5) &&
    (Math.abs(source.x - target.x) < t_nodeRadius * 1.5)) {
    t_nodeRadius = 0;
}

let t_srcPos = targetFlag ? sourcePos : targetPos;
let t_tgtPos = targetFlag ? targetPos : sourcePos;

let topAngle = Math.PI / 180 * 50,//角度转弧度，注意Math的那些方法的单位是弧度
    sideEdge = t_nodeRadius,//瞅着合适，先凑合
    halfBottomEdge = Math.sin(topAngle / 2) * sideEdge,
    centerEdge = Math.cos(topAngle / 2) * sideEdge;
//angle是一样的，先按node中心算，arrow中心算之后再说，先todo(直线版看出不这个问题，曲线就崩了)
let angle = Math.atan(Math.abs(t_srcPos.y - t_tgtPos.y) / Math.abs(t_srcPos.x - t_tgtPos.x));
let beginPosX = t_nodeRadius * Math.cos(angle),
    beginPosY = t_nodeRadius * Math.sin(angle),
    pos1X, pos1Y, pos2X, pos2Y,
    centerX = (t_nodeRadius + centerEdge) * Math.cos(angle),
    centerY = (t_nodeRadius + centerEdge) * Math.sin(angle);

pos1X = pos2X = Math.sin(angle) * halfBottomEdge;
pos1Y = pos2Y = Math.cos(angle) * halfBottomEdge;//简单的几何知识(手动抽搐😖)

//还需要分类讨论target和source的左右位置的各种情况
//1234代表target相对source所在象限
if (t_srcPos.x > t_tgtPos.x) {//source节点在右
    if (t_srcPos.y > t_tgtPos.y) {//下 ----> 1
        beginPosX = t_tgtPos.x + beginPosX;
        beginPosY = t_tgtPos.y + beginPosY;

        centerX = t_tgtPos.x + centerX;
        centerY = t_tgtPos.y + centerY;

        pos1X = centerX + pos1X;
        pos1Y = centerY - pos1Y;//+ -

        pos2X = centerX - pos2X;
        pos2Y = centerY + pos2Y;//- +
    } else {//上 ----> 4
        beginPosX = t_tgtPos.x + beginPosX;
        beginPosY = t_tgtPos.y - beginPosY;

        centerX = t_tgtPos.x + centerX;
        centerY = t_tgtPos.y - centerY;

        pos1X = centerX + pos1X;
        pos1Y = centerY + pos1Y;//+ +

        pos2X = centerX - pos2X;
        pos2Y = centerY - pos2Y;//- -
    }

} else {//source节点在左
    if (t_srcPos.y > t_tgtPos.y) {//下 ----> 2
        beginPosX = t_tgtPos.x - beginPosX;
        beginPosY = t_tgtPos.y + beginPosY;

        centerX = t_tgtPos.x - centerX;
        centerY = t_tgtPos.y + centerY;

        pos1X = centerX - pos1X;
        pos1Y = centerY - pos1Y;//- -

        pos2X = centerX + pos2X;
        pos2Y = centerY + pos2Y;//+ +
    } else {//上 ----> 3
        beginPosX = t_tgtPos.x - beginPosX;
        beginPosY = t_tgtPos.y - beginPosY;

        centerX = t_tgtPos.x - centerX;
        centerY = t_tgtPos.y - centerY;

        pos1X = centerX - pos1X;
        pos1Y = centerY + pos1Y;//- +

        pos2X = centerX + pos2X;
        pos2Y = centerY - pos2Y;//+ -
    }
}

//Draw triangle
let triangle = new Graphics();

triangle.beginFill(0x66CCFF);
triangle.lineStyle(0, 0x66CCFF, 1);
triangle.moveTo(beginPosX, beginPosY);
triangle.lineTo(pos1X, pos1Y);
triangle.lineTo(pos2X, pos2Y);
triangle.endFill();

let g = new Dracula.Graph();
for (let i = 0, l = edges.length; i < l; i++) {
    let data = edges[i], id = data.id;
    g.addEdge(data.source, data.target);
}
var layouter = new Dracula.Layout.Spring(g);
layouter.layout();

var renderer = new Dracula.Renderer.Raphael('canvas', g,canvas.width, canvas.height);

renderer.draw();//这里改动了Dragular的源码,这个draw方法不再进行渲染

//根据g生成的位置进行初始化
let nodesObj = g.nodes;
for (let node in nodesObj) {...}