CSceneNode* CSkpMeshImporterImpler::LoadModel(SUModelRef model)
{
    // Get the entities container of the model.
    SUEntitiesRef entities = SU_INVALID;
    SUResult res = SUModelGetEntities(model, &entities);

	//size_t faceCount = 0;
	//res = SUEntitiesGetNumFaces(entities, &faceCount);
	//vector<SUFaceRef> faces;
	//size_t count;
	//res = SUEntitiesGetFaces(entities, faceCount, &faces[0], &faceCount);


    assert(res == SU_ERROR_NONE);

    // Load materials
    LoadMaterials(model);

    // Create a texture writer
    SUSetInvalid(m_textureWriter);
    res = SUTextureWriterCreate(&m_textureWriter);
    assert(res == SU_ERROR_NONE);

    // Entities recursive
    CSceneNode* pGroup = new CGroupNode();
    SUMaterialRef eleMaterial = SU_INVALID;
    LoadEntitiesRecursive(entities, eleMaterial, pGroup);

    SUAxesRef axis;
    SUModelGetAxes(model,&axis);
    SUTransformation transform;
    SUAxesGetTransform(axis,&transform);
    CMatrix4d mat = CMatrix4d::Identity;
    memcpy(mat.Ptr(), transform.values, sizeof(double) * 16);
    pGroup->SetTransform(mat.Inverse().Matrix4f());

    return pGroup;
}

void CSkpMeshImporterImpler::LoadEntitiesRecursive(SUEntitiesRef entities, SUMaterialRef parMaterial, CSceneNode* pParent)
{
    // Load component instances
    size_t instanceCount = 0;
    SUResult res = SUEntitiesGetNumInstances(entities, &instanceCount);
    assert(res == SU_ERROR_NONE);
    if (instanceCount > 0)
    {
        std::vector<SUComponentInstanceRef> instances(instanceCount);
        res = SUEntitiesGetInstances(entities, instanceCount, &instances[0], &instanceCount);
        assert(res == SU_ERROR_NONE);

        for (size_t i=0; i<instanceCount; ++i) 
        {
            CSceneNode* pGroup = nullptr;
            SUMaterialRef material = SkpImporterHelper::LoadComponentInstanceMaterial(instances[i], m_textureWriter);
            if (SUIsInvalid(material) && SUIsValid(parMaterial))
            {
                material = parMaterial;
            }
            SUEntitiesRef componentEntities = LoadComponentInstance(instances[i], material, pParent, pGroup);
            LoadEntitiesRecursive(componentEntities, material, pGroup);
        }
    }

    // Load groups
    size_t groupCount = 0;
    res = SUEntitiesGetNumGroups(entities, &groupCount);
    assert(res == SU_ERROR_NONE);
    if (groupCount > 0)
    {
        std::vector<SUGroupRef> groups(groupCount);
        SUEntitiesGetGroups(entities, groupCount, &groups[0], &groupCount);
        assert(res == SU_ERROR_NONE);

        for (size_t i=0; i<groupCount; ++i)
        {
            CSceneNode* pGroup = nullptr;
            SUMaterialRef material = SkpImporterHelper::LoadGroupMaterial(groups[i], m_textureWriter);
            if (SUIsInvalid(material) && SUIsValid(parMaterial))
            {
                material = parMaterial;
            }
            SUEntitiesRef groupEntities = LoadGroup(groups[i], material, pParent, pGroup);
            LoadEntitiesRecursive(groupEntities, material, pGroup);
        }
    }

    // Load separate mesh,no edges
    size_t faceCount = 0;
    res = SUEntitiesGetNumFaces(entities, &faceCount);
    assert(res == SU_ERROR_NONE);
    if (faceCount>0)
    {
        CGroupNode* pTempParent = dynamic_cast<CGroupNode*>(pParent);
        if (pTempParent)
        {
            CVisualNode* pNode =  new CVisualNode();
            LoadFaces(entities, pNode, parMaterial);
            pTempParent->AddChild(pNode);
        }
    }
}

