思想
 
递归生成
判断是否超过边界
超过就不再生成
所以核心是边界函数
定义不同的边界函数就会生成不同的棱柱
 
	public void CreateMap (int length)
	{
		len = length + 1;
		if (grids != null)
		{
			ResetMap ();
		}
		//开始递归
		AutoCreateMap (Vector3.zero, new Point (0, 0));
	}

	Dictionary<Point, Vector3> offsetDic;
	public void InitOffsetDic ()
	{
		if (offsetDic == null)
		{
			offsetDic = new Dictionary<Point, Vector3> ();
			borderPoint = new List<Point> ();
			grids = new Dictionary<Point, Grid> ();
		}

		offsetDic.Add (new Point (1, -1), new Vector3 (1.5f, 0, -0.87f));
		offsetDic.Add (new Point (-1, -1), new Vector3 (-1.5f, 0, -0.87f));
		offsetDic.Add (new Point (1, 1), new Vector3 (1.5f, 0, 0.87f));
		offsetDic.Add (new Point (-1, 1), new Vector3 (-1.5f, 0, 0.87f));
		offsetDic.Add (new Point (0, 2), new Vector3 (0, 0, 1.73f));
		offsetDic.Add (new Point (0, -2), new Vector3 (0, 0, -1.73f));
	}

	






	void AutoCreateMap (Vector3 originPos, Point gridPos)
	{
		if (IsInBorder (originPos) && !grids.ContainsKey (gridPos))
		{

			Grid floor = GridPool.Inst.GetFloor (originPos, gridPos);
			grids.Add (gridPos, floor);

			foreach (var pair in offsetDic)
			{
				if (!IsInBorder (originPos + pair.Value))
				{
					floor.IsBorder = true;
					Renderer render = floor.floor.GetComponent<Renderer> ();
					render.material.color = new Color (81, 128, 248) / 255;
					borderPoint.Add (gridPos + pair.Key);

					Rigidbody rigi = floor.floor.GetComponent<Rigidbody> ();
					rigi.isKinematic = true;
				}
				else
				{
					AutoCreateMap (originPos + pair.Value, gridPos + pair.Key);
				}
			}

		}

	}


	//3^0.5 *border  border*2
	//3^0.5 *border  border*2
	public bool IsInBorder (Vector3 pos)
	{
		float x = Mathf.Abs (pos.x);
		float z = Mathf.Abs (pos.z);
		float borderX = 0, borderY = 1.73f * len / 2 + 0.2f;
		if (x == 0)
		{
			borderX = len;
			//Debug.Log (borderX);
		}
		else
		{
			//y = (x)*-1.73f+1.73*len

			borderX = (z - 1.73f * len) / -1.73f + 0.2f;
		}


		return x < borderX && z < borderY ? true : false;
	}

       继续设计文献里面的模型
 
 
 
一、设计多个六棱柱
 
       1）Matlab代码
 
%%All hex are oriented such that the incident light
%%is along the x axis and strikes the circular face of the hex
R = [20, 20, 20]; %Hex center to side distance
H = [10, 10, 10]; %Hex height
hex = 3; %number of cylinders (including ring)
offX = zeros(1,hex);
offY = zeros(1,hex);
offZ = zeros(1,hex);
%   offX = [0,-40,40]; %User defined offsets
    offY = [18,-18,-18]; %user defined offsets
    offZ = [0,21,-21]; %user defined offsets
%%Calculation variables for output file documantation
X = H;
Y = R*1.5;
Z = R*1.5;
Xd = X;
Yd = Y*2;
Zd = Z*2;
Out = [0 0 0 0 0 0 0];
d = 1; %dipole #
di = 1; %inner dipole #
for off = 1:hex;
    for i = (-Z(1,off)+offZ(1,off)):(Z(1,off)+offZ(1,off))
        for j = (-Y(1,off)+offY(1,off)):(Y(1,off)+offY(1,off))
            for k = (0+offX(1,off)):(X(1,off)+offX(1,off))
                L1 = (abs(sqrt(3)/2*(j-offY(1,off))+1/2*(i-offZ(1,off))));
                L2 = (abs(sqrt(3)/2*(j-offY(1,off))-1/2*(i-offZ(1,off))));
                L3 = ((i-offZ(1,off))^2 + (j-offY(1,off))^2)^.5;
                if L1 <= R(1,off) && L2 <= R(1,off) && abs(i-offZ(1,off))<= R(1,off);
                    Out = [Out; d k j i 1 1 1];
                    d = d + 1;
                end
            end
        end
    end
