// D:\phoneclient\cocos2dxlib\cocos\3d\CCBundle3DData.h
/**mesh vertex attribute*/
// 顶点属性(位置属性、颜色属性、纹理属性等)
struct MeshVertexAttrib
{
    //attribute size
    // 描述该属性所需要的元素个数，比如描述一个Vec3的位置信息，需要x，y，z这么3个变量
    GLint size;
    //GL_FLOAT
    // 元素的类型，如GL_FLOAT
    GLenum type;
    //VERTEX_ATTRIB_POSITION,VERTEX_ATTRIB_COLOR,VERTEX_ATTRIB_TEX_COORD,VERTEX_ATTRIB_NORMAL, VERTEX_ATTRIB_BLEND_WEIGHT, VERTEX_ATTRIB_BLEND_INDEX, GLProgram for detail
    // 描述改属性类型的值，使用的值是GLProgram类的枚举，如GLProgram::VERTEX_ATTRIB_POSITION
    int  vertexAttrib;
    //size in bytes
    // 存储该属性所需要的字节数，等于size * sizeof(type)
    int attribSizeBytes;
};

/**mesh data*/
// 模型蒙皮数据
struct MeshData
{
    // 每个顶点拥有的属性类型数目
    int attribCount;
    // Vertex数组元素个数
    int vertexSizeInFloat;
    // indices数组元素个数
    int numIndex;
    // 每个顶点的属性信息
    std::vector<MeshVertexAttrib> attribs;
    std::vector<float> vertex;
    std::vector<unsigned short> indices;
};

/**skin data*/
// 模型骨骼信息
struct SkinData
{
    // 影响到模型蒙皮的骨骼名字数组，称之为skinBone的数组
    std::vector<std::string> skinBoneNames; //skin bones affect skin
    // 未影响到模型蒙皮的骨骼名字数组，称之为nodeBone的数组
    std::vector<std::string> nodeBoneNames; //node bones don‘t affect skin, all bones [skinBone, nodeBone]
    // 从对应的skinBone坐标系到模型坐标系变换的逆变换，可实现将该骨骼影响的蒙皮顶点从模型坐标系的坐标，转换至该骨骼坐标系的坐标
    std::vector<Mat4>        inverseBindPoseMatrices; //bind pose of skin bone, only for skin bone
    // skinBone到其父骨骼坐标系的初始矩阵
    std::vector<Mat4>        skinBoneOriginMatrices; // original bone transform, for skin bone
    // nodeBone到其父骨骼坐标系的初始矩阵
    std::vector<Mat4>        nodeBoneOriginMatrices; // original bone transform, for node bone
    
    //bone child info, both skinbone and node bone
    // 所有骨骼与其子骨骼索引的map，值得说明的是这个索引是对skinBone和nodeBone两个数组而言的
    std::map<int, std::vector<int> > boneChild;//key parent, value child
    // 根骨骼索引，同样是相对两个数组而言
    int                              rootBoneIndex;
}

/**material data*/
// 材质数据
struct MaterialData
{
    // 3.2 版本的材质数据结构很简单，只有纹理信息
    std::string texturePath;
};

// D:\phoneclient\cocos2dxlib\cocos\3d\CCMesh.h
/** 
 * Mesh: Geometry with a collection of vertex. 
 * Supporting various vertex formats.
 */
class Mesh : public Ref
{
public:
    /**build buffer*/
    // 将MeshData中的vertex和indices数组传给GPU并得到对应的_vertexBuffer和_indexBuffer
    void buildBuffer();

protected:
    // 顶点数据缓冲
    GLuint _vertexBuffer;
    // 顶点索引缓冲
    GLuint _indexBuffer;

    // 复制了MeshData中的数据
    RenderMeshData _renderdata;
};

// D:\phoneclient\cocos2dxlib\cocos\3d\CCMeshSkin.h
/**
 * Defines a basic hierachial structure of transformation spaces.
 */
class Bone3D : public Ref
{
protected:
    // 复制对应SkinData::inverseBindPoseMatrices而来，只对skinBone有意义
    Mat4 _invBindPose;
    // 复制对应SkinData::skinBoneOriginMatrices 或 Skin::nodeBoneOriginMatrices而来
    Mat4 _oriPose; //original bone pose
    // 其父骨骼指针
    Bone3D* _parent; //parent bone
    // 子骨骼指针
    Vector<Bone3D*> _children;
    // 到模型空间的变换矩阵
    Mat4          _world;
    // 到父骨骼坐标系的变换矩阵
    Mat4          _local;
    
};


/**
 * MeshSkin, A class maintain a collection of bones that affect Mesh vertex.
 * And it is responsible for computing matrix palletes that used by skin mesh rendering.
 */