SUEntitiesRef CSkpMeshImporterImpler::LoadComponentInstance(SUComponentInstanceRef instance, SUMaterialRef eleMaterial, CSceneNode* pParent, CSceneNode* &pGGPNode)
{
    // Convert to entities
    SUComponentDefinitionRef component_definition;
    SUResult res = SUComponentInstanceGetDefinition(instance, &component_definition);
    assert(res == SU_ERROR_NONE);

    SUEntitiesRef entities;
    res = SUComponentDefinitionGetEntities(component_definition, &entities);
    assert(res == SU_ERROR_NONE);

    // Load transform
    SUTransformation transform;
    res = SUComponentInstanceGetTransform(instance, &transform);
    assert(res == SU_ERROR_NONE);

    CMatrix4d mat = CMatrix4d::Identity;
    memcpy(mat.Ptr(), transform.values, sizeof(double) * 16);
    mat[3][0] *= m_fUnitFactor;
    mat[3][1] *= m_fUnitFactor;
    mat[3][2] *= m_fUnitFactor;

    std::vector<CSceneNode*> skpEntityNodes = CreateGGPNodeBySkpEntities(entities, eleMaterial, pParent);
    pGGPNode = skpEntityNodes.at(0);
    for(unsigned int i = 0; i < skpEntityNodes.size(); i++)
    {
        assert(skpEntityNodes[i] != nullptr);
        if (skpEntityNodes[i] != nullptr)
        {
            skpEntityNodes[i]->SetTransform(mat.Matrix4f());
        }
    }
    return entities;
}

SUEntitiesRef CSkpMeshImporterImpler::LoadGroup(SUGroupRef group, SUMaterialRef eleMaterial, CSceneNode* pParent, CSceneNode* &pGGPNode)
{
    // Convert to entities
    SUComponentDefinitionRef component_definition;
    SUResult res = SUGroupGetDefinition(group, &component_definition);
    assert(res == SU_ERROR_NONE);

    SUEntitiesRef entities;
    res = SUComponentDefinitionGetEntities(component_definition, &entities);
    assert(res == SU_ERROR_NONE);

    // Load transform
    SUTransformation transform;
    res = SUGroupGetTransform(group, &transform);
    assert(res == SU_ERROR_NONE);

    CMatrix4d mat = CMatrix4d::Identity;
    memcpy(mat.Ptr(), transform.values, sizeof(double) * 16);
    mat[3][0] *= m_fUnitFactor;
    mat[3][1] *= m_fUnitFactor;
    mat[3][2] *= m_fUnitFactor;

    std::vector<CSceneNode*> skpEntityNodes = CreateGGPNodeBySkpEntities(entities, eleMaterial, pParent);
    pGGPNode = skpEntityNodes.at(0);
    for(unsigned int i = 0; i < skpEntityNodes.size(); i++)
    {
        assert(skpEntityNodes[i] != nullptr);
        if (skpEntityNodes[i] != nullptr)
        {
            skpEntityNodes[i]->SetTransform(mat.Matrix4f());
        }
    }
    return entities;
}

