/// <summary>
/// 创建拼图
/// </summary>
/// <param name="jigsawInfoData"></param>
private void createJigsaw(JigsawStyleEnum jigsawStyle, Texture2D pic2D, int horizontalNumber, int verticalJigsawNumber)
{
//创建拼图数据
listJigsawBean = CreateJigsawDataUtils.createJigsawDataList(jigsawStyle, horizontalNumber, verticalJigsawNumber, pic2D);
//创建拼图
CreateJigsawGameObjUtil.createJigsawGameObjList(listJigsawBean, pic2D);
containerList = CreateJigsawContainerObjUtil.createJigsawContainerObjList(listJigsawBean);
//初始化拼图位置
for (int i = 0; i < listJigsawBean.Count; i++)
{
JigsawBean item = listJigsawBean[i];
Vector3 jigsawPosition = new Vector3(
item.MarkLocation.x * item.JigsawWith - item.JigsawWith * horizontalNumber / 2f + item.JigsawWith / 2f,
item.MarkLocation.y * item.JigsawHigh - item.JigsawHigh * verticalJigsawNumber / 2f + item.JigsawHigh / 2f
);
containerList[i].transform.position = jigsawPosition;
//设置起始位置和角度
JigsawContainerCpt containerCpt = containerList[i].transform.GetComponent <JigsawContainerCpt>();
if (containerCpt != null)
{
containerCpt.startPosition = jigsawPosition;
containerCpt.startRotation = containerList[i].transform.rotation;
}
}
}
/// <summary>
/// 基础-设置item坐标点
/// </summary>
/// <param name="jigsawItem"></param>
public void baseSetListVerticesForItem(JigsawBean jigsawItem)
{
//添加中心点坐标
Vector3 centerVector = new Vector3(0, 0);
setCenterVector(jigsawItem, centerVector);
}
//-----------------------------------------------------------------------------------------------------------------------
/// <summary>
/// 根据图片获取item宽高和UV
/// </summary>
/// <param name="horizontalJigsawNumber"></param>
/// <param name="verticalJigsawNumber"></param>
/// <param name="jigsawPic"></param>
protected JigsawBean getWithAndHighByTexture2D(int horizontalJigsawNumber, int verticalJigsawNumber, Texture2D jigsawPic)
{
JigsawBean tempBean = new JigsawBean();
float picItemWith = (float)jigsawPic.width / (float)horizontalJigsawNumber;
float picItemHigh = (float)jigsawPic.height / (float)verticalJigsawNumber;
tempBean.JigsawUVWith = picItemWith / (float)jigsawPic.width;
tempBean.JigsawUVHigh = picItemHigh / (float)jigsawPic.height;
if (picItemWith > picItemHigh)
{
//拼图的高
tempBean.JigsawHigh = m_JigsawUnitSize;
//拼图的宽
tempBean.JigsawWith = tempBean.JigsawHigh * (picItemWith / picItemHigh);
}
else
{
//拼图的宽
tempBean.JigsawWith = m_JigsawUnitSize;
//拼图的高
tempBean.JigsawHigh = tempBean.JigsawWith * (picItemHigh / picItemWith);
}
return(tempBean);
}
/// <summary>
/// 设置UV坐标
/// </summary>
/// <param name="jigsawItem"></param>
public void baseSetListUVPositionForItem(JigsawBean jigsawItem)
{
List <Vector3> listVertices = jigsawItem.ListVertices;
Vector2 markLocation = jigsawItem.MarkLocation;
if (listVertices == null)
{
LogUtil.log("没有顶点坐标");
return;
}
if (markLocation == null)
{
LogUtil.log("没有标记坐标");
return;
}
List <Vector2> listUVposition = new List <Vector2>();
float xRatio = jigsawItem.JigsawWith / jigsawItem.JigsawUVWith;
float yRatio = jigsawItem.JigsawHigh / jigsawItem.JigsawUVHigh;
foreach (Vector3 item in listVertices)
{
float uvXposition = ((item.x + jigsawItem.JigsawWith / 2f) / xRatio) + (markLocation.x * jigsawItem.JigsawUVWith);
float uvYposition = ((item.y + jigsawItem.JigsawHigh / 2f) / yRatio) + (markLocation.y * jigsawItem.JigsawUVHigh);
listUVposition.Add(new Vector2(uvXposition, uvYposition));
}
setListUVPosition(jigsawItem, listUVposition);
}
/// <summary>
/// 增加碰撞
/// </summary>
/// <param name="jigsawContainerObj"></param>
public static CompositeCollider2D addCollider(GameObject jigsawContainerObj)
{
Transform[] childsTFs = jigsawContainerObj.GetComponentsInChildren <Transform>();
if (childsTFs != null)
{
int childsTFsSize = childsTFs.Length;
for (int childPosition = 0; childPosition < childsTFsSize; childPosition++)
{
Transform childsItemTF = childsTFs[childPosition];
NormalJigsawCpt jigsawItem = childsItemTF.GetComponent <NormalJigsawCpt>();
if (jigsawItem == null)
{
continue;
}
JigsawBean jigsawData = jigsawItem.getJigsawData();
if (jigsawData == null)
{
continue;
}
JigsawObjBuilder.setCollider2D(childsItemTF.gameObject, jigsawData.CenterVector, jigsawData.JigsawWith, jigsawData.JigsawHigh);
}
;
}
CompositeCollider2D jigsawContainerCollider = jigsawContainerObj.AddComponent <CompositeCollider2D>();
if (jigsawContainerCollider != null)
{
jigsawContainerCollider.geometryType = CompositeCollider2D.GeometryType.Polygons;
jigsawContainerCollider.generationType = CompositeCollider2D.GenerationType.Synchronous;
}
return(jigsawContainerCollider);
}
/// <summary>
/// 生成一个随机凹凸的拼图
/// </summary>
/// <param name="jigsawStyle"></param>
/// <param name="jigsawW"></param>
/// <param name="jigsawH"></param>
/// <returns></returns>
public static JigsawBean createJigsaw(JigsawStyleEnum jigsawStyle, float jigsawW, float jigsawH, Texture2D jigsawPic)
{
JigsawBean jigsawBean = new JigsawBean();
//按样式生成不同的拼图碎片
IBaseJigsawBuilder jigsawBuilder;
JigsawBulgeEnum[] bulge;
if (jigsawStyle == JigsawStyleEnum.Def)
{
jigsawBuilder = new NomralJigsawBuilder();
bulge = new JigsawBulgeEnum[4]
{
(JigsawBulgeEnum)DevUtil.getRandomInt(0, 2),
(JigsawBulgeEnum)DevUtil.getRandomInt(0, 2),
(JigsawBulgeEnum)DevUtil.getRandomInt(0, 2),
(JigsawBulgeEnum)DevUtil.getRandomInt(0, 2)
};
}
else
{
LogUtil.logError("没有相对于样式的拼图");
return(null);
}
return(jigsawBuilder.buildJigsaw(jigsawW, jigsawH, bulge, jigsawPic));
}
/// <summary>
/// 创建拼图对象
/// </summary>
/// <param name="jigsawData"></param>
/// <returns></returns>
public static GameObject createJigsawGameObj(JigsawBean jigsawData, Texture2D jigsawPic)
{
GameObject jigsawGameObj = JigsawObjBuilder.buildJigsawGameObj(jigsawData, jigsawPic);
jigsawData.JigsawGameObj = jigsawGameObj;
return(jigsawGameObj);
}
/// <summary>
/// 初始化数据
/// </summary>
private void initData()
{
jigsawInfoData = CommonData.SelectPuzzlesInfo.puzzlesInfo;
if (jigsawInfoData == null)
{
LogUtil.log("没有拼图数据");
return;
}
string resFilePath = jigsawInfoData.Data_file_path + jigsawInfoData.Mark_file_name;
int horizontalNumber = jigsawInfoData.Horizontal_number;
int verticalJigsawNumber = jigsawInfoData.Vertical_number;
if (resFilePath == null)
{
LogUtil.log("没有拼图图片路径");
return;
}
if (horizontalNumber == 0 || verticalJigsawNumber == 0)
{
LogUtil.log("没有拼图生成数量");
return;
}
Texture2D pic2D;
if (jigsawInfoData.Data_type.Equals((int)JigsawResourcesEnum.Custom))
{
WWW www = ResourcesManager.LoadLocationData(resFilePath);
pic2D = www.texture;
}
else
{
pic2D = ResourcesManager.LoadAssetBundlesTexture2DForBytes(resFilePath, jigsawInfoData.Mark_file_name);
}
if (pic2D == null)
{
LogUtil.log("没有源图片");
return;
}
//生成拼图
createJigsaw(CommonConfigure.PuzzlesShape, pic2D, horizontalNumber, verticalJigsawNumber);
//获取图片的高和宽
if (listJigsawBean != null && listJigsawBean.Count > 0)
{
JigsawBean itemJigsawBean = listJigsawBean[0];
picAllWith = itemJigsawBean.JigsawWith * horizontalNumber;
picAllHigh = itemJigsawBean.JigsawHigh * verticalJigsawNumber;
}
//生成围墙
createWall(CommonConfigure.BorderShape, CommonConfigure.BorderColor, picAllWith, picAllHigh);
//生成背景
createBackground(CommonConfigure.Background, picAllWith, picAllHigh);
//增加镜头控制
addCameraControl(picAllWith * CreateGameWallUtil.wallScale / 2f, picAllHigh * CreateGameWallUtil.wallScale / 2f);
//增加拼图控制
addJigsawControl(picAllWith * CreateGameWallUtil.wallScale / 2f, picAllHigh * CreateGameWallUtil.wallScale / 2f);
//启动动画
startAnim();
}
/// <summary>
/// 设置顶点坐标
/// </summary>
/// <param name="jigsaw"></param>
public void setListVertices(JigsawBean jigsaw, List <Vector3> listVertices)
{
if (jigsaw == null)
{
return;
}
jigsaw.ListVertices = listVertices;
}
/// <summary>
/// 设置拼图碎片对象
/// </summary>
/// <param name="jigsaw"></param>
public void setJigsawGameObj(JigsawBean jigsaw, GameObject gameObj)
{
if (jigsaw == null)
{
return;
}
jigsaw.JigsawGameObj = gameObj;
}
/// <summary>
/// 设置每个边的凹凸情况
/// </summary>
/// <param name="jigsawBulges">凹凸集合</param>
public void setBulgeEdge(JigsawBean jigsaw, JigsawBulgeEnum[] jigsawBulges)
{
if (jigsaw == null)
{
return;
}
jigsaw.ListBulge = jigsawBulges;
}
/// <summary>
/// 设置拼图块数
/// </summary>
/// <param name="jigsaw"></param>
/// <param name="jigsawNumber"></param>
public void setJigsawNumber(JigsawBean jigsaw, int jigsawNumber)
{
if (jigsaw == null)
{
return;
}
jigsaw.JigsawNumber = jigsawNumber;
}
/// <summary>
/// 设置拼图UV高
/// </summary>
/// <param name="jigsaw"></param>
/// <param name="jigsawHigh"></param>
public void setJigsawUVHigh(JigsawBean jigsaw, float jigsawUVHigh)
{
if (jigsaw == null)
{
return;
}
jigsaw.JigsawUVHigh = jigsawUVHigh;
}
/// <summary>
/// 设置拼图宽
/// </summary>
/// <param name="jigsaw"></param>
/// <param name="jigsawWith"></param>
public void setJigsawWith(JigsawBean jigsaw, float jigsawWith)
{
if (jigsaw == null)
{
return;
}
jigsaw.JigsawWith = jigsawWith;
}
/// <summary>
/// 设置当前样式
/// </summary>
public void setJigsawStyle(JigsawBean jigsaw, JigsawStyleEnum style)
{
if (jigsaw == null)
{
return;
}
jigsaw.JigsawStyle = style;
}
/// <summary>
/// 设置中心点坐标
/// </summary>
/// <param name="jigsaw"></param>
/// <param name="centerVector"></param>
public void setCenterVector(JigsawBean jigsaw, Vector3 centerVector)
{
if (jigsaw == null)
{
return;
}
jigsaw.CenterVector = centerVector;
}
/// <summary>
/// 设置UV坐标
/// </summary>
/// <param name="jigsaw"></param>
public void setListUVPosition(JigsawBean jigsaw, List <Vector2> listUVposition)
{
if (jigsaw == null)
{
return;
}
jigsaw.ListUVposition = listUVposition;
}
/// <summary>
/// 设置当前拼图碎片相对图片的坐标
/// </summary>
/// <param name="jigsaw"></param>
public void setMarkLocation(JigsawBean jigsaw, int markX, int markY)
{
if (jigsaw == null)
{
return;
}
Vector2 markVector = new Vector2(markX, markY);
jigsaw.MarkLocation = markVector;
}
/// <summary>
/// 设置拼图组件
/// </summary>
/// <param name="jigsawGameObj"></param>
private static void setJigsawCpt(GameObject jigsawGameObj, JigsawBean jigsawData)
{
JigsawStyleEnum jigsawStyle = jigsawData.JigsawStyle;
NormalJigsawCpt jigsawCpt = jigsawGameObj.AddComponent <NormalJigsawCpt>();
jigsawCpt.setJigsawData(jigsawData);
jigsawCpt.setEdgeMergeStatus(JigsawStyleNormalEdgeEnum.Left, JigsawMergeStatusEnum.Unincorporated);
jigsawCpt.setEdgeMergeStatus(JigsawStyleNormalEdgeEnum.Above, JigsawMergeStatusEnum.Unincorporated);
jigsawCpt.setEdgeMergeStatus(JigsawStyleNormalEdgeEnum.Right, JigsawMergeStatusEnum.Unincorporated);
jigsawCpt.setEdgeMergeStatus(JigsawStyleNormalEdgeEnum.Below, JigsawMergeStatusEnum.Unincorporated);
}
/// <summary>
/// 创建拼图容器对象
/// </summary>
/// <param name="jigsawData"></param>
/// <returns></returns>
public static GameObject createJigsawContainerObj(JigsawBean jigsawData)
{
GameObject jigsawGameObj = JigsawContainerGameObjBuilder.buildJigsawContainerObj();
JigsawContainerCpt containerCpt = jigsawGameObj.GetComponent <JigsawContainerCpt>();
if (jigsawData != null)
{
containerCpt.addJigsaw(jigsawData);
}
return(jigsawGameObj);
}
/// <summary>
/// 设置拼图块所有边的凹凸情况
/// </summary>
/// <param name="listJigsaw">所有的拼图块</param>
/// <param name="jigsawItem">当前拼图块</param>
protected void setBulgeEdgeForItem(List <JigsawBean> listJigsaw, JigsawBean jigsawItem)
{
JigsawBulgeEnum leftBulge = JigsawBulgeEnum.Smooth;
JigsawBulgeEnum rightBulge = JigsawBulgeEnum.Smooth;
JigsawBulgeEnum belowBulge = JigsawBulgeEnum.Smooth;
JigsawBulgeEnum aboveBulge = JigsawBulgeEnum.Smooth;
int listJigsawCount = listJigsaw.Count;
Vector2 markLocation = jigsawItem.MarkLocation;
if (markLocation == null)
{
return;
}
for (int childposition = 0; childposition < listJigsawCount; childposition++)
{
JigsawBean childJigsaw = listJigsaw[childposition];
Vector2 childMarkLocation = childJigsaw.MarkLocation;
if (markLocation == null)
{
continue;
}
if (childMarkLocation.y.Equals(markLocation.y))
{
if ((childMarkLocation.x - markLocation.x) == 1)
{
rightBulge = compareBulge(childJigsaw, JigsawStyleNormalEdgeEnum.Right);
}
else if ((childMarkLocation.x - markLocation.x) == -1)
{
leftBulge = compareBulge(childJigsaw, JigsawStyleNormalEdgeEnum.Left);
}
}
if (childMarkLocation.x.Equals(markLocation.x))
{
if ((childMarkLocation.y - markLocation.y) == 1)
{
aboveBulge = compareBulge(childJigsaw, JigsawStyleNormalEdgeEnum.Above);
}
else if ((childMarkLocation.y - markLocation.y) == -1)
{
belowBulge = compareBulge(childJigsaw, JigsawStyleNormalEdgeEnum.Below);
}
}
}
setBulgeEdge(jigsawItem, new JigsawBulgeEnum[4] {
leftBulge, aboveBulge, rightBulge, belowBulge
});
}
/// <summary>
/// 位置纠正
/// </summary>
/// <param name="mergeAnimDuration">纠正时间</param>
/// <param name="addListJigsaw">需要纠正位置的拼图</param>
public void jigsawLocationCorrect(float mergeAnimDuration, List <JigsawBean> addListJigsaw)
{
int jigsawListCount = addListJigsaw.Count;
if (jigsawListCount != 0)
{
JigsawBean baseJigsawItem = listJigsaw[0];
Transform baseTF = baseJigsawItem.JigsawGameObj.transform;
//获取基准拼图的标记位
Vector2 baseMarkLocation = baseJigsawItem.MarkLocation;
//获取基准拼图的世界坐标
Vector3 basePosition = baseTF.position;
//获取基准拼图的本地坐标
Vector3 baseLocationPosition = baseTF.InverseTransformPoint(basePosition);
for (int listPosition = 0; listPosition < jigsawListCount; listPosition++)
{
//获取纠正拼图数据
JigsawBean jigsawItem = addListJigsaw[listPosition];
//获取纠正拼图的标记坐标
Vector2 itemMarkLocation = jigsawItem.MarkLocation;
//获取纠正拼图的对象
Transform jigsawTF = jigsawItem.JigsawGameObj.transform;
//获取纠正于基准拼图的标记偏移量
Vector2 offsetMarkLocation = baseMarkLocation - itemMarkLocation;
//获取纠正于基准拼图的本地位置偏移量
Vector3 offsetPosition = new Vector2(offsetMarkLocation.x * jigsawItem.JigsawWith, offsetMarkLocation.y * jigsawItem.JigsawHigh);
//获取纠正拼图的本地位置
Vector3 jigsawItemLocationPosition = baseLocationPosition - offsetPosition;
//获取纠正拼图的世界坐标
Vector3 jigsawItemPosition = baseTF.TransformPoint(jigsawItemLocationPosition);
//设置位置
if (mergeAnimDuration <= 0)
{
jigsawTF.position = jigsawItemPosition;
jigsawTF.rotation = transform.rotation;
}
else
{
jigsawTF.DOMove(jigsawItemPosition, mergeAnimDuration);
jigsawTF.DORotate(transform.rotation.eulerAngles, mergeAnimDuration);
}
}
}
}
/// <summary>
/// 添加拼图块
/// </summary>
/// <param name="jigsawData"></param>
public void addJigsaw(JigsawBean jigsawData)
{
if (jigsawData == null)
{
LogUtil.logError("给拼图容器添加子拼图失败：没有JigsawBean");
return;
}
GameObject jigsawGameObj = jigsawData.JigsawGameObj;
if (jigsawGameObj == null)
{
LogUtil.logError("给拼图容器添加子拼图失败：没有JigsawGameObj");
return;
}
jigsawGameObj.transform.parent = null;
jigsawGameObj.transform.parent = transform;
listJigsaw.Add(jigsawData);
}
private IEnumerator createJigsaw()
{
while (isCreateJigsaw)
{
Texture2D texture2D = Texture2D.blackTexture;
JigsawBean jigsawBean = CreateJigsawDataUtils.createJigsaw(JigsawStyleEnum.Def, 1f, 1f, texture2D);
GameObject jigsawObj = JigsawObjBuilder.buildJigsawGameObj(jigsawBean, texture2D);
float startX = DevUtil.getRandomFloat(-(int)(DevUtil.GetScreenWith() / 2f), (int)(DevUtil.GetScreenWith() / 2f));
float startY = DevUtil.GetScreenHeight() / 2f;
float endX = DevUtil.getRandomFloat(-(int)(DevUtil.GetScreenWith() / 2f), (int)(DevUtil.GetScreenWith() / 2f));
float endY = -DevUtil.GetScreenHeight() / 2f;
Vector3 startPosition = new Vector3(startX, startY, 2);
jigsawObj.transform.position = startPosition;
jigsawObj.transform.DOMove(new Vector3(endX, endY, 2), 10);
yield return(new WaitForSeconds(1f));
}
}
/// <summary>
/// 获取该拼图附近能合并的点坐标
/// </summary>
public Dictionary <Vector2, Vector3> getMergeVectorList()
{
Dictionary <Vector2, Vector3> mapMergeList = new Dictionary <Vector2, Vector3>();
int listJigsawCount = listJigsaw.Count;
for (int jigsawPosition = 0; jigsawPosition < listJigsawCount; jigsawPosition++)
{
JigsawBean jigsawData = listJigsaw[jigsawPosition];
GameObject jigsawObj = jigsawData.JigsawGameObj;
Transform jigsawTF = jigsawObj.transform;
Vector3 jigsawLocation = jigsawTF.InverseTransformPoint(jigsawTF.position);
Vector2 leftMarkLocation = new Vector2(jigsawData.MarkLocation.x - 1, jigsawData.MarkLocation.y);
Vector3 leftVector = jigsawLocation + Vector3.left * jigsawData.JigsawWith;
Vector2 aboveMarkLocation = new Vector2(jigsawData.MarkLocation.x, jigsawData.MarkLocation.y + 1);
Vector3 aboveVector = jigsawLocation + Vector3.up * jigsawData.JigsawHigh;
Vector2 rightMarkLocation = new Vector2(jigsawData.MarkLocation.x + 1, jigsawData.MarkLocation.y);
Vector3 rightVector = jigsawLocation + Vector3.right * jigsawData.JigsawWith;
Vector2 belowMarkLocation = new Vector2(jigsawData.MarkLocation.x, jigsawData.MarkLocation.y - 1);
Vector3 belowVector = jigsawLocation + Vector3.down * jigsawData.JigsawHigh;
if (!mapMergeList.ContainsKey(leftMarkLocation))
{
mapMergeList.Add(leftMarkLocation, jigsawTF.TransformPoint(leftVector));
}
if (!mapMergeList.ContainsKey(aboveMarkLocation))
{
mapMergeList.Add(aboveMarkLocation, jigsawTF.TransformPoint(aboveVector));
}
if (!mapMergeList.ContainsKey(rightMarkLocation))
{
mapMergeList.Add(rightMarkLocation, jigsawTF.TransformPoint(rightVector));
}
if (!mapMergeList.ContainsKey(belowMarkLocation))
{
mapMergeList.Add(belowMarkLocation, jigsawTF.TransformPoint(belowVector));
}
}
return(mapMergeList);
}
/// <summary>
/// 获取所有拼图坐标
/// </summary>
/// <returns></returns>
public Dictionary <Vector2, Vector3> getJigsawPositionVectorList()
{
Dictionary <Vector2, Vector3> mapJigsawPositionVectorList = new Dictionary <Vector2, Vector3>();
int listJigsawCount = listJigsaw.Count;
for (int jigsawPosition = 0; jigsawPosition < listJigsawCount; jigsawPosition++)
{
JigsawBean jigsawData = listJigsaw[jigsawPosition];
GameObject jigsawObj = jigsawData.JigsawGameObj;
Transform jigsawTF = jigsawObj.transform;
Vector3 jigsawLocation = jigsawTF.position;
if (!mapJigsawPositionVectorList.ContainsKey(jigsawData.MarkLocation))
{
mapJigsawPositionVectorList.Add(jigsawData.MarkLocation, jigsawLocation);
}
}
return(mapJigsawPositionVectorList);
}
public override void setListVerticesForItem(JigsawBean jigsawItem)
{
base.baseSetListVerticesForItem(jigsawItem);
float withX = jigsawItem.JigsawWith / 2f;
float highY = jigsawItem.JigsawHigh / 2f;
//根据凹凸属性生成坐标点
List <Vector3> listVertices = new List <Vector3>();
JigsawBulgeEnum[] listBulge = jigsawItem.ListBulge;
JigsawBulgeEnum leftBulge = listBulge[0];
JigsawBulgeEnum aboveBulge = listBulge[1];
JigsawBulgeEnum rightBulge = listBulge[2];
JigsawBulgeEnum belowBulge = listBulge[3];
//添加起始点
listVertices.Add(jigsawItem.CenterVector);
//添加左下角点
listVertices.Add(new Vector3(-withX, -highY));
//添加左边点
getTrapezoidVertices(listVertices, leftBulge, Direction2DEnum.Left, withX, highY);
//添加左上角点
listVertices.Add(new Vector3(-withX, highY));
//添加上边点
getTrapezoidVertices(listVertices, aboveBulge, Direction2DEnum.Above, withX, highY);
//添加右上角点
listVertices.Add(new Vector3(withX, highY));
//添加右边
getTrapezoidVertices(listVertices, rightBulge, Direction2DEnum.Right, withX, highY);
//添加右下角点
listVertices.Add(new Vector3(withX, -highY));
//添加下边
getTrapezoidVertices(listVertices, belowBulge, Direction2DEnum.Below, withX, highY);
setListVertices(jigsawItem, listVertices);
}
/// <summary>
/// 基础-创建数据列表
/// </summary>
/// <param name="horizontalJigsawNumber"></param>
/// <param name="verticalJigsawNumber"></param>
/// <param name="jigsawPic"></param>
/// <returns></returns>
public List <JigsawBean> baseBuildJigsawList(JigsawStyleEnum style, int horizontalJigsawNumber, int verticalJigsawNumber, Texture2D jigsawPic)
{
// 根据图片获取item宽高和UV
JigsawBean tempBean = getWithAndHighByTexture2D(horizontalJigsawNumber, verticalJigsawNumber, jigsawPic);
// 获取拼图总块数
int jigsawTotalNumber = verticalJigsawNumber * horizontalJigsawNumber;
List <JigsawBean> listJigsawBean = new List <JigsawBean>();
for (int horizontal = 0; horizontal < horizontalJigsawNumber; horizontal++)
{
for (int vertical = 0; vertical < verticalJigsawNumber; vertical++)
{
//生成拼图对象
JigsawBean jigsawItem = new JigsawBean();
//确认拼图样式
setJigsawStyle(jigsawItem, style);
//确认当前拼图碎片相对图片的坐标
setMarkLocation(jigsawItem, horizontal, vertical);
//设置拼图长宽
setJigsawHigh(jigsawItem, tempBean.JigsawHigh);
setJigsawWith(jigsawItem, tempBean.JigsawWith);
setJigsawUVHigh(jigsawItem, tempBean.JigsawUVHigh);
setJigsawUVWith(jigsawItem, tempBean.JigsawUVWith);
setJigsawNumber(jigsawItem, jigsawTotalNumber);
listJigsawBean.Add(jigsawItem);
}
}
int listJigsawBeanCount = listJigsawBean.Count;
for (int jigsawposition = 0; jigsawposition < listJigsawBeanCount; jigsawposition++)
{
JigsawBean jigsawItem = listJigsawBean[jigsawposition];
//确认拼图每个边的凹凸情况
setBulgeEdgeForItem(listJigsawBean, jigsawItem);
//确认拼图顶点坐标和UVposition
setListVerticesForItem(jigsawItem);
baseSetListUVPositionForItem(jigsawItem);
}
return(listJigsawBean);
}
/// <summary>
/// 设置顶点坐标
/// </summary>
/// <param name="jigsawItem"></param>
public override void setListVerticesForItem(JigsawBean jigsawItem)
{
List <Vector3> listVertices = new List <Vector3>();
base.baseSetListVerticesForItem(jigsawItem);
float withX = jigsawItem.JigsawWith / 2f;
float highY = jigsawItem.JigsawHigh / 2f;
//添加起始点
listVertices.Add(jigsawItem.CenterVector);
//添加左下角点
listVertices.Add(new Vector3(-withX, -highY));
//添加左上角点
listVertices.Add(new Vector3(-withX, highY));
//添加右上角点
listVertices.Add(new Vector3(withX, highY));
//添加右下角点
listVertices.Add(new Vector3(withX, -highY));
setListVertices(jigsawItem, listVertices);
}
/// <summary>
/// 设置UV坐标集
/// </summary>
/// <param name="jigsawItem"></param>
public override void setListUVPosition(JigsawBean jigsawItem)
{
List <Vector3> listVertices = jigsawItem.ListVertices;
if (listVertices == null)
{
LogUtil.log("没有顶点坐标");
return;
}
List <Vector2> listUVposition = new List <Vector2>();
float jigsawWithAndr = jigsawItem.JigsawWith + m_JigsawBulgeR;
float jigsawHighAndr = jigsawItem.JigsawHigh + m_JigsawBulgeR;
float picRatio;
if (jigsawItem.JigsawUVWith > jigsawItem.JigsawUVHigh)
{
picRatio = jigsawItem.JigsawUVHigh / jigsawHighAndr;
}
else
{
picRatio = jigsawItem.JigsawUVWith / jigsawWithAndr;
}
float xRatio = 1 / jigsawItem.JigsawUVWith;
float yRatio = 1 / jigsawItem.JigsawUVHigh;
foreach (Vector3 item in listVertices)
{
float uvXposition = (((item.x + jigsawWithAndr / 2f) * picRatio)) * xRatio;
float uvYposition = (((item.y + jigsawHighAndr / 2f) * picRatio)) * yRatio;
listUVposition.Add(new Vector2(uvXposition, uvYposition));
}
setListUVPosition(jigsawItem, listUVposition);
}