end
Out(1,:) = [];
d = d - 1;
di = di - 1;
fid = fopen('output.txt', 'w');
fprintf(fid, ' >TARCEL: Hexagons; AX,AY,AZ= %7.4f %7.4f %7.4f', Xd, Yd, Zd);
fprintf(fid, '\r\n %8.0f %8.0f = NAT, NIN,', d, di);
fprintf(fid, '\r\n 1.000000 0.000000 0.000000 = A_1 vector\r\n 0.000000 1.000000 0.000000 = A_2 vector');
fprintf(fid, '\r\n 1.000000 1.000000 1.000000 = lattice spacings (d_x,d_y,d_z)/d');
fprintf(fid, '\r\n -0.50000 -0.50000 -0.50000 = lattice offset x0(1-3) = (x_TF,y_TF,z_TF)/d for dipole 0 0 0');
fprintf(fid, '\r\n JA IX IY IZ ICOMP(x,y,z)\r\n');
fprintf(fid,'%7d %3d %3d %3d %1d %1d %1d\r\n', Out');
fclose(fid);
foldername = sprintf('%dHex%dR%dH',hex,R(1,1),H(1,1));
folderpath = strcat(foldername,'/');
filename = sprintf('%dHex%dR%dH.txt',hex,R(1,1),H(1,1));
mkdir(foldername);
copyfile('output.txt',filename);
copyfile('output.txt','shape.dat');
movefile(filename, folderpath);
movefile('shape.dat',folderpath);% 将shape.dat文件移动到 %dSpheres%dR%dr/ 文件夹中

% 后面的也是一些文件复制移动的操作，大家可以注释掉，需要用的话得去掉注释自行修改代码，否则会报错
% copyfile('Ag.txt',folderpath);
% copyfile('Ti.txt',folderpath);
% copyfile('ddscat.exe',folderpath);
% copyfile('ddscat2.par','ddscat.par');
% movefile('ddscat.par',folderpath);
% disp(['Sucess, file saved to: ', foldername]);
 
       2）ddscat.par文件
 
       先放一个会报错的ddscat.par文件。
 
       
 
       下面是在命令行中运行的报错结果。
 
       
 
       报错的原因暂时还没有找到，但是可以确定的是，其中X=3.00000D-01中的X表示的是入射光的波长。因为我改变过波长的值，这个值也会跟着改变，继续报错。小范围的波长改动依然会继续报错，但是大范围的波长改动，会导致程序一直迭代下去，不会终止，且error误差值很大。
 
 
 
       3）近场图
 
       报这个错误最大的问题是，在ddpostprocess后处理之后，虽然产生了vtr文件，但是在vislt里面无法读取模型的强度值，即无法可视化。
 
       
 
 
 
        4）正确的ddscat.par文件
 
       在尝试了很多次的改动之后，终于改出了可以正常运行不报错、可以可视化的配置文件。结果其实很简单，就是把介电常数的种类配置为两个。虽然这个纯六棱柱模型是由一种物质构成的，但是我们设置有两种配置文件没有什么影响，只要shape文件里面只出现1，不出现2就行。结果，这样一改，反而结果正确了。
 
       
 
       
 
       5）成功的近场图
 
       
 
       6）模型的3D散点图
 
       之后尽量给大家加上模型的一个三维散点图，除了在电厂图可视化的情况下认识模型，也同时在偶极子构成概念上了解模型。
 
       
 
 
 
二、设计多个圆柱核六棱柱壳模型
 
       1）Matlab代码
 
       
 
%%All hex are oriented such that the incident light
%%is along the x axis and strikes the circular face of the hex
R = [20, 20, 20]; %Hex center to side distance
H = [20, 20, 20]; %Hex height
Ri = [10, 10, 10]; %Hex core radius
hex = 3; %number of cylinders (including ring)
offX = zeros(1,hex);
offY = zeros(1,hex);
offZ = zeros(1,hex);
% offX = [0,-40,40];
offY = [18,-18,-18];
offZ = [0,21,-21];
%% calculation parameters used for output documentation file
X = H;
Y = R*1.5;
Z = R*1.5;
Xd = X; %diameter
Yd = Y*2;
Zd = Z*2;
Xs = Ri*2;
Ys = Ri*2;
Zs = Ri*2;
Out = [0 0 0 0 0 0 0];
d = 1; %dipole #
di = 1; %inner dipole #
for off = 1:hex;
    for i = (-Z(1,off)+offZ(1,off)):(Z(1,off)+offZ(1,off))
        for j = (-Y(1,off)+offY(1,off)):(Y(1,off)+offY(1,off))
            for k = (0+offX(1,off)):(X(1,off)+offX(1,off))
                L1 = (abs(sqrt(3)/2*(j-offY(1,off))+1/2*(i-offZ(1,off))));
                L2 = (abs(sqrt(3)/2*(j-offY(1,off))-1/2*(i-offZ(1,off))));
                L3 = ((i-offZ(1,off))^2 + (j-offY(1,off))^2)^.5;
                if L1 <= R(1,off) && L2 <= R(1,off) && abs(i-offZ(1,off))<= R(1,off);
                    if L3 <= Ri;
                        Out = [Out; d k j i 1 1 1];
                        d = d + 1;
                        di = di + 1;
                    else
                        Out = [Out; d k j i 2 2 2];
                        d = d + 1;
                    end
                end
            end
        end
    end
end
Out(1,:) = [];
d = d - 1;
di = di - 1;
fid = fopen('output.txt', 'w');
fprintf(fid, ' >TARCEL: Hexegons with Cores; AX,AY,AZ= %7.4f %7.4f %7.4f BX,BY,BZ= %7.4f %7.4f %7.4f', Xd, Yd, Zd, Xs, Ys, Zs);
fprintf(fid, '\r\n %8.0f %8.0f = NAT, NIN,', d, di);
fprintf(fid, '\r\n 1.000000 0.000000 0.000000 = A_1 vector\r\n 0.000000 1.000000 0.000000 = A_2 vector');
fprintf(fid, '\r\n 1.000000 1.000000 1.000000 = lattice spacings (d_x,d_y,d_z)/d');
fprintf(fid, '\r\n -0.50000 -0.50000 -0.50000 = lattice offset x0(1-3) = (x_TF,y_TF,z_TF)/d for dipole 0 0 0');
fprintf(fid, '\r\n JA IX IY IZ ICOMP(x,y,z)\r\n');
fprintf(fid,'%7d %3d %3d %3d %1d %1d %1d\r\n', Out');
fclose(fid);
foldername = sprintf('%dHexCore%dR%dr%dH',hex,R(1,1),Ri(1,1),H(1,1));
folderpath = strcat(foldername,'/');
filename = sprintf('%dHexCore%dR%dr%dH.txt',hex,R(1,1),Ri(1,1),H(1,1));
mkdir(foldername);
copyfile('output.txt',filename);
copyfile('output.txt','shape.dat');
movefile(filename, folderpath);
movefile('shape.dat',folderpath);% 将shape.dat文件移动到 %dSpheres%dR%dr/ 文件夹中

% 后面的也是一些文件复制移动的操作，大家可以注释掉，需要用的话得去掉注释自行修改代码，否则会报错
% copyfile('Ag.txt',folderpath);
% copyfile('Ti.txt',folderpath);
% copyfile('ddscat.exe',folderpath);
% copyfile('ddscat2.par','ddscat.par');
% movefile('ddscat.par',folderpath);
% disp(['Sucess, file saved to: ', foldername]);
 
 
 
       2）ddscat.par文件
 
       
 
' ========== Parameter file for v7.3 ===================' 
'**** Preliminaries ****'
'NOTORQ' = CMTORQ*6 (DOTORQ, NOTORQ) -- either do or skip torque calculations
'PBCGS2' = CMDSOL*6 (PBCGS2, PBCGST, GPBICG, QMRCCG, PETRKP) -- CCG method
'GPFAFT' = CMETHD*6 (GPFAFT, FFTMKL) -- FFT method
'GKDLDR' = CALPHA*6 (GKDLDR, LATTDR, FLTRCD) -- DDA method
'NOTBIN' = CBINFLAG (NOTBIN, ORIBIN, ALLBIN)
'**** Initial Memory Allocation ****'
150 150 150 = dimensioning allowance for target generation
'**** Target Geometry and Composition ****'
'FROM_FILE' = CSHAPE*9 shape directive
no SHPAR parameters needed
2         = NCOMP = number of dielectric materials
'../diel/SiO2' = file with refractive index 1
'../diel/Au_evap' = file with refractive index 2
'**** Additional Nearfield calculation? ****'
1 = NRFLD (=0 to skip nearfield calc., =1 to calculate nearfield E)
0.0 0.0 0.0 0.0 0.0 0.0 (fract. extens. of calc. vol. in -x,+x,-y,+y,-z,+z)
'**** Error Tolerance ****'
1.00e-5 = TOL = MAX ALLOWED (NORM OF |G>=AC|E>-ACA|X>)/(NORM OF AC|E>)
'**** Maximum number of iterations ****'
2000     = MXITER
'**** Integration cutoff parameter for PBC calculations ****'
1.00e-2 = GAMMA (1e-2 is normal, 3e-3 for greater accuracy)
'**** Angular resolution for calculation of <cos>, etc. ****'
0.5	= ETASCA (number of angles is proportional to [(3+x)/ETASCA]^2 )
'**** Vacuum wavelengths (micron) ****'
0.300 0.300 1 'LIN' = wavelengths (first,last,how many,how=LIN,INV,LOG)
'**** Refractive index of ambient medium'
1.0000 = NAMBIENT
'**** Effective Radii (micron) **** '
0.03 0.03 1 'LIN' = eff. radii (first, last, how many, how=LIN,INV,LOG)
'**** Define Incident Polarizations ****'
(0,0) (1.,0.) (0.,0.) = Polarization state e01 (k along x axis)
2 = IORTH  (=1 to do only pol. state e01; =2 to also do orth. pol. state)
'**** Specify which output files to write ****'
1 = IWRKSC (=0 to suppress, =1 to write ".sca" file for each target orient.
'**** Specify Target Rotations ****'
0.    0.   1  = BETAMI, BETAMX, NBETA  (beta=rotation around a1)
0.    0.   1  = THETMI, THETMX, NTHETA (theta=angle between a1 and k)
0.    0.   1  = PHIMIN, PHIMAX, NPHI (phi=rotation angle of a1 around k)
'**** Specify first IWAV, IRAD, IORI (normally 0 0 0) ****'
0   0   0    = first IWAV, first IRAD, first IORI (0 0 0 to begin fresh)
'**** Select Elements of S_ij Matrix to Print ****'
6	= NSMELTS = number of elements of S_ij to print (not more than 9)
11 12 21 22 31 41	= indices ij of elements to print
'**** Specify Scattered Directions ****'
'LFRAME' = CMDFRM (LFRAME, TFRAME for Lab Frame or Target Frame)
1 = NPLANES = number of scattering planes
0.  0. 180. 5 = phi, theta_min, theta_max (deg) for plane A
90. 0. 180. 5 = phi, theta_min, theta_max (deg) for plane B
 
       这里的配置其实和上一个模型的正确配置文件的参数是一模一样的，不过这次是没有出现问题的。
 
 
 
       3）近场图
 
       
 
       4）模型的3D散点图
 
       
 
 
 
       继续加油
 
 
 
     【DDSCAT——离散偶极近似仿真程序01】概念和说明书介绍
 
     【DDSCAT——离散偶极近似仿真程序02】初步运行案例程序
 
     【DDSCAT——离散偶极近似仿真程序03】近场计算及其呈现
 
     【DDSCAT——离散偶极近似仿真程序04】参数理解和模型设计
 
     【DDSCAT——离散偶极近似仿真程序05】模型设计Matlab代码：多核壳球 、多核壳圆柱
 
     【DDSCAT——离散偶极近似仿真程序06】模型设计Matlab代码：多六棱柱 、多圆柱核六棱柱壳
 
     【DDSCAT——离散偶极近似仿真程序07】模型设计Matlab代码：圆环套多个圆柱
 
     【DDSCAT——离散偶极近似仿真程序08】如何在Linux系统上运行DDSCAT程序
 
     【DDSCAT——离散偶极近似仿真程序09】如何下载ifort安装文件
 
     【DDSCAT——离散偶极近似仿真程序10】DDSCAT内置示例运行结果
 
     【DDSCAT——离散偶极近似仿真程序11】DDSCAT目标方向的调整
 
     【DDSCAT——离散偶极近似仿真程序12】calltarget与vtrconvert程序的使用
 
     【DDSCAT——离散偶极近似仿真程序13】ParaView可视化工具的使用及其与Vislt的对比
 
     【DDSCAT——离散偶极近似 用户手册中文翻译稿 0201】
 
     【DDSCAT——离散偶极近似 用户手册中文翻译稿 0202】
 
     【DDSCAT——离散偶极近似 用户手册中文翻译稿 0203】
 
     【DDSCAT——离散偶极近似 用户手册中文翻译稿 0204】
 
     【DDSCAT——离散偶极近似 用户手册中文翻译稿 0205】

transition
 
 
 
transition：property duration timing-function delay；
 
 
property：指定哪个属性需要过度（例如 width 、bgc等）
 注意：all 一次应用全部属性，但不建议全部属性，因为效率低下且所有样式的过度效果都一样，多个属性可以整体逗号隔开
duration：过度时间
timing-function：控制过度动画速度（linear-匀速 ease-减慢 ease-in-加速 ease-out-减速 ease-in-out-先加速后减速 steps(n)-可以让过度效果分为指定几次来完成，更多自定义过度速度 cubic-bezier），其中 steps 可以实现打字机效果
delay：过度效果的延迟
 
三要素（缺一不可）：
 1、元素属性改变（可以hover、active等）
 2、指定需要改变的属性
 3、改变时间
 
注意：
 1、浏览器兼容
 2、属性触发结束，默认会动画回原来的样式
 3、无法为一些状态值添加过度效果，例如 display 等
 
perspective
 
 
 
perspective：mpx；（设置三维透视距离，近大远小）
 
 
m大小取决多远看图，如果创建一个200px的立方体盒子，perspective < 100px 则相当于在盒子内部看结果，如果 perspective 非常大，那就是站在非常远的地方看盒子，以为 perspective 指定了观察者于 z = 0 平面的距离使三维位置变换元素产生透视的效果，对动画不应用此值
 
 
 
perspective-origin：水平 垂直；（设置相机在水平面的位置，改变观察角度）
 
 
transform（都可独立针对xyz一方向改变）
 
二维：
 
transform-origin：水平 垂直；（自定义中心点的位置）
旋转：transform：rotate（deg）（默认以中心点顺时针旋转）
平移：transform：translate（水平，垂直）（默认参照元素的左上角）
缩放：transform：scale（水平，垂直）传入数字代表放大缩小倍数，若只传一个数 则xy同步变化
斜切：transform：skew（水平deg，垂直deg）若只传一个数 代表沿x轴斜切，若角度值为正，则往当前轴负方向斜切，反之角度值为负，则正向斜切
综合：transform：translate（x，y） scale（num） skew（x，y） rotate（deg）；
 
（会改变坐标系，所以 rotate 不推荐放前面）
 
三维（二维和三维推荐使用三维，渲染效果更好）：
 
transform: translate3d(x方向的偏移，y方向的偏移，z方向的偏移);
transform: scale3d(x方向的缩放，y方向的缩放，z方向的缩放);
transform: rotate3d(x,y,z,angle)
 x,y,z：代表x,y,z方向上的一个向量值,围绕着向量旋转
 angle：代表角度
 例如：transform: rotate3d(1,0,0,30deg);
 
 
 
transform-style：preserve-3d；（由于页面二维，所以上面三条设置看不出来，想要看效果，需要在父元素中设置此属性）
 
 
再结合 translate+rotate 做立方体（先rotate（改变坐标系）再translate（固定数值））
 
添加 perspective 增强透视效果，对动画不应用此值
 
/* 立方体动画 */
        ul {
            width: 200px;
            height: 200px;
            margin: 100px auto;
            transform: rotate3d(1, 1, 0, 0deg);
            transform-style: preserve-3d;
            position: relative;
            animation: lunbo 5s infinite linear;
        }

        @keyframes lunbo {
            form {
                transform: rotate3d(1, 1, 0, 0deg);
            }
            to {
                transform: rotate3d(1, 1, 0, 360deg);
            }
        }

        ul li {
            width: 200px;
            height: 200px;
            list-style: none;
            text-align: center;
            opacity: .8;
            position: absolute;
            left: 0;
            top: 0;
        }

        ul li:nth-of-type(1) {
            background-color: #ffff00;
            transform: translateZ(100px);
        }

        ul li:nth-of-type(2) {
            background-color: #0ff3ff;
            transform: rotateX(90deg) translateZ(100px);
        }

        ul li:nth-of-type(3) {
            background-color: #334455;
            transform: rotateX(180deg) translateZ(100px);
        }

        ul li:nth-of-type(4) {
            background-color: #F07AFA;
            transform: rotateX(270deg) translateZ(100px);
        }

        ul li:nth-of-type(5) {
            background-color: #f98769;
            transform: rotateY(90deg) translateZ(100px);
        }

        ul li:nth-of-type(6) {
            background-color: #954210;
            transform: rotateY(270deg) translateZ(100px);
        }
 
/* 六棱柱动画 */
        ul {
            width: 200px;
            height: 200px;
            transform-style: preserve-3d;
            position: absolute;
            left: 400px;
            top: 500px;

            animation: lunbo 10s infinite linear;
        }

        @keyframes lunbo {
            from {
                transform: rotateX(-20deg) rotateY(0deg);
            }
            to {
                transform: rotateX(-20deg) rotateY(360deg);
            }
        }

        ul:hover {
            animation-play-state: paused;
        }

        ul:hover li {
            opacity: 0.3;
        }

        ul li:hover {
            opacity: 1;
        }

        ul li {
            width: 200px;
            height: 200px;
            list-style: none;
            float: left;
            position: absolute;
            left: 0;
            top: 0;
        }

        ul li:nth-of-type(1) {
            background-color: #60be47;
            transform: rotateY(60deg) translateZ(200px);
        }

        ul li:nth-of-type(2) {
            background-color: #8c902e;
            transform: rotateY(120deg) translateZ(200px);
        }

        ul li:nth-of-type(3) {
            background-color: #a66853;
            transform: rotateY(180deg) translateZ(200px);
        }

        ul li:nth-of-type(4) {
            background-color: #604483;
            transform: rotateY(240deg) translateZ(200px);
        }

        ul li:nth-of-type(5) {
            background-color: #43b3bb;
            transform: rotateY(300deg) translateZ(200px);
        }

        ul li:nth-of-type(6) {
            background-color: #9a7d94;
            transform: rotateY(360deg) translateZ(200px);
        }
 
animation（与过度区别：无需人为触发）
 
animation: name duration timing-function delay iteration-count direction fill-mode;
 
这三步必须有：
 
 
 
（1）animation-name：指定动画名称
 （2）@kframes name{ from{ }to{ }} 或是{0%{ } 25%{ }等等}
 （3）animation-duration：指定动画时间
 
 
animation-timing-function：控制过度动画速度（linear-匀速 ease-减慢 ease-in-加速 ease-out-减速 ease-in-out-先加速后减速 steps(n)-可以让过度效果分为指定几次来完成，，更多自定义过度速度 cubic-bezier），其中 steps 可以实现打字机效果
animation-delay：延迟时间
animation-iteration-count：动画次数（infinite-无限次）
animation-direction：动画方向（alternate-往返）
animation-play-state：动画状态（默认running 设置paused为暂停）
animation-fill-mode：none；（forwards-最后一帧停止； backwards-如果动画有初始状态，如初始旋转，那么立刻进入初始状态，前提：添加了动画延迟； both-前面两个都有）
 
简写：animation：name 时长 速度 delay 动画次数 往返与否；（name和时长必须有）
 
实例：
 
        div {
            width: 200px;
            height: 200px;
            background-color: #f98769;
            animation: move 2s infinite ease-in;
        }

        /*创建动画*/
        @keyframes move {
            0% {
                transform: translate(0, 0);
            }
            33% {
                transform: translate(500px, 500px);
            }
            66% {
                transform: translate(500px, 0);
            }
            100% {
                transform: translate(0, 0);
            }
        }

        div:hover {
            animation-play-state: paused;
        }
 
注：
 
如果有和默认样式中同名的样式，会覆盖默认样式
编写动画中，固定不变的值写在前面，需要变化的值写在后面
 
box-shadow
 
 
 
box-shadow：水平 垂直 模糊度 阴影扩展 阴影颜色 内外阴影（默认外阴影，inset传入内阴影）；
 
 
多层阴影：box-shadow：水平 垂直 模糊度 阴影扩展 阴影颜色 内外阴影（默认外阴影，inset传入内阴影），水平 垂直 模糊度 阴影扩展 阴影颜色 内外阴影（默认外阴影，inset传入内阴影），等等；
 
text-shadow
 
 
 
text-shadow：水平 垂直 模糊度 阴影颜色（默认跟从文字颜色）；
 
 
多层阴影：text-shadow：水平 垂直 模糊度 阴影颜色（默认跟从文字颜色），水平 垂直 模糊度 阴影颜色（默认跟从文字颜色），等等；
 
box-sizing
 
box-sizing: content-box|border-box|inherit;
 
值
描述
content-box
border和padding不计算入width之内，width=内容(默认属性)
border-box
width=内容+padding+border(怪异模式)
inherit
规定应从父元素继承 box-sizing 属性的值
注：
 
表单的 input、select 默认的样式是不同的，所以就造成了 width 设置的一样，但就是对不齐，可以设置box-sizing:border-box;来解决不一致问题
通过设置box-sizing:border-box;防止因为设置padding或border而导致盒子宽高改变，稳固网页结构
 
border-radius
 
/*四个角都一样*/
border-radius: 10px;
/*左上/右下，右上/左下*/
border-radius: 10px 20px;
/*左上，右上/左下，右下*/
border-radius: 10px 20px 30px;
/*左上，右上，右下，左下*/
border-radius: 10px 20px 30px 40px;
/*添加/是用来设置当前不同方向的半径值，水平x方向/垂直y方向，下面这个可用来绘制椭圆*/
border-radius: 100px/50px;
/*设置某一圆角*/
border-top-right-radius: 20px;
/*设置某个角点的两个方向上的不同圆角值，类似添加/*/
border-top-right-radius: 100px 50px;
/*设置四个角点的不同方向上的不同角值，代表：（水平方向的 左上，右上，右下，左下）/（垂直方向的 左上，右上，右下，左下）*/
border-radius: 90px 80px 60px 100px/50px 60px 70px 80px;

前几课我们绘制的是平面的图形，下面我们要绘制一个立体的图形——六棱柱，这里我们使用了顶点索引，这是一个新的概念，它是一个指明了顶点绘制顺序的ByteBuffer，还有就是这里我们使用的是二维的顶点数组，其中第二维中所有的顶点是同一个平面上的点，所以我们是一个面一个面的绘制，Polygon 类改动的代码较多，其他类基本不变，下面一一描述：
 
public class Polygon {

	// 保存每一个平面的顶点索引的ByteBuffer数组
	private ByteBuffer[] indexBuffer;

	// 保存每一个平面的顶点坐标的FloatBuffer数组
	private FloatBuffer[] faceVertexBuffer;

	// 保存每一个平面的顶点坐标的二维数组

	private float[][] faceVertices = { new float[] { -0.5f, -0.816f, 1.0f,// bottom
																			// left
																			// 0
			0.5f, -0.816f, 1.0f,// bottom right 1
			-1.0f, 0.0f, 1.0f,// middle left 2
			1.0f, 0.0f, 1.0f,// middle right 3
			-0.5f, 0.816f, 1.0f, // top left 4
			0.5f, 0.816f, 1.0f // top right 5
			},// front face
			new float[] { -0.5f, -0.816f, -1.0f,// bottom left 6
					0.5f, -0.816f, -1.0f,// bottom right 7
					-1.0f, 0.0f, -1.0f,// middle left 8
					1.0f, 0.0f, -1.0f,// middle right 9
					-0.5f, 0.816f, -1.0f, // top left 10
					0.5f, 0.816f, -1.0f // top right 11
			},// back face
			new float[] { -0.5f, -0.816f, -1.0f,// bottom left 6
					0.5f, -0.816f, -1.0f,// bottom right 7
					-0.5f, -0.816f, 1.0f,// bottom left 0
					0.5f, -0.816f, 1.0f // bottom right 1
			},// bottom face
			new float[] { -1.0f, 0.0f, -1.0f,// middle left 8
					-0.5f, -0.816f, -1.0f,// bottom left 6
					-1.0f, 0.0f, 1.0f,// middle left 2
					-0.5f, -0.816f, 1.0f // bottom left 0
			},// bottom left face
			new float[] { 0.5f, -0.816f, -1.0f,// bottom right 7
					1.0f, 0.0f, -1.0f,// middle right 9
					0.5f, -0.816f, 1.0f,// bottom right 1
					1.0f, 0.0f, 1.0f // middle right 3
			},// bottom right face
			new float[] { 0.5f, 0.816f, -1.0f, // top right 11
					1.0f, 0.0f, -1.0f,// middle right 9
					0.5f, 0.816f, 1.0f,// top right 5
					1.0f, 0.0f, 1.0f // middle right 3
			},// top right face
			new float[] { -0.5f, 0.816f, -1.0f, // top left 10
					0.5f, 0.816f, -1.0f, // top right 11
					-0.5f, 0.816f, 1.0f,// top left 4
					0.5f, 0.816f, 1.0f // top right 5
			},// top face
			new float[] { -0.5f, 0.816f, -1.0f, // top left 10
					-1.0f, 0.0f, -1.0f,// middle left 8
					-0.5f, 0.816f, 1.0f, // top left 4
					-1.0f, 0.0f, 1.0f // middle left 2
			} // top left face
	};

	// 定义每一个平面颜色的数组

	private float[] colors = { 1.0f, 0.0f, 0.0f, 1.0f, // 0
			0.0f, 1.0f, 0.0f, 1.0f,// 1
			0.0f, 0.0f, 1.0f, 1.0f, // 2
			1.0f, 1.0f, 1.0f, 1.0f, // 3
			1.0f, 1.0f, 0.0f, 1.0f,// 4
			1.0f, 0.0f, 1.0f, 1.0f,// 5
			0.0f, 1.0f, 1.0f, 1.0f,// 6
			0.5f, 0.5f, 0.5f, 1.0f, // 7
	};

	// 保存每一个平面的顶点索引的二维数组

	private byte[][] indies = {
			new byte[] { 0, 1, 2, 1, 3, 2, 2, 3, 4, 3, 5, 4 },// front face
			new byte[] { 0, 1, 2, 1, 3, 2, 2, 3, 4, 3, 5, 4 },// back face
			new byte[] { 0, 1, 2, 1, 3, 2 },// bottom face
			new byte[] { 0, 1, 2, 1, 3, 2 },// bottom left face
			new byte[] { 0, 1, 2, 1, 3, 2 },// bottom right face
			new byte[] { 0, 1, 2, 1, 3, 2 },// top right face
			new byte[] { 0, 1, 2, 1, 3, 2 },// top face
			new byte[] { 0, 1, 2, 1, 3, 2 } // top left face
	};

	public Polygon() {

		// 利用循环初始化顶点坐标faceVertexBuffer数组和顶点索引indexBuffer数组
		ByteBuffer bb;
		faceVertexBuffer = new FloatBuffer[8];
		for (int i = 0; i < faceVertices.length; i++) {
			bb = ByteBuffer.allocateDirect(faceVertices[i].length * 4);
			bb.order(ByteOrder.nativeOrder());
			faceVertexBuffer[i] = bb.asFloatBuffer();
			faceVertexBuffer[i].put(faceVertices[i]);
			faceVertexBuffer[i].position(0);

		}

		indexBuffer = new ByteBuffer[8];
		for (int i = 0; i < indies.length; i++) {
			indexBuffer[i] = ByteBuffer.allocateDirect(indies[i].length);
			indexBuffer[i].put(indies[i]);
			indexBuffer[i].position(0);

		}

	}

	public void draw(GL10 gl) {

		// 利用循环绘制六棱柱的每一个面，并给不同的面设置不同的颜色
		gl.glFrontFace(GL10.GL_CW);

		for (int i = 0; i < 8; i++) {
			gl.glVertexPointer(3, GL10.GL_FLOAT, 0, faceVertexBuffer[i]);
			gl.glColor4f(colors[4 * i + 0], colors[4 * i + 1],
					colors[4 * i + 2], colors[4 * i + 3]);
			gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);

			gl.glDrawElements(GL10.GL_TRIANGLES, indies[i].length,
					GL10.GL_UNSIGNED_BYTE, indexBuffer[i]);// 另一种绘制的方法glDrawElements
			gl.glDisableClientState(GL10.GL_VERTEX_ARRAY);
		}

	}

}