std::vector<CSceneNode*> CSkpMeshImporterImpler::CreateGGPNodeBySkpEntities(SUEntitiesRef entities, SUMaterialRef parMaterial, CSceneNode* pParent)
{
    std::vector<CSceneNode*> skpEntitiyNodes;
    // Parameter check
    if (SUIsInvalid(entities) || pParent == nullptr)
    {
        assert(false);
        return skpEntitiyNodes;
    }
    CGroupNode* pTempParent = dynamic_cast<CGroupNode*>(pParent);
    assert(pTempParent != nullptr);

    // Child and mesh info
    size_t instanceCount = 0;
    SUResult res = SUEntitiesGetNumInstances(entities, &instanceCount);
    assert(res == SU_ERROR_NONE);

    size_t groupCount = 0;
    res = SUEntitiesGetNumGroups(entities, &groupCount);
    assert(res == SU_ERROR_NONE);

    size_t faceCount = 0;
    res = SUEntitiesGetNumFaces(entities, &faceCount);
    assert(res == SU_ERROR_NONE);

    // Have no child, only mesh
    if(instanceCount == 0 && groupCount == 0)
    {
        CVisualNode* pNode =  new CVisualNode();
        pTempParent->AddChild(pNode);
        LoadFaces(entities, pNode, parMaterial);
        skpEntitiyNodes.push_back(pNode);

        if (m_bImportEdges)
        {
            CSkpLineNode* pSkpNode =  new CSkpLineNode();
            pTempParent->AddChild(pSkpNode);
            LoadEdges(entities, pSkpNode, CColor::Black);
            skpEntitiyNodes.push_back(pSkpNode);
            pSkpNode->SetVisible(false);
        }
        return skpEntitiyNodes;
    }
    else
    {
        // Have both child and mesh
        if (faceCount > 0)
        {
            CGroupNode* pMiddleNode = new CGroupNode(); 
            pTempParent->AddChild(pMiddleNode);

            CVisualNode* pNode = new CVisualNode();
            pMiddleNode->AddChild(pNode);
            LoadFaces(entities, pNode, parMaterial);

            if (m_bImportEdges)
            {
                CSkpLineNode* pSkpNode =  new CSkpLineNode();
                pMiddleNode->AddChild(pSkpNode);
                LoadEdges(entities, pSkpNode, CColor::Black);
                pSkpNode->SetVisible(false);
            }
            skpEntitiyNodes.push_back(pMiddleNode);
            return skpEntitiyNodes;
        }
        // Have child, no mesh
        else
        {
            CGroupNode* pNode =  new CGroupNode();
            pTempParent->AddChild(pNode);
            skpEntitiyNodes.push_back(pNode);
            return skpEntitiyNodes;
        }
    }
}

