1. 材料和光源

2. 深度
在现实生活中，一个实心物体挡在另外一个实心物体的前面， 后面的那个物体有部分会被遮盖掉


那么opengl里面如何模拟这个情况呢？ 每个物体的每个像素都有一个深度缓存的值（在0到1之间，可以想象成是z轴的距离）


如果glDepthFunc启用了GL_LESS(现实生活中的前景）， 那么当前个物体挡住后个物体时， 由于前个物体深度值小（越靠近人的）， 所以它就被画了出来， 后面的物体被挡住的像素就被忽略掉了。（当然你如果启用了GL_GREATER, 那么情况就反过来了）


这个时候再来说glClearDepth, 它给深度缓冲指定了一个初始值，缓冲中的每个像素的深度值都是这个， 比如1，这个时候你往里面画一个物体， 由于物体的每个像素的深度值都小于等于1， 所以整个物体都被显示了出来。 如果初始值指定为0， 物体的每个像素的深度值都大于等于0， 所以整个物体都不可见。 如果初始值指定为0.5， 那么物体就只有深度小于0.5的那部分才是可见的


glDepthMask(GL_TRUE); 开启深度缓存写入


3.模板

模板缓冲区(Stencil Buffer)：与颜色缓冲区和深度缓冲区类似，模板缓冲区可以为屏幕上的每个像素点保存一个无符号整数值。这个值的具体意义视程序的具体应用而定。在渲染的过程中，可以用这个值与一个预先设定的参考值相比较，根据比较的结果来决定是否更新相应的像素点的颜色值。这个比较的过程被称为模板测试。模板测试发生在透明度测试（alpha test）之后，深度测试（depth test）之前。如果模板测试通过，则相应的像素点更新，否则不更新。就像使用纸板和喷漆一样精确的混图一样，当启动模板测试时，通过模板测试的片段像素点会被替换到颜色缓冲区中，从而显示出来，未通过的则不会保存到颜色缓冲区中，从而达到了过滤的功能。


4.正反
void glFrontFace(GLenum mode);
作用是控制多边形的正面是如何决定的。在默认情况下，mode是GL_CCW。
mode的值为：
GL_CCW 表示窗口坐标上投影多边形的顶点顺序为逆时针方向的表面为正面。
GL_CW 表示顶点顺序为顺时针方向的表面为正面。
顶点的方向又称为环绕


5.glShadeModel(GL_SMOOTH);

在使用顶点数据绘制几何图形时，如果为每个顶点指定了顶点颜色，此时若使用GL_SMOOTH，每个顶点使用对应的顶点颜色来着色，而顶点之间的片元颜色则使用差值的方式来计算获得，结果就是渐变色；而若使用GL_FLAT，假设几何图形由n个三角形构成，则只会使用顶点颜色数组中最后n个颜色进行着色


6.Blend 混合是将源色和目标色以某种方式混合生成特效的技术。混合常用来绘制透明或半透明的物体。在混合中起关键作用的α值实际上是将源色和目标色按给定比率进行混合，以达到不同程度的透明。α值为0则完全透明，α值为1则完全不透明。混合操作只能在RGBA模式下进行，颜色索引模式下无法指定α值。物体的绘制顺序会影响到OpenGL的混合处理。

7.表面剔除

glCullFace()参数包括GL_FRONT和GL_BACK。
意义：两个参数分别表示禁用多边形正面或者背面上的光照、阴影和颜色计算及操作，消除不必要的渲染计算。

例如某对象无论如何位置变化，我们都只能看到构成其组成的多边形的某一面时，可使用该函数。

8.点画线
可以使用glLineStipple()函数定义点画模式，然后用glEnable()函数启用直线点画功能。
    glLineStipple( 1, 0x3F07 );

    glEnable( GL_LINE_STIPPLE );


9.启用数组

void glEnableClientState(GLenum array)

    指定了需要启用的数组。array参数可以使用下面这些符号常量：GL_VERTEY_ARRAY、GL_COLOR_ARRAY、GL_SECONDARY_COLOR_ARRAY、GL_INDEX_ARRAY、GL_NORMAL_ARRAY、GL_FOG_COORDINATE_ARRAY、GL_TEXTURE_COORD_ARRAY和GL_EDGE_FLAG_ARRAY


10.glPixelStorei用于设置像素存储模式。




[objc] 
view plain 
copy 

void glPixelStorei(    GLenum pname,  
     GLint param);  



它含有两个参数：
pname：指定所要被设置参数的符号名。这里，参数的符号名有两种，一种是GL_PACK_ALIGNMENT，它影响将像素数据写回到主存的打包形式，对glReadPixels的调用产生影响；还有一种是GL_UNPACK_ALIGNMENT，它影响从主存读到的像素数据的解包形式，对glTexImage2D以及glTexSubImage2D产生影响。

param：指定相应的pname设置为什么值。这个数值一般是1、2、4或8，用于指定存储器中每个像素行有多少个字节对齐。对齐的字节数越高，系统就越能优化。
在实际代码中，我们看到的是glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
实际上，我们可以这里可以用4（默认值）。因为checkImage能够保证是4字节对齐的。当然，我们可以通过对checkImage的修改使其保证是8字节对齐

用户管理

mysql>use mysql;

查看

mysql> select host,user,password from user ;

创建

mysql> create user  zx_root   IDENTIFIED by 'xxxxx';   //identified by 会将纯文本密码加密作为散列值存储

修改

mysql>rename   user  feng  to   newuser；//mysql 5之后可以使用，之前需要使用update 更新user表

删除

mysql>drop user newuser;   //mysql5之前删除用户时必须先使用revoke 删除用户权限，然后删除用户，mysql5之后drop 命令可以删除用户的同时删除用户的相关权限

更改密码

mysql> set password for zx_root =password('xxxxxx');

 mysql> update  mysql.user  set  password=password('xxxx')  where user='otheruser'

查看用户权限

mysql> show grants for zx_root;

赋予权限

mysql> grant select on dmc_db.*  to zx_root;

回收权限

mysql> revoke  select on dmc_db.*  from  zx_root;  //如果权限不存在会报错

 

上面的命令也可使用多个权限同时赋予和回收，权限之间使用逗号分隔

mysql> grant select，update，delete  ，insert  on dmc_db.*  to  zx_root;

如果想立即看到结果使用

flush  privileges ;

命令更新 

 

设置权限时必须给出一下信息

1，要授予的权限

2，被授予访问权限的数据库或表

3，用户名

grant和revoke可以在几个层次上控制访问权限

1，整个服务器，使用 grant ALL  和revoke  ALL

2，整个数据库，使用on  database.*

3，特点表，使用on  database.table

4，特定的列

5，特定的存储过程

 

user表中host列的值的意义

%              匹配所有主机

localhost    localhost不会被解析成IP地址，直接通过UNIXsocket连接

127.0.0.1      会通过TCP/IP协议连接，并且只能在本机访问；

::1                 ::1就是兼容支持ipv6的，表示同ipv4的127.0.0.1

 

 

grant 普通数据用户，查询、插入、更新、删除 数据库中所有表数据的权利。
grant select on testdb.* to common_user@’%’
grant insert on testdb.* to common_user@’%’
grant update on testdb.* to common_user@’%’
grant delete on testdb.* to common_user@’%’
或者，用一条 MySQL 命令来替代：
grant select, insert, update, delete on testdb.* to common_user@’%’
9>.grant 数据库开发人员，创建表、索引、视图、存储过程、函数。。。等权限。
grant 创建、修改、删除 MySQL 数据表结构权限。
grant create on testdb.* to developer@’192.168.0.%’;
grant alter on testdb.* to developer@’192.168.0.%’;
grant drop on testdb.* to developer@’192.168.0.%’;
grant 操作 MySQL 外键权限。
grant references on testdb.* to developer@’192.168.0.%’;
grant 操作 MySQL 临时表权限。
grant create temporary tables on testdb.* to developer@’192.168.0.%’;
grant 操作 MySQL 索引权限。
grant index on testdb.* to developer@’192.168.0.%’;
grant 操作 MySQL 视图、查看视图源代码 权限。
grant create view on testdb.* to developer@’192.168.0.%’;
grant show view on testdb.* to developer@’192.168.0.%’;
grant 操作 MySQL 存储过程、函数 权限。
grant create routine on testdb.* to developer@’192.168.0.%’; -- now, can show procedure status
grant alter routine on testdb.* to developer@’192.168.0.%’; -- now, you can drop a procedure
grant execute on testdb.* to developer@’192.168.0.%’;
10>.grant 普通 DBA 管理某个 MySQL 数据库的权限。
grant all privileges on testdb to dba@’localhost’
其中，关键字 “privileges” 可以省略。
11>.grant 高级 DBA 管理 MySQL 中所有数据库的权限。
grant all on *.* to dba@’localhost’
12>.MySQL grant 权限，分别可以作用在多个层次上。
1. grant 作用在整个 MySQL 服务器上：
grant select on *.* to dba@localhost; -- dba 可以查询 MySQL 中所有数据库中的表。
grant all on *.* to dba@localhost; -- dba 可以管理 MySQL 中的所有数据库
2. grant 作用在单个数据库上：
grant select on testdb.* to dba@localhost; -- dba 可以查询 testdb 中的表。
3. grant 作用在单个数据表上：
grant select, insert, update, delete on testdb.orders to dba@localhost;
4. grant 作用在表中的列上：
grant select(id, se, rank) on testdb.apache_log to dba@localhost;
5. grant 作用在存储过程、函数上：
grant execute on procedure testdb.pr_add to ’dba’@’localhost’
grant execute on function testdb.fn_add to ’dba’@’localhost’
注意：修改完权限以后 一定要刷新服务，或者重启服务，刷新服务用：FLUSH PRIVILEGES。

 

 

权限表


权限

说明

all

 

alter

 

alter routine

使用alter procedure 和drop procedure

create

 

create routine

使用create  procedure



create temporary tables

使用create temporary table

create  user

 

create view

 

delete

 

drop

 

execute

使用call和存储过程



file

使用select into outfile  和load data infile

grant option

可以使用grant和revoke

index

可以使用create index 和drop index

insert

 

lock tables

锁表

process

使用show full processlist



reload

   使用flush

replication client

服务器位置访问

replocation slave

由复制从属使用

select

 

show databases

 

show view

 



shutdown

使用mysqladmin shutdown 来关闭mysql

super

 

update

 

usage

无访问权限

 

 

 

 









Mysql初始化root密码和允许远程访问






mysql默认root用户没有密码，输入mysql –u root 进入mysql

1、初始化root密码

进入mysql数据库




1




mysql>update user set password=PASSWORD(‘123456’)
where User='root';





2、允许mysql远程访问,可以使用以下三种方式:

a、改表。




1

2

3

4




mysql
 -u root –p

mysql>use
 mysql;

mysql>update user set host
 = '%' where user =
'root';

mysql>select host,
user from user;





b、授权。

例如，你想root使用123456从任何主机连接到mysql服务器。




1




mysql>GRANT ALL PRIVILEGES ON *.*
TO 'root'@'%' IDENTIFIED
BY '123456' WITH GRANT OPTION;





如果你想允许用户jack从ip为10.10.50.127的主机连接到mysql服务器，并使用654321作为密码




1

2




mysql>GRANT ALL PRIVILEGES ON *.*
TO 'jack'@’10.10.50.127’
 IDENTIFIED BY '654321' WITH GRANT OPTION;

mysql>FLUSH
 RIVILEGES





c:在安装mysql的机器上运行：




1

2

3

4

5

6

7

8




//进入MySQL服务器

d:\mysql\bin\>mysql
 -h localhost -u root

//赋予任何主机访问数据的权限

mysql>GRANT ALL PRIVILEGES ON *.*
TO 'root'@'%' WITH GRANT OPTION

//使修改生效

mysql>FLUSH
PRIVILEGES

//退出MySQL服务器

mysql>EXIT

平时写代码都直接写
List<String> list = new ArrayList<>();

由于公司做政府项目，对并发和响应没有太苛刻的要求，平时就没有考虑到这一块。今天看同事代码在new ArrayList<>()的时候带入初始容量，于是好奇百度一下，讲结果记录下来。
一、有无初始容量的区别
	/**
     * The maximum size of array to allocate.
     * Some VMs reserve some header words in an array.
     * Attempts to allocate larger arrays may result in
     * OutOfMemoryError: Requested array size exceeds VM limit
     */
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
    
	/**
     * Default initial capacity.
     */
    private static final int DEFAULT_CAPACITY = 10;

	/**
     * The array buffer into which the elements of the ArrayList are stored.
     * The capacity of the ArrayList is the length of this array buffer. Any
     * empty ArrayList with elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA
     * will be expanded to DEFAULT_CAPACITY when the first element is added.
     */
    transient Object[] elementData; // non-private to simplify nested class access

	/**
     * Shared empty array instance used for empty instances.
     */
    private static final Object[] EMPTY_ELEMENTDATA = {};	

	/**
     * Constructs an empty list with the specified initial capacity.
     *
     * @param  initialCapacity  the initial capacity of the list
     * @throws IllegalArgumentException if the specified initial capacity
     *         is negative
     */
    public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }

	/**
     * Increases the capacity to ensure that it can hold at least the
     * number of elements specified by the minimum capacity argument.
     *
     * @param minCapacity the desired minimum capacity
     */
    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

