unity之uv贴图画圆弧，圆弧面，不规则图形

由于最近一直没有时间，所以这篇博客一直没发，下面我说说uv画圆弧，圆面，不规则面拼接。

先来两张效果图

图截的不咋滴，凑合着看吧，画圆弧主要用的贝塞尔曲线画的，我感觉这个比较简单，当然大家也可以使用圆的方程，抛物线的方程都可以实现这种效果

但是我比较倾向于用贝塞尔，如果大家会ps的话，知道里边有一个钢笔工具，他就是贝塞尔的原理，贝塞尔的算法大家可以去网上搜搜，

贝塞尔计算方法类网上也有很多

下面先上我的代码

using UnityEngine;
 
[System.Serializable]
 
public class Bezier : System.Object
 
{
 
	public Vector3 p0;
 
	public Vector3 p1;
 
	public Vector3 p2;
 
	public Vector3 p3;
 
	public float ti = 0f;
 
	private Vector3 b0 = Vector3.zero;
 
	private Vector3 b1 = Vector3.zero;
 
	private Vector3 b2 = Vector3.zero;
 
	private Vector3 b3 = Vector3.zero;
 
	private float Ax;
 
	private float Ay;
 
	private float Az;
 
	private float Bx;
 
	private float By;
 
	private float Bz;
 
	private float Cx;
 
	private float Cy;
 
	private float Cz;
 
	public Bezier( Vector3 v0, Vector3 v1, Vector3 v2, Vector3 v3 )
 
	{
 
		this.p0 = v0;
 
		this.p1 = v1;
 
		this.p2 = v2;
 
		this.p3 = v3;
 
	}
 
	// 0.0 >= t <= 1.0
 
	public Vector3 GetPointAtTime( float t )
 
	{
 
		this.CheckConstant();
 
		float t2 = t * t;
 
		float t3 = t * t * t;
 
		float x = this.Ax * t3 + this.Bx * t2 + this.Cx * t + p0.x;
 
		float y = this.Ay * t3 + this.By * t2 + this.Cy * t + p0.y;
 
		float z = this.Az * t3 + this.Bz * t2 + this.Cz * t + p0.z;
 
		return new Vector3( x, y, z );
 
	}
 
	private void SetConstant()
 
	{
 
		this.Cx = 3f * ( ( this.p0.x + this.p1.x ) - this.p0.x );
 
		this.Bx = 3f * ( ( this.p3.x + this.p2.x ) - ( this.p0.x + this.p1.x ) ) - this.Cx;
 
		this.Ax = this.p3.x - this.p0.x - this.Cx - this.Bx;
 
		this.Cy = 3f * ( ( this.p0.y + this.p1.y ) - this.p0.y );
 
		this.By = 3f * ( ( this.p3.y + this.p2.y ) - ( this.p0.y + this.p1.y ) ) - this.Cy;
 
		this.Ay = this.p3.y - this.p0.y - this.Cy - this.By;
 
		this.Cz = 3f * ( ( this.p0.z + this.p1.z ) - this.p0.z );
 
		this.Bz = 3f * ( ( this.p3.z + this.p2.z ) - ( this.p0.z + this.p1.z ) ) - this.Cz;
 
		this.Az = this.p3.z - this.p0.z - this.Cz - this.Bz;
 
	}
 
	// Check if p0, p1, p2 or p3 have changed
 
	private void CheckConstant()
 
	{
 
		if( this.p0 != this.b0 || this.p1 != this.b1 || this.p2 != this.b2 || this.p3 != this.b3 )
 
		{
 
			this.SetConstant();
 
			this.b0 = this.p0;
 
			this.b1 = this.p1;
 
			this.b2 = this.p2;
 
			this.b3 = this.p3;
 
		}
 
	}
 
}

这就是贝塞尔计算类，很简单的计算方法，

using UnityEngine;
using System.Collections;
using System.Collections.Generic;
 