void CSkpMeshImporterImpler::LoadFaces(SUEntitiesRef entities, CVisualNode* pGGPNode, SUMaterialRef parMaterial)
{
    // Parameter check
    if (SUIsInvalid(entities) || (pGGPNode == nullptr))
    {
        assert(false);
        return;
    }

    size_t faceCount = 0;
    SUResult res = SUEntitiesGetNumFaces(entities, &faceCount);

    assert(res == SU_ERROR_NONE);
    if (faceCount > 0)
    {
        std::vector<SUFaceRef> faces(faceCount);
        res = SUEntitiesGetFaces(entities, faceCount, &faces[0], &faceCount);
        assert(res == SU_ERROR_NONE);

		SUBoundingBox3D box;
		res =  SUEntitiesGetBoundingBox(entities, &box);
		assert(res == SU_ERROR_NONE);

        // Divide faces by material
		std::map <std::pair<wstring, wstring>, std::vector<SUFaceRef>> materialFaces;
		std::vector<bool> is_affineFaces(faceCount);
		std::vector<long> idTextureFaces(faceCount);
		std::vector<double> textureScaleU(faceCount);
		std::vector<double> textureScaleV(faceCount);
        for (size_t i=0; i<faceCount; ++i)
        {
            SUMaterialRef frontMaterial = SU_INVALID;
            res = SUFaceGetFrontMaterial(faces[i], &frontMaterial);
			bool is_affine;
			SUFaceIsFrontMaterialAffine(faces[i], &is_affine);
			is_affineFaces[i] = is_affine;

            assert(res == SU_ERROR_NONE || res == SU_ERROR_NO_DATA);

            if(res == SU_ERROR_NO_DATA)
            {
                assert(SUIsInvalid(frontMaterial));
                res = SUFaceSetFrontMaterial(faces[i], parMaterial);
                assert(res == SU_ERROR_NONE);
                frontMaterial = parMaterial;
            }

            if (SUIsValid(frontMaterial))
            {
                SUTextureRef texture_ref = SU_INVALID;
                bool hasFrontTexture = SUMaterialGetTexture(frontMaterial, &texture_ref) == SU_ERROR_NONE;
                //bool hasBackTexture = SUMaterialGetTexture(frontMaterial, &texture_ref) == SU_ERROR_NONE;

                if (hasFrontTexture)
                {
                    // Texture
                    long front_texture_id = 0;
                    long back_texture_id = 0;
                    res = SUTextureWriterLoadFace(m_textureWriter, faces[i], &front_texture_id, &back_texture_id);
                    assert(res == SU_ERROR_NONE);
					idTextureFaces[i] = front_texture_id;

					size_t width = 0;
					size_t height = 0;
					double scaleU = 0;
					double scaleV = 0;
					CVector2d scale;
					SUTextureGetDimensions(texture_ref, &width, &height, &scale.X, &scale.Y);
					textureScaleU[i] = scale.X;
					textureScaleV[i] = scale.Y;
                }
            }

			SUMaterialRef backMaterial = SU_INVALID;
			res = SUFaceGetBackMaterial(faces[i], &backMaterial);
			bool is_BackAffine;
			SUFaceIsBackMaterialAffine(faces[i], &is_BackAffine);

			assert(res == SU_ERROR_NONE || res == SU_ERROR_NO_DATA);

			if (res == SU_ERROR_NO_DATA)
			{
				assert(SUIsInvalid(backMaterial));
				res = SUFaceSetBackMaterial(faces[i], parMaterial);
				assert(res == SU_ERROR_NONE);
				backMaterial = parMaterial;
			}

			std::wstring materialFrontId = GetMaterialId(frontMaterial);
			std::wstring materialBackId = GetMaterialId(backMaterial);
			materialFaces[std::make_pair(materialFrontId, materialFrontId)].push_back(faces[i]);
        }

        // Parse faces
		int index = 0;
        for (auto it=materialFaces.begin(); it != materialFaces.end(); ++it)
        {
            // Create renderable
			CVector2d scale;
            CRenderable* renderable = LoadMesh(it->second, is_affineFaces[index]);

			CStateSet* pStateSetFront = GetStateSetByID(it->first.first);
			CStateSet* pStateSetBack = GetStateSetByID(it->first.second);
			if (pStateSetBack != nullptr)
			{
				////pStateSetFront->AddTextureState(pStateSetBack->GetTextureState(0));
				//if (pStateSetFront->GetShaderProgram() != nullptr)
				//{
				//	pStateSetFront->GetShaderProgram()->GetFragmentShader()->LoadShaderFromFile(L"D:/shader_fs.glsl");
				//	CShaderUniform* pShaderUniform = 0;
				//	pShaderUniform = new CShaderUniform("isDoubleFace", true);
				//	pStateSetFront->AddUniform(CShader::ST_FRAGMENT_SHADER, pShaderUniform);
				//	//pStateSetFront->AddTextureState(pStateSetBack->GetTextureState(0));
				//	pStateSetFront->RemoveAllTextureStates();

				//	pStateSetFront->CreateTextureState(L"D:/a.jpg", 1);
				//}

			}
			renderable->SetStateSet(pStateSetFront);
            pGGPNode->AddRenderable(renderable);
			index++;
        }
    }
}