class MeshSkin: public Ref
{
protected:
    // 由SkinData::skinBoneNames, inverseBindPoseMatrices, skinBoneOriginMatrices这些数据创建出相应Bone3D,得到该数组
    Vector<Bone3D*> _skinBones; // bones with skin
    // 由SkinData::skinBoneNames, nodeBoneOriginMatrices这些数据创建出相应Bone3D,得到该数组
    Vector<Bone3D*> _nodeBones; //bones without skin, only used to compute transform of children
    // 根骨骼
    Bone3D* _rootBone;
    
    // Pointer to the array of palette matrices.
    // This array is passed to the vertex shader as a uniform.
    // Each 4x3 row-wise matrix is represented as 3 Vec4‘s.
    // The number of Vec4‘s is (_skinBones.size() * 3).
    Vec4* _matrixPalette;
};

// D:\phoneclient\cocos2dxlib\cocos\3d\CCMeshSkin.cpp
void Bone3D::updateJointMatrix(Vec4* matrixPalette)
{
    {
        static Mat4 t;
        // 得到我们需要的矩阵，但这是4*4 的。
        Mat4::multiply(_world, getInverseBindPose(), &t);
        // 将矩阵最后一行去掉，得到4*3的Vec4向量数组
        matrixPalette[0].set(t.m[0], t.m[4], t.m[8], t.m[12]);
        matrixPalette[1].set(t.m[1], t.m[5], t.m[9], t.m[13]);
        matrixPalette[2].set(t.m[2], t.m[6], t.m[10], t.m[14]);
    }
}

const char* cc3D_PositionTex_vert = STRINGIFY(

attribute vec4 a_position;
attribute vec2 a_texCoord;

varying vec2 TextureCoordOut;

void main(void)
{
    gl_Position = CC_MVPMatrix * a_position;
    TextureCoordOut = a_texCoord;
    TextureCoordOut.y = 1.0 - TextureCoordOut.y;
}
);

const char* cc3D_SkinPositionTex_vert = STRINGIFY(
attribute vec3 a_position;

attribute vec4 a_blendWeight;
attribute vec4 a_blendIndex;

attribute vec2 a_texCoord;

const int SKINNING_JOINT_COUNT = 60;
// Uniforms
uniform vec4 u_matrixPalette[SKINNING_JOINT_COUNT * 3];

// Varyings
varying vec2 TextureCoordOut;

vec4 getPosition()
{   
    // 对该顶点产生作用的第一个块骨骼，所占的权重
    float blendWeight = a_blendWeight[0];

    int matrixIndex = int (a_blendIndex[0]) * 3;
    // 对传递进来的matriPalette矩阵乘以该骨骼的权重
    vec4 matrixPalette1 = u_matrixPalette[matrixIndex] * blendWeight;
    vec4 matrixPalette2 = u_matrixPalette[matrixIndex + 1] * blendWeight;
    vec4 matrixPalette3 = u_matrixPalette[matrixIndex + 2] * blendWeight;
    
    
    blendWeight = a_blendWeight[1];
    if (blendWeight > 0.0)
    {
        // 若还有别的骨骼对该顶点产生影响，则进行混合
        matrixIndex = int(a_blendIndex[1]) * 3;
        matrixPalette1 += u_matrixPalette[matrixIndex] * blendWeight;
        matrixPalette2 += u_matrixPalette[matrixIndex + 1] * blendWeight;
        matrixPalette3 += u_matrixPalette[matrixIndex + 2] * blendWeight;
    }
    
    
    blendWeight = a_blendWeight[2];
    if (blendWeight > 0.0)
    {
        matrixIndex = int(a_blendIndex[2]) * 3;
        matrixPalette1 += u_matrixPalette[matrixIndex] * blendWeight;
        matrixPalette2 += u_matrixPalette[matrixIndex + 1] * blendWeight;
        matrixPalette3 += u_matrixPalette[matrixIndex + 2] * blendWeight;
    }
    
    
    blendWeight = a_blendWeight[3];
    if (blendWeight > 0.0)
    {
        matrixIndex = int(a_blendIndex[3]) * 3;
        matrixPalette1 += u_matrixPalette[matrixIndex] * blendWeight;
        matrixPalette2 += u_matrixPalette[matrixIndex + 1] * blendWeight;
        matrixPalette3 += u_matrixPalette[matrixIndex + 2] * blendWeight;
    }
    

    vec4 _skinnedPosition;
    vec4 postion = vec4(a_position, 1.0);
    // 使用这个混合后的矩阵，对顶点进行变换，得到该顶点在模型坐标系下的坐标
    _skinnedPosition.x = dot(postion, matrixPalette1);
    _skinnedPosition.y = dot(postion, matrixPalette2);
    _skinnedPosition.z = dot(postion, matrixPalette3);
    _skinnedPosition.w = postion.w;
    
    return _skinnedPosition;
}

void main()
{
    // 得到顶点在模型坐标系下的坐标
    vec4 position = getPosition();
    // 使用MVP矩阵进行变换得到最终坐标
    gl_Position = CC_MVPMatrix * position;
    
    TextureCoordOut = a_texCoord;
    TextureCoordOut.y = 1.0 - TextureCoordOut.y;
}

);