以上是JDK1.8的ArrayList源码，可以看出，

没有初始容量的话，在做数据操作的时候ArrayList会自己创建容量，JDK1.8默认为10
每次扩容后容量为oldCapacity + (oldCapacity >> 1)
容量最大值Integer.MAX_VALUE - 8

由此可以想到，如果存在上千上万数据量的操作，不初始容量和初始化了合适的容量，处理时间肯定不同，因为初始化和扩容是需要时间的。
测试代码如下：
public static void main(String[] args) {
    final int count = 200 * 10000;
    List<Integer> list = new ArrayList<>();
    long begin = System.currentTimeMillis();
    for(int i = 0; i < count ; i++) {
        list.add(i);
    }
    System.out.println("没有设置ArrayList初始容量： " + (System.currentTimeMillis() - begin) + " ms");

    List<Integer> list2 = new ArrayList<>(10);
    long begin2 = System.currentTimeMillis();
    for(int i = 0; i < count ; i++) {
        list2.add(i);
    }
    System.out.println("设置了ArrayList初始容量： " + (System.currentTimeMillis() - begin2) + " ms");
}

输出：
没有设置ArrayList初始容量： 96 ms
设置了ArrayList初始容量： 26 ms

分析：

在list.add()方法执行时，先调用ArrayList的：
/**
 * Appends the specified element to the end of this list.
 *
 * @param e element to be appended to this list
 * @return <tt>true</tt> (as specified by {@link Collection#add})
 */