void CSkpMeshImporterImpler::LoadEdges(SUEntitiesRef entities, CSkpLineNode* pGGPNode, CColor color)
{
    // Parameter check
    if (SUIsInvalid(entities) || (pGGPNode == nullptr))
    {
        assert(false);
        return;
    }

    std::vector<SUEdgeRef> sktEdges;
    size_t edgeCount = 0;
    SUEntitiesGetNumEdges(entities, false, &edgeCount);
    if (edgeCount>0)
    {
        sktEdges.resize(edgeCount);
        SUEntitiesGetEdges(entities, false, edgeCount, &sktEdges[0], &edgeCount);
    }

    // Create renderable
    CPrimitiveRenderable* pRenderable = new CPrimitiveRenderable;
    // Declaration
    pRenderable->SetPrimitiveType(PT_LINES);
    Vec3List positionArr;
    UIntList indexArr;
    int j = 0;
    for(unsigned int i=0; i<sktEdges.size(); ++i)
    {
        SUCurveRef sktCurve = SU_INVALID;
        SUEdgeGetCurve(sktEdges[i], &sktCurve);

        SUVertexRef startVertex = SU_INVALID;
        SUVertexRef endVertex = SU_INVALID;
        SUEdgeGetStartVertex(sktEdges[i], &startVertex);
        SUEdgeGetEndVertex(sktEdges[i], &endVertex);

        SUPoint3D start;
        SUPoint3D end;
        SUVertexGetPosition(startVertex, &start);
        SUVertexGetPosition(endVertex, &end);

        CVector3d position(start.x, start.y, start.z);
        CVector3d positionEnd(end.x, end.y, end.z);
        positionArr.push_back(position.Vec3f());
        positionArr.push_back(positionEnd.Vec3f());
        indexArr.push_back(static_cast<unsigned int>(j++));
        indexArr.push_back(static_cast<unsigned int>(j++));

    }
    if(positionArr.size() > 1)
    {
        pRenderable->SetVertexArray(positionArr);
        pRenderable->SetIndexArray(indexArr);
        pRenderable->GetOrCreateStateSet()->SetMaterial(color);
        pGGPNode->AddRenderable(pRenderable);
    }
}