public class TriangleSubdivision  :MonoBehaviour{
	public static int[] TriangulatePolygon (Vector2[] XZofVertices) {
		//
		int VertexCount = XZofVertices.Length;
		//minx miny  maxx maxy
        float xmin = XZofVertices[0].x;
        float ymin = XZofVertices[0].y;
        float xmax = xmin;
        float ymax = ymin;
        for (int ii1 = 1; ii1 < VertexCount; ii1++)
        {
			if (XZofVertices[ii1].x < xmin)
			{
				xmin = XZofVertices[ii1].x;
			}
			else if (XZofVertices[ii1].x > xmax)
			{
				xmax = XZofVertices[ii1].x;
			}
			if (XZofVertices[ii1].y < ymin)
			{
				ymin = XZofVertices[ii1].y;
			}
			else if (XZofVertices[ii1].y > ymax)
			{
				ymax = XZofVertices[ii1].y;
			}
        }
        float dx = xmax - xmin;
        float dy = ymax - ymin;
        float dmax = (dx > dy) ? dx : dy;
        float xmid = (xmax + xmin) * 0.5f;
        float ymid = (ymax + ymin) * 0.5f;
        Vector2[] ExpandedXZ = new Vector2[3 + VertexCount];
        for (int ii1 = 0; ii1 < VertexCount; ii1++)
        {
			ExpandedXZ[ii1] = XZofVertices[ii1];
        }
		ExpandedXZ[VertexCount] = new Vector2((xmid - 2 * dmax), (ymid - dmax));
        ExpandedXZ[VertexCount + 1] = new Vector2(xmid, (ymid + 2 * dmax));
        ExpandedXZ[VertexCount + 2] = new Vector2((xmid + 2 * dmax), (ymid - dmax));
		List<Triangle> TriangleList = new List<Triangle>();
        TriangleList.Add(new Triangle(VertexCount, VertexCount+1, VertexCount+2));
        for (int ii1 = 0; ii1 < VertexCount; ii1++)
        {
			//检查构成的三角形
			List<Edge> Edges = new List<Edge>();
			for (int ii2 = 0; ii2 < TriangleList.Count; ii2++)
			{
				if (TriangulatePolygonSubFunc_InCircle(ExpandedXZ[ii1], ExpandedXZ[TriangleList[ii2].p1],ExpandedXZ[TriangleList[ii2].p2],ExpandedXZ[TriangleList[ii2].p3]))
				{
					Edges.Add(new Edge(TriangleList[ii2].p1, TriangleList[ii2].p2));
		            Edges.Add(new Edge(TriangleList[ii2].p2, TriangleList[ii2].p3));
		            Edges.Add(new Edge(TriangleList[ii2].p3, TriangleList[ii2].p1));
		            TriangleList.RemoveAt(ii2);
		            ii2--;
				}
			}
			if (ii1 >= VertexCount) { continue; }
			//判断相同的三个点构成的三角形
			for (int ii2 = Edges.Count - 2; ii2 >= 0; ii2--)
			{
				for (int ii3 = Edges.Count - 1; ii3 >= ii2 + 1; ii3--)
				{
					if (Edges[ii2].Equals(Edges[ii3]))
					{
						Edges.RemoveAt(ii3);
						Edges.RemoveAt(ii2);
                        ii3--;
                        continue;
					}
				}
			}
			for (int ii2 = 0; ii2 < Edges.Count; ii2++)
            {
				TriangleList.Add(new Triangle(Edges[ii2].p1, Edges[ii2].p2, ii1));
			}
            Edges.Clear();
            Edges = null;
		}
		//大于点集外围的点
        for (int ii1 = TriangleList.Count - 1; ii1 >= 0; ii1--)
        {
			if (TriangleList[ii1].p1 >= VertexCount ||TriangleList[ii1].p2 >= VertexCount ||TriangleList[ii1].p3 >= VertexCount)
            {
				TriangleList.RemoveAt(ii1);
			}
        }
		//不在房间内的面
		for(int ii3 = 0;ii3<TriangleList.Count;ii3++){
			if(TriangleInPolygonOuter(XZofVertices,XZofVertices[TriangleList[ii3].p1],XZofVertices[TriangleList[ii3].p2],XZofVertices[TriangleList[ii3].p3])){
				TriangleList.RemoveAt(ii3);
				ii3--;
			}
		}
        TriangleList.TrimExcess();
        int[] Triangles = new int[3 * TriangleList.Count];
        for (int ii1 = 0; ii1 < TriangleList.Count; ii1++)
        {
			Triangles[3 * ii1] = TriangleList[ii1].p1;
	        Triangles[3 * ii1 + 1] = TriangleList[ii1].p2;
	        Triangles[3 * ii1 + 2] = TriangleList[ii1].p3;
        }
		return Triangles;
	}
	static bool TriangulatePolygonSubFunc_InCircle(Vector2 p, Vector2 p1, Vector2 p2, Vector2 p3) {
		if (Mathf.Abs(p1.y - p2.y) < 0.0000001&&Mathf.Abs(p2.y - p3.y) < 0.0000001)
        {
			return false;
		}
        float m1, m2, mx1, mx2, my1, my2, xc, yc;
        if (Mathf.Abs(p2.y - p1.y) < 0.0000001)
        {
			m2 = -(p3.x - p2.x) / (p3.y - p2.y);
            mx2 = (p2.x + p3.x) * 0.5f;
            my2 = (p2.y + p3.y) * 0.5f;
            xc = (p2.x + p1.x) * 0.5f;
            yc = m2 * (xc - mx2) + my2;
        }
        else if (Mathf.Abs(p3.y - p2.y) < 0.0000001)
        {
            m1 = -(p2.x - p1.x) / (p2.y - p1.y);
            mx1 = (p1.x + p2.x) * 0.5f;
            my1 = (p1.y + p2.y) * 0.5f;
            xc = (p3.x + p2.x) * 0.5f;
            yc = m1 * (xc - mx1) + my1;
        }
        else
        {
            m1 = -(p2.x - p1.x) / (p2.y - p1.y);
            m2 = -(p3.x - p2.x) / (p3.y - p2.y);
            mx1 = (p1.x + p2.x) * 0.5f;
            mx2 = (p2.x + p3.x) * 0.5f;
            my1 = (p1.y + p2.y) * 0.5f;
            my2 = (p2.y + p3.y) * 0.5f;
            xc = (m1 * mx1 - m2 * mx2 + my2 - my1) / (m1 - m2);
            yc = m1 * (xc - mx1) + my1;
        }
		float dx = p2.x - xc;
        float dy = p2.y - yc;
        float rsqr = dx * dx + dy * dy;
        dx = p.x - xc;
        dy = p.y - yc;
        double drsqr = dx * dx + dy * dy;
        return (drsqr <= rsqr);
    }
	static bool TriangleInPolygonOuter(Vector2[] pList,Vector2 p1,Vector2 p2,Vector2 p3){
		Vector2[] centerPoint = new Vector2[3];
		centerPoint[0] = new Vector2((p1.x+p2.x)/2,(p1.y+p2.y)/2);
		centerPoint[1] = new Vector2((p1.x+p3.x)/2,(p1.y+p3.y)/2);
		centerPoint[2] = new Vector2((p3.x+p2.x)/2,(p3.y+p2.y)/2);
		for(int j = 0,crossNum = 0;j<centerPoint.Length;j++){
	        for (int i = 0; i < pList.Length; i++)
	        {
				if (IsPointInLine(centerPoint[j].x, centerPoint[j].y, pList[i].x, pList[i].y, pList[(i+1)%pList.Length].x, pList[(i+1)%pList.Length].y)==0)
	            {
	                crossNum=crossNum+1;
					continue;
	            }else if(IsPointInLine(centerPoint[j].x, centerPoint[j].y, pList[i].x, pList[i].y, pList[(i+1)%pList.Length].x, pList[(i+1)%pList.Length].y)==2){
					crossNum = 1;
					break;
				}
	        }
			if ((crossNum % 2) == 0)
			{
				return true;
	        }
			crossNum = 0;
		}
 
        return false;
	}
	//0   在外  1  在内   2  边上
	static int IsPointInLine(float x,float y,float x1,float y1,float x2,float y2)
    {
		float maxY =y1;
        float minY = y2;
		if(y1>y2){
		    maxY = y1;
			minY = y2;
		}else{
			maxY = y2;
			minY = y1;
		}
		float averageX = (x1+x2)/2;
		float averageY = (y1+y2)/2;
		if(y==averageY&&x==averageX){
			return 2;
		}
        if (y < maxY && y >minY)
        {
            if (x >(x1 + (x2 - x1) * (y - y1) / (y2 - y1)))
            {
                return 0;
            }
        }
        return 1;
    }
}
 struct Triangle
{
	public int p1;
    public int p2;
    public int p3;
    public Triangle(int point1, int point2, int point3)
    {
		p1 = point1; p2 = point2; p3 = point3;
    }
}
class Edge
{
	public int p1;
	public int p2;
	public Edge(int point1, int point2)
    {
		p1 = point1; p2 = point2;
    }
	public Edge() : this(0, 0)
    {}
	public bool Equals(Edge other)
    {
		return ((this.p1 == other.p2) && (this.p2 == other.p1)) ||((this.p1 == other.p1) && (this.p2 == other.p2));
    }
}