public boolean add(E e) {
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}

进入方法：
private void ensureCapacityInternal(int minCapacity) {
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}

再往下：
private static int calculateCapacity(Object[] elementData, int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {// 第一次add的时候，都会走这一步
        return Math.max(DEFAULT_CAPACITY, minCapacity);//初始化容量小于默认值10都会取10，反之取自定义的容量
    }
    return minCapacity;
}

扩容方法：
private void ensureExplicitCapacity(int minCapacity) {
    modCount++;

    // overflow-conscious code
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

grow():
/**
 * Increases the capacity to ensure that it can hold at least the
 * number of elements specified by the minimum capacity argument.
 *
 * @param minCapacity the desired minimum capacity
 */
 private void grow(int minCapacity) {//minCapacity是当前容量，比如，默认容量下，add一次后就是10+1
    // overflow-conscious code
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    // minCapacity is usually close to size, so this is a win:
    elementData = Arrays.copyOf(elementData, newCapacity);
}

总结：

建议初始化容量，减少系统初始化容量的耗时；
初始化容量不是越大越好，跟系统配置相关，因为要开辟内存。如果能确定add的总数，以总数作为初始容量效率最高，但这种场景太少了。最佳的设置要兼顾内存空间和扩容次数，我也没有找到最优解，欢迎大佬补充。
尽管不知道初始化多少最快，但是初始化比未初始化快，并且有限的数据量下，设置不同initialCapacity的差距不大。最终，我建议大家初始化容量，并且就写10（<=10都一样，看自己喜好）。

上例不同大小初始容量的耗时：




initialCapacity
time




未初始化
96


<=10
26


100
26


1000
23


10000
648


100000
24


1000000
18


10000000
609


二、initialCapacity != list.size()
public static void main(String[] args) {
    List<Integer> list = new ArrayList<>(10);
    list.set(0, 666);
}

console:
Exception in thread "main" java.lang.IndexOutOfBoundsException: Index: 0, Size: 0
	at java.util.ArrayList.rangeCheck(ArrayList.java:657)
	at java.util.ArrayList.set(ArrayList.java:448)
	at top.chengsw.demo.test.ListTest.main(ListTest.java:25)

此时，list.size() = 0。

也就是说，该构造方法并不是将ArrayList()初始化为指定长度，而是指定了其内部的Object数组的长度，也就是其容量。当我们调用size()时，返回的是其实际长度，而非容量大小。对超出ArrayList长度的部分进行访问或赋值操作时也会造成访问越界，尽管它的容量大小足够。

初始化着色器函数initShaders()被定义在了cuon.util.js中
使用：
initShaders(gl, vshader, fshader);
参数：
gl  指定渲染的上下文
vshader  指定顶点着色器程序代码(字符串)
fshader  指定片元着色器程序代码（字符串）
返回值：
true  初始化着色器成功
false  初始化着色器失败


顶点着色器
    var VSHADER_SOURCE="" +
        "void main(){\n" +
        "   gl_Position = vec4(0.0,0.0,0.0,1.0);\n" +//设置坐标
        "   gl_PointSize = 10.0;\n" +//设置尺寸
        "}\n";
首先用js声明了一个变量将书写的GLSL ES着色器语言代码字符串赋值变量。
类似于C语言，必须包含一个main()函数，  void代码这个函数不会有返回值，而且你不能为main()指定参数。
函数内部的两行代码
gl_Position  类型：vec4 表示顶点的位置 必须设置
gl_PointSize  类型：float  表示点的尺寸（像素数） 如果不设置，默认为1.0
GLSL ES数据类型
float 表示是浮点数
vec4表示由四个浮点数组成的矢量
由4个分量组成的矢量被称为齐次坐标，它能够提高处理三维数据的效率，所以被大量使用
齐次坐标：（x,y,z,w）。齐次坐标（x,y,z,w）等价于三维坐标（x/w,y/w,z/w）。所以如果齐次坐标的第四个分量是1，你就可以将它当做单位坐标来使用。w的值必须大于等于0的。如果w趋近于0，那么它所表示的点将趋近于无穷远，所以在齐次坐标系中可以有无穷的概念。齐次坐标的存在，似的用矩阵乘法来描述顶点变换成为可能，三维图形系统在计算过程中，通常使用齐次坐标来表示顶点的三维坐标。


片元着色器
    //片元着色器程序
    var FSHADER_SOURCE = "" +
        "void main(){\n" +
        "   gl_FragColor = vec4(1.0,0.0,0.0,1.0);\n" +//设置颜色
        "}\n";
顶点着色器控制点的位置和大小，片元着色器控制点的颜色。片元就是显示在屏幕上的像素（严格意义上来说，片元包括这个像素的位置、颜色和其他信息）。

片元着色器的作用就是处理片元，使其显示在屏幕上。
片元着色器将点的颜色赋值给gl_FragColor变量，该变量是片元着色器唯一的内置变量，它控制着像素在屏幕上的最终颜色。
gl_FragColor 类型：vec4  描述：指定片元颜色（RGBA格式）。
对这个内置变量赋值后，相应的像素就会以这个颜色值显示。类型和顶点着色器中的顶点位置一样，也是vce4类型。四个浮点分量，分别代表RGBA值。


绘制操作
        //绘制一个点
        gl.drawArrays(gl.POINTS,0,1);
gl.drawArrays(mode, first, count);执行顶点着色器，安装mode的参数指定的方式绘制图形。

参数：
mode  指定绘制的方式，可接收一下常量符号：gl.POINTS，gl.LINES, gl.LINE_STRIP, gl.LINE_LOOP, gl.TRIANGLES, gl.TRIANGLE_STRIP, gl.TRIANGLE_FAN
first 指定从哪个顶点开始绘制（整数型）
count  指定绘制需要用到多少个顶点（整数型）
返回值：无
错误  INVALID_ENUM  传入的mode参数不是前述参数之一
INVALID_VALUE  参数first或count是负数


示例当中由于我们只绘制了单独的点，所以第一个值是gl.POINTS，第二个参数表示从第1个顶点开始画起，第三个参数表示仅绘制的一个点。