CRenderable* CSkpMeshImporterImpler::LoadMesh(const std::vector<SUFaceRef>& faces, bool isAffine)
{
    Vec3List positionArr;
    Vec3List normalArr;
    ColorList colorArr;
    Vec2List texCoordArr;
    UIntList indexArr;

    size_t iBaseIndex = 0;
    for (size_t i=0; i<faces.size(); ++i)
    {
		if (isAffine)
		{
			// Form the mesh
			SUMeshHelperRef mesh = SU_INVALID;
			SUResult res = SUMeshHelperCreateWithTextureWriter(&mesh, faces[i], m_textureWriter);
			assert(res == SU_ERROR_NONE);

			// Indices
			size_t triCount = 0;
			res = SUMeshHelperGetNumTriangles(mesh, &triCount);
			assert(res == SU_ERROR_NONE);
			if (triCount < 1)
				continue;

			const size_t indicesCount = 3 * triCount;
			size_t retrievedCount = 0;
			std::vector<size_t> Indices(indicesCount);
			res = SUMeshHelperGetVertexIndices(mesh, indicesCount, &Indices[0], &retrievedCount);
			assert(res == SU_ERROR_NONE);

			for (size_t j = 0; j < indicesCount; ++j)
			{
				indexArr.push_back(static_cast<unsigned int>(Indices[j] + iBaseIndex));
			}

			// Get number of vertices. 
			size_t vertexCount;
			res = SUMeshHelperGetNumVertices(mesh, &vertexCount);
			assert(res == SU_ERROR_NONE);
			iBaseIndex += vertexCount;

			// Get vertices.
			std::vector<SUPoint3D> vertices(vertexCount);
			res = SUMeshHelperGetVertices(mesh, vertexCount, &vertices[0], &vertexCount);
			assert(res == SU_ERROR_NONE);
			for (size_t j = 0; j < vertexCount; ++j)
			{
				CVector3d position(vertices[j].x, vertices[j].y, vertices[j].z);
				position *= m_fUnitFactor;
				positionArr.push_back(position.Vec3f());
			}

			// Get Normals
			std::vector<SUVector3D> normals(vertexCount);
			res = SUMeshHelperGetNormals(mesh, vertexCount, &normals[0], &vertexCount);
			assert(res == SU_ERROR_NONE);
			for (size_t j = 0; j < vertexCount; ++j)
			{
				CVector3d normal(normals[j].x, normals[j].y, normals[j].z);
				normalArr.push_back(normal.Vec3f());
			}
			// Front Texture Coordinates
			std::vector<SUPoint2D> textureCoords(vertexCount);
			res = SUTextureWriterGetFrontFaceUVCoords(m_textureWriter, faces[i], vertexCount, &vertices[0], &textureCoords[0]);
			assert(res == SU_ERROR_NONE);
			for (size_t j = 0; j < vertexCount; ++j)
			{
				CVector2d texCoord(textureCoords[j].x, textureCoords[j].y);;
				texCoordArr.push_back(texCoord.Vec2f());
			}

			res = SUMeshHelperRelease(&mesh);
			assert(res == SU_ERROR_NONE);
		}
		else
		{
			SUMeshHelperRef polyMesh = SU_INVALID;
			SUMeshHelperCreate(&polyMesh, faces[i]);

			size_t result;
			size_t nVertices = 0;
			size_t nIndices = 0;

			if (SUIsValid(polyMesh))
			{
				SUMeshHelperGetNumVertices(polyMesh, &nVertices);

				std::vector<SUPoint3D> points(nVertices);
				std::vector<SUPoint3D> uvs(nVertices);
				std::vector<SUVector3D> normals(nVertices);

				SUMeshHelperGetVertices(polyMesh, nVertices, &points[0], &result);
				SUMeshHelperGetNormals(polyMesh, nVertices, &normals[0], &result);
				SUMeshHelperGetFrontSTQCoords(polyMesh, nVertices, &uvs[0], &result);

				SUMeshHelperGetNumTriangles(polyMesh, &nIndices);

				nIndices = nIndices * 3;
				std::vector<size_t> indices(nIndices);

				SUMeshHelperGetVertexIndices(polyMesh, nIndices, &indices[0], &result);

				// Release polyMesh
				SUMeshHelperRelease(&polyMesh);

				for (size_t j = 0; j < nIndices; ++j)
				{
					CVector3d position(points[indices[j]].x, points[indices[j]].y, points[indices[j]].z);
					positionArr.push_back(position.Vec3f());
					CVector3d normal(normals[indices[j]].x, normals[indices[j]].y, normals[indices[j]].z);
					normalArr.push_back(normal.Vec3f());
					CVector2d texCoord(uvs[indices[j]].x / uvs[indices[j]].z, uvs[indices[j]].y / uvs[indices[j]].z);
					texCoordArr.push_back(texCoord.Vec2f());
				}
			}
			//SUUVHelperRef uv_helper;
			//res = SUFaceGetUVHelperWithTextureHandle(faces[i], true, false, m_textureWriter, id, &uv_helper);
			//assert(res == SU_ERROR_NONE);
			//if (res == SU_ERROR_NONE)
			//{
			//	for (int iv = 0; iv < vertices.size(); iv++)
			//	{
			//		SUUVQ uvq;
			//		res = SUUVHelperGetFrontUVQ(uv_helper, &vertices[iv], &uvq);
			//		if (res == SU_ERROR_NONE)
			//		{
			//			double u;
			//			double v;
			//			if (scaleU != 0)
			//			{
			//				u = 1.0;
			//				//u = scaleU;
			//			}
			//			if (scaleV != 0)
			//			{
			//				v = 1.0;
			//				//v = scaleV;
			//			}
			//			texCoordArr.push_back(CVector2d(uvq.u / (uvq.q * u), uvq.v / (uvq.q * v)).Vec2f());
			//		}
			//	}
			//}
			//SUUVHelperRelease(&uv_helper);

		}
    }

	colorArr.assign(positionArr.size(), CColor::Gray);
	return SkpImporterHelper::CreateRenderable(positionArr, normalArr, colorArr, texCoordArr, indexArr);
}