这个类上一张已经说过了，就是画不规则图形的类，不过我这篇文章是把圆和不规则拼接出带有圆弧状的图形，看图大家就会明白了

using UnityEngine;
using System.Collections;
 
public class ChartletManager : System.Object {
	Bezier myBezier;
	public ChartletManager(){
 
	}
	public GameObject WallChartletInMesh(GameObject obj,Vector3 startPoint,Vector3 endPoint,float height,Texture2D tex,float excursion,float zoom)
	{
		myBezier = new Bezier( startPoint,  new Vector3( excursion, zoom, 0f ),  new Vector3( excursion, zoom, 0f ), endPoint);
		MeshFilter	myFilter = (MeshFilter)obj.GetComponent (typeof(MeshFilter));
		Mesh myMesh = myFilter.mesh;
		Vector3[] myVertices = new Vector3[52];
		for(int i = 0;i<52;i++){
			if(i<26){
				myVertices[i] = myBezier.GetPointAtTime( (float)((i) *0.04) );
				myVertices[i] = new Vector3(myVertices[i].x,myVertices[i].y,myVertices[i].z-height);
			}else{
				myVertices[i] = myBezier.GetPointAtTime( (float)((i-26) *0.04) );
				myVertices[i] = new Vector3(myVertices[i].x,myVertices[i].y,myVertices[i].z);
			}
		}
		myMesh.vertices = myVertices;
		int[] myTriangles = new int[52 * 3];
		for(int i = 0; i < 52; i++){
			if(i<25){
				myTriangles[i*3] = 26+i;
				myTriangles[i*3+1] = i;
				myTriangles[i*3+2] = i+1;
			}else if(i == 25||i==51){
				myTriangles[i*3] = 0;
				myTriangles[i*3+1] = 0;
				myTriangles[i*3+2] = 0;
			}else{
				myTriangles[i*3+2] = i;
				myTriangles[i*3+1] = i+1;
				myTriangles[i*3] = i-25;
			}
		}
		Vector2[] myuvs = new Vector2[52];
		for (int i = 0; i < 52; i++) {
			myuvs [i] = new Vector2 ( (myVertices [i].x),  (myVertices [i].y));
		}
		myMesh.triangles = myTriangles;
		myMesh.uv = myuvs;
		myMesh.RecalculateBounds ();
		myMesh.RecalculateNormals ();
		obj.renderer.material.mainTexture = tex;
		return obj;
	}
	public GameObject CircleChartletInMesh(GameObject obj,Vector3 startPoint,Vector3 endPoint,Texture2D tex,float excursion,float zoom)
	{
		myBezier = new Bezier( startPoint,  new Vector3( excursion, zoom, 0f ),  new Vector3( excursion, zoom, 0f ), endPoint);
		MeshFilter	myFilter = (MeshFilter)obj.GetComponent (typeof(MeshFilter));
		Mesh myMesh = myFilter.mesh;
 
		Vector3[] myVertices = new Vector3[27];
		myVertices[0] = new Vector3(0,0,0);
		for(int i =0; i <= 25; i++)
		{
			myVertices[i+1]  = myBezier.GetPointAtTime( (float)(i *0.04) );
		}
 
		myMesh.vertices = myVertices;
 
		Vector2[] myuvs = new Vector2[27];
		for (int i = 0; i < 27; i++) {
			myuvs [i] = new Vector2 ( (myVertices [i].x),  (myVertices [i].y));
		}
		myMesh.triangles = TriangleSubdivision.TriangulatePolygon(myuvs);
		myMesh.uv = myuvs;
		myMesh.RecalculateBounds ();
		myMesh.RecalculateNormals ();
		obj.renderer.material.mainTexture = tex;
		return obj;
	}
	public GameObject CircleAndTriangleChartletInMesh(GameObject obj,Vector3 startPoint,Vector3 endPoint,Vector3[] points,Texture2D tex,float excursion,float zoom)
	{
		myBezier = new Bezier( startPoint,  new Vector3( excursion, zoom, 0f ),  new Vector3( excursion, zoom, 0f ), endPoint);
		MeshFilter	myFilter = (MeshFilter)obj.GetComponent (typeof(MeshFilter));
		Mesh myMesh = myFilter.mesh;
		Vector3[] myVertices = new Vector3[27+points.Length];
 
		myVertices[0] = new Vector3((startPoint.x+endPoint.x)/2,(startPoint.y+endPoint.y)/2,(startPoint.z+endPoint.z)/2);
		for(int i =0; i <= 25; i++)
		{
			myVertices[i+1]  = myBezier.GetPointAtTime( (float)(i *0.04) );
		}
		for(int i = 27;i<27+points.Length;i++){
			myVertices[i] = points[i-27];
		}
		myMesh.vertices = myVertices;
		Vector2[] myuvs = new Vector2[27+points.Length];
		for (int i = 0; i < myuvs.Length; i++) {
			myuvs [i] = new Vector2 ( (myVertices [i].x),  (myVertices [i].y));
		}
		myMesh.triangles = TriangleSubdivision.TriangulatePolygon(myuvs);
		myMesh.uv = myuvs;
 
		myMesh.RecalculateBounds ();
		myMesh.RecalculateNormals ();
		obj.renderer.material.mainTexture = tex;
		return obj;
	}
}