void CSkpMeshImporterImpler::LoadMaterials(SUModelRef model)
{
    // Get the materials of model
    size_t materialCount = 0;
    SUResult res = SUModelGetNumMaterials(model, &materialCount);
    assert(res == SU_ERROR_NONE);

    // Parse material
    if (materialCount>0)
    {
        std::vector<SUMaterialRef> materials(materialCount);
        res = SUModelGetMaterials(model, materialCount, &materials[0], &materialCount);
        assert(res == SU_ERROR_NONE);

        for (size_t i=0; i<materialCount; ++i)
        {
            LoadMaterial(materials[i]);
        }
    }
}

CStateSet* CSkpMeshImporterImpler::LoadMaterial(SUMaterialRef skpMaterial)
{
    // ID
    std::wstring id = GetMaterialId(skpMaterial);
    if (id != L"")
    {
        return GetStateSetByID(id);
    }
    else
    {
        // Create guid
        std::string newId = SkpImporterHelper::newGUID();
        id = GStdStringTrans::StringToWString(newId);
    }

    //Material name
    SUStringRef matName = SU_INVALID;
    std::string strMatName;
    SUStringCreate(&matName);
    SUMaterialGetName(skpMaterial, &matName);
    if(SUIsValid(matName))
    {
        strMatName = SkpImporterHelper::SUString2String(matName);
    }
    SUStringRelease(&matName);

    //Material type
    SUMaterialType type;
    SUResult res = SUMaterialGetType(skpMaterial, &type);
    assert(res == SU_ERROR_NONE);

    //Material color
    CColor diffuse;
    float arrayDiffse[4];
    if(type == SUMaterialType_Colored || type == SUMaterialType_ColorizedTexture)
    {
        SUColor sktColor;
        res = SUMaterialGetColor(skpMaterial, &sktColor);
        assert(res == SU_ERROR_NONE);

        diffuse = CColor(sktColor.red, sktColor.green, sktColor.blue, 0/*sktColor.alpha*/);
        CColor::MakeFloatArray(diffuse, arrayDiffse);
    }
    else
    {
        arrayDiffse[0] = arrayDiffse[1] = arrayDiffse[2] = 0.0f;
    }

    //Opacity
    bool use_opacity = false;
    double alpha = 1.0;
    res = SUMaterialGetUseOpacity(skpMaterial, &use_opacity);
    assert(res == SU_ERROR_NONE);
    if (use_opacity)
    {
        res = SUMaterialGetOpacity(skpMaterial, &alpha);
        assert(res == SU_ERROR_NONE);
    }
    arrayDiffse[3] = static_cast<float>(alpha);
    diffuse.SetByFloatArray(arrayDiffse);

    // Texture type
    std::string strTexName;
    if(type == SUMaterialType_Textured || type == SUMaterialType_ColorizedTexture)
    {
        SUTextureRef texture = SU_INVALID;
        res = SUMaterialGetTexture(skpMaterial, &texture);
        switch (res)
        {
        case SU_ERROR_NONE:
            {
                SUStringRef fileName = SU_INVALID;
                SUStringCreate(&fileName);
                SUTextureGetFileName(texture, &fileName);
                if(SUIsValid(fileName))
                {
                    strTexName = SkpImporterHelper::SUString2String(fileName);
                }
                SUStringRelease(&fileName);

                // Write texture to resource path
                if (SUIsValid(texture))
                {
                    std::string strFullPath = m_strResourcesPath + strTexName;
                    bool bExist = boost::filesystem::exists(GStdStringTrans::Utf8ToAnsi(strFullPath.c_str()));
                    if (!bExist)
                    {
                        res = SUTextureWriteToFile(texture, strFullPath.c_str());
                        assert(res == SU_ERROR_NONE);
                    }
                }

                break;
            }
        case SU_ERROR_NO_DATA:
            {
                std::cout <<"No Texture \n";
                break;
            }
        default :
            break;
        }
    }

    // Create CStateSet
    CStateSet* pStateSet = nullptr;
    if (m_pMaterialLibrary)
    {
        CAppearanceInstancePtr pInstance = m_pMaterialLibrary->CreateMaterial("Generic");
        CVector4f color;
        CColor::MakeFloatArray(diffuse, &color[0]);
        pInstance->SetDiffuse(color);
        pInstance->SetAmbient(color);
        pInstance->SetSpecular(CVector4f(0.0f, 0.0f, 0.0f, 1.0f));
        pInstance->SetShininess(0.0f);

        pInstance->SetTransparent(static_cast<float>(alpha));
        pInstance->SetName(GStdStringTrans::Utf8ToAnsi(strMatName.c_str()));
        pInstance->SetEditType(2);//¿É±à¼­²»¿Éɾ³ý

        // Texture
        if(strTexName != "") 
        {
            std::string strFile = m_strResourcesPath + strTexName;
            wchar_t* pChar = GStdStringTrans::Utf8ToUnicode(strFile.c_str());

            pInstance->SetUseDiffuseTexture(true);
            CAppearanceInstancePtr pDiffuseTexture = pInstance->GetDiffuseTexture();
            pDiffuseTexture->SetTextureFile(GStdStringTrans::WstringToString(pChar));
            delete [] pChar;

            pInstance->SetDiffuse(CVector4f(1.0f, 1.0f, 1.0f, color.W));
            pInstance->SetAmbient(CVector4f(1.0f, 1.0f, 1.0f, color.W));
        }

        WString id = GStdStringTrans::StringToWString(pInstance->GetId());
        m_pMaterialLibrary->UpdateMaterial(id);
        pStateSet = m_pMaterialLibrary->GetStateSetbyID(id).get();
        pStateSet->SetFaceMode(FM_FRONT_AND_BACK);
    }
    else
    {
        pStateSet = new CStateSet();
        pStateSet->SetDiffuse(diffuse);
        pStateSet->SetAmbient(diffuse);
        pStateSet->SetSpecular(CColor::Black);
        pStateSet->SetEmissive(CColor::Black);

        if(strTexName != "") 
        {
            std::string strFullPath = m_strResourcesPath.c_str() + strTexName;
            wchar_t* pChar = GStdStringTrans::Utf8ToUnicode(strFullPath.c_str());
            pStateSet->CreateTextureState(pChar);
            delete [] pChar;

            pStateSet->SetDiffuse(CColor(255, 255, 255, diffuse.A));
            pStateSet->SetAmbient(CColor(255, 255, 255, diffuse.A));
        }

        if ((alpha < 1.0))
        {
            pStateSet->SetSceneBlending(SBT_TRANSPARENT_ALPHA);
            pStateSet->SetAlphaTestReferenceValue(0.0f);
            pStateSet->SetAlphaTestFunction(FTF_GREATER);
        }

        pStateSet->SetFaceMode(FM_FRONT_AND_BACK);
        //pStateSet->SetLightModelTwoSided(true);
    }

    m_mapIdSkpMaterials[id] = skpMaterial;
    m_mapIdGGPmaterials[id] = pStateSet;
    return pStateSet;
}

std::wstring CSkpMeshImporterImpler::GetMaterialId(SUMaterialRef sktMaterial)
{
    for (auto it=m_mapIdSkpMaterials.begin(); it != m_mapIdSkpMaterials.end(); ++it)
    {
        if (SUAreEqual(sktMaterial, it->second))
        {
            return it->first;
        }
    }
    return L"";
}

CStateSet* CSkpMeshImporterImpler::GetStateSetByID(const std::wstring& materilId)
{
    auto it = m_mapIdGGPmaterials.find(materilId);
    if (it != m_mapIdGGPmaterials.end())
    {
        return it->second.get();
    }
    return nullptr;
}