为了方便大家测试，我把我的测试放在了一个类里，大家直接调这个方法即可，我是测试用的，大家可以修改成自己的脚本

using UnityEngine;
 
public class MyBezier : MonoBehaviour
 
{
	public Bezier myBezier;
	public GameObject circleline;
	public Texture2D tex;
	void Start()
	{
 
		GameObject floorTexture = (GameObject)Instantiate(circleline,new Vector3(0,0,10),Quaternion.Euler(new Vector3(0,0,0)));
		GameObject wallTexture =(GameObject) Instantiate(circleline,new Vector3(0,0,10),Quaternion.Euler(new Vector3(0,0,0)));
		ChartletManager chartlet = new ChartletManager();
		Vector3[] ceilVertices = new Vector3[4];
		ceilVertices[0] = new Vector3(-4,0,0);
		ceilVertices[1] = new Vector3(-4,-5,0);
		ceilVertices[2] = new Vector3(4,-5,0);
		ceilVertices[3] = new Vector3(4,0,0);
//		ceilVertices[1] = new Vector3(-5,1,0);
//		ceilVertices[2] = new Vector3(-5,-4,0);
//		ceilVertices[3] = new Vector3(-2,-4.5f,0);
//		ceilVertices[4] = new Vector3(-2.5f,-2,0);
//		ceilVertices[5] = new Vector3(2,-2.5f,0);
//		ceilVertices[6] = new Vector3(2.5f,-4,0);
//		ceilVertices[7] = new Vector3(5,-4,0);
//		ceilVertices[8] = new Vector3(5,0,0);
//		ceilVertices[9] = new Vector3(4,0,0);
 
		wallTexture= chartlet.WallChartletInMesh(wallTexture,new Vector3( -4f, 0f, 0f ),new Vector3( 4f, 0f, 0f ),3.0f,tex,0,6);
		floorTexture= chartlet.CircleAndTriangleChartletInMesh(floorTexture,new Vector3( -4f, 0f, 0f ),new Vector3( 4f, 0f, 0f ),ceilVertices,tex,0,6);
	}
 
}

测试用例，大家可以做自己想要的东西了，CircleAndTriangleChartletInMesh(GameObject obj,Vector3 startPoint,Vector3 endPoint,Vector3[] points

,Texture2D tex,float excursion,float zoom)

我解释一下这个类的传递参数吧

obj,就是传进来的obj对象，大家可以使用out，那个直接能用了

startPoint圆弧起始点

endPoint终点圆弧点

points 是传入的不规则图形的各个点

tex 是那张贴图

excursion这个是圆弧的 倾斜度

zoom是圆弧的大小就是圆弧顶点到起始点于终止点中间的那个点的距离   正规半圆这个值应该是圆半径的1.5倍

using UnityEngine;
 
public class MyBezier : MonoBehaviour
 
{
	public Bezier myBezier;
	public GameObject circleline;
	public Texture2D tex;
	void Start()
	{
 
		GameObject floorTexture = (GameObject)Instantiate(circleline,new Vector3(0,0,10),Quaternion.Euler(new Vector3(0,0,0)));
		GameObject wallTexture =(GameObject) Instantiate(circleline,new Vector3(0,0,10),Quaternion.Euler(new Vector3(0,0,0)));
		ChartletManager chartlet = new ChartletManager();
		Vector3[] ceilVertices = new Vector3[10];
		ceilVertices[0] = new Vector3(-4,0,0);
//		ceilVertices[1] = new Vector3(-4,-5,0);
//		ceilVertices[2] = new Vector3(4,-5,0);
//		ceilVertices[3] = new Vector3(4,0,0);
		ceilVertices[1] = new Vector3(-5,1,0);
		ceilVertices[2] = new Vector3(-5,-4,0);
		ceilVertices[3] = new Vector3(-2,-4.5f,0);
		ceilVertices[4] = new Vector3(-2.5f,-2,0);
		ceilVertices[5] = new Vector3(2,-2.5f,0);
		ceilVertices[6] = new Vector3(2.5f,-4,0);
		ceilVertices[7] = new Vector3(5,-4,0);
		ceilVertices[8] = new Vector3(5,0,0);
		ceilVertices[9] = new Vector3(4,0,0);
 
		wallTexture= chartlet.WallChartletInMesh(wallTexture,new Vector3( -4f, 0f, 0f ),new Vector3( 4f, 0f, 0f ),3.0f,tex,3,8);
		floorTexture= chartlet.CircleAndTriangleChartletInMesh(floorTexture,new Vector3( -4f, 0f, 0f ),new Vector3( 4f, 0f, 0f ),ceilVertices,tex,3,8);
	}
 
}

如果我数值改改就会出现这种，zoom就是倾斜程度，当然也可以是负数，是往里凹进去的，excursion是负数就向另一个方向倾斜。

凹进去的就是这种情况，具体情况大家可以测试，值的范围有限制的，超出了，会出现空的情况，当然我写的也有很多不足之处，大家可以修改修改

不知为何 csdn编辑问题，我的图片文字与代码都混合了 所以乱了 我把我的工程打包上去 大家可以下载看看具体实现效果

下载地址

http://download.csdn.net/detail/pzw0416/6727303

unity之uv贴图画圆弧，圆弧面，不规则图形的更多相关文章

unity多边形uv地图
我曾经写过一篇文章,不规则图形uv地图.(http://blog.csdn.net/itolfn/article/details/17240131)我用三角算法.但是,这种方法已经不完全,有一个指明: ...
使用CSS 3创建不规则图形文字围绕
前言 CSS 创建复杂图形的技术即将会被广泛支持,并且应用到实际项目中.本篇文章的目的是为大家开启它的冰山一角.我希望这篇文章能让你对不规则图形有一个初步的了解. 现在,我们已经可以使用CSS 3 常 ...
qt button以及label实现不规则图形（五种方法：使用QSS，设置Mask图片，自己画）
1.方法1:准备一张边界是透明的不规则图形 QPushButton * pbtn = new QPushButton; pbtn->setStyleSheet("QPushBut ...
border三角形阴影(不规则图形阴影)和多重边框的制作
前言:这是笔者学习之后自己的理解与整理.如果有错误或者疑问的地方,请大家指正,我会持续更新! 1. border的组合写法 border:border-width border-style borde ...
使用CSS 3创建不规则图形
前言 CSS 创建复杂图形的技术即将会被广泛支持,并且应用到实际项目中.本篇文章的目的是为大家开启它的冰山一角.我希望这篇文章能让你对不规则图形有一个初步的了解. 现在,我们已经可以使用CSS 3 常 ...
WPF入门(三)->几何图形之不规则图形(PathGeometry) (2)
原文:WPF入门(三)->几何图形之不规则图形(PathGeometry) (2) 上一节我们介绍了PathGeometry中LineSegment是点与点之间绘制的一条直线,那么我们这一节来看 ...
WPF入门(三)->几何图形之不规则图形(PathGeometry)
原文:WPF入门(三)->几何图形之不规则图形(PathGeometry) 前面我们给大家介绍了LineGeometry,EllipseGeometry,CombinedGeometry等一些规 ...
css border 三角形阴影(不规则图形阴影) & 多重边框的制作
前言:这是笔者学习之后自己的理解与整理.如果有错误或者疑问的地方,请大家指正,我会持续更新! border 的组合写法 border:border-width border-style border- ...
Open gl 的不规则图形的4联通种子递归填充和扫描线种子递归填充算法实现
实验题目:不规则区域的填充算法实验目的:验证不规则区域的填充算法实验内容:利用VC与OpenGL,实现不规则区域的填充算法. 1.必做:实现简单递归的不规则区域填充算法. 2.选做:针对简单递归算 ...

随机推荐

mobile web 手机开发
1. -webkit-tap-highlight-color -webkit-tap-highlight-color:rgba(255,255,255,0); 用来把android上点击网页时出现 ...
Module中引用Module中的Activity时报错了，错误是找不到R文件中的id引用
1.好像库modul和主modul不能有相同名字和layout文件 2.资源文件名冲突导致的
[转贴]JavaScript中Array（数组）的属性和方法
数组有四种定义的方式使用构造函数:var a = new Array();var b = new Array(8); var c = new Array("first", &qu ...
Android利用Fiddler进行网络数据抓包,手机抓包工具汇总
Fiddler抓包工具 Fiddler抓包工具很好用的,它可以干嘛用呢,举个简单例子,当你浏览网页时,网页中有段视频非常好,但网站又不提供下载,用迅雷下载你又找不到下载地址,这个时候,Fiddler抓 ...
UVA122-Trees on the level(链二叉树)
Trees on the level Time Limit: 3000MS Memory Limit: Unknown 64bit IO Format: %lld & %llu Sub ...
c++11新特性(4) lambda捕捉块
lambda表达式中的方括号成为捕捉块,能够在这里指定怎样从所在的作用域中捕捉变量. 捕捉的意思是指能够在该lambda中使用该变量.即能够捕获外部变量在lambda表达式内使用. 能够使用两种方式来 ...
linux下emacs安装
1.下载地址:http://ftp.gnu.org/pub/gnu/emacs/ 下载文件:emacs-24.2.tar.gz 步骤: 一.安装依赖文件: (先进入root:终端中输入 su -) ...
dans le quartier
culture /kyltyr/ 文化 une école [ekɔl] un cinéma un musée une église un théâtre [teɑtr] un opéra [ɔp ...
If We Were a Child Again
Description The Problem The first project for the poor student was to make a calculator that can jus ...
在数组中找几个数的和等于某个数[LeetCode]
首先明确一点,这个方面的问题设计到的知识点是数组的查找的问题.对于类似的这样的查找操作的具体办法就是三种解决方法: 1.暴力算法,多个for循环,很高的时间复杂度 2.先排序,然后左右夹逼,但是这样会 ...

unity之uv贴图画圆弧，圆弧面，不规则图形

unity之uv贴图画圆弧，圆弧面，不规则图形的更多相关文章

随机推荐

热门专题