2015年1月13日星期二（11-1深度缓存和可见性简介）

最新推荐文章于 2024-06-07 16:38:06 发布
最新推荐文章于 2024-06-07 16:38:06 发布
阅读量1k 收藏 1
点赞数 1
分类专栏： 业余封装3D软引擎
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/directx3d_beginner/article/details/50493210
版权


新的一年，开始新的篇章，终于进入第11章了。必须首要搞这个。争取今年搞完，我也相信，会对3D学习不是浪费时间。而是内力提升。

在以前，用画家算法进行多边形排序，即根据渲染列表中的每个多边形的平均、最小或最大值进行排序，然后，再从后到前的顺序绘制多边形。

大多数情况下，是正确的。但是，在多边形相互贯通、包含大小各异的几何体时，画家算法可能失效，

引入Z缓存（即像素级画家算法）：将对像素进行排序，

算法如下：

For(渲染列表中的每个多边形) begin

 1,对其进行光栅化，生成xi,yi,zi,

For(每组xi,yi,zi)

2,if( zi < zbuffer[xi,yi], then

 Zbuffer[xi,yi]= zi,然后将像素显示到屏幕上，Plot(xi,yi).

End for

 

获取多边形的Z值方法：

根据多边形所在的平面;ax+by+cz+d=0.求得z值。

然后可以进行插值运算。

 

Z缓存的问题：

上述三角形的（x,y,z）是3D空间推导进行，即世界做表空间或相机坐标空间，而Z缓冲是在屏幕空间的投影坐标(x_screen,y_screen),而x_screen = d * x/z; y_screen= d * y /z，可知，Z值不是线性的，而1/z是线性的。

首先定义z缓存的变量和数据结构

//为z缓存数据结构定义的常量

#define  ZBUFFER_ATTR_16BIT                     16

#define  ZBUFFER_ATTR_32BIT                     32

 

//Z缓存数据结构

typedef struct ZBUFFERV1_TYP

{

    int               attr;             //z缓存的属性，位或位

    UCHAR    *        zbuffer;     //指向Z缓存的指针

    int               width;            //z缓存的宽度，单位为像素

    int               height;           //z缓存的高度，单位为像素

    int               sizeq;            //实际的四元组大小（每个四元组为个字节）

} ZBUFFERV1, *ZBUFFERV1_PTR;

 

 

创建z缓存

 

 

int DDRAW_LIUSHUIXIAN_TEXTURE::Create_Zbuffer(ZBUFFERV1_PTRzb, int width, int height, int attr)

{

    //指针zb是否有效

    if(!zb )

         return0;

 

    //是否已经给zb指向的ZBUFFERV1分配了内存

    if(zb->zbuffer)

         free(zb->zbuffer);

 

    //设置字段

    zb->width                              =width;

    zb->height                             =height;

    zb->attr                           =attr;

 

    //z缓存是位的还是位的

    if(attr & ZBUFFER_ATTR_16BIT)

    {

         //计算四元组数

         zb->sizeq                          =width * height/ 2;

 

         //分配内存

         if(( zb->zbuffer= ( UCHAR * ) malloc(width * height* sizeof( SHORT) ) ) )

             return1;

         else

             return0;

    }

    else

    if(attr & ZBUFFER_ATTR_32BIT)

    {

         //计算四元组数

         zb->sizeq                          =width * height;

 

         //分配内存

         if(( zb->zbuffer= ( UCHAR * ) malloc(width * height* sizeof( INT) ) ) )

             return1;

         else

             return0;

    }

    else

         return0;

}

 

每次写入一个32位UINT值的方式填充/设置内存

void ddraw_math::Mem_Set_QUAD( void* dest, USHORTdata, int count )

{

    _asm

    {

         movedi, dest     ;

         movecx, count    ;

         moveax,  data    ;

         repstosd         ;

    }

}

清空/填充z缓存

 

 

void DDRAW_LIUSHUIXIAN_TEXTURE::Clear_Zbufffer(ZBUFFERV1_PTRzb, UINT data)

{

    ddraw_mathmath;

    math.Mem_Set_QUAD( ( void* ) zb->zbuffer,data, zb->sizeq );

}

 

删除z缓存，

 

int DDRAW_LIUSHUIXIAN_TEXTURE::Delete_Zbuffer(ZBUFFERV1_PTRzb)

{

    if(zb )

    {

         //释放内存

         if(zb->zbuffer)

             free(zb->zbuffer);

 

         //清除内存中的数据

         memset(( void * ) zb,0, sizeof( ZBUFFERV1) );

         return1;

    }

    else

         return0;

}

 

首先，更新恒定Shader处理函数

以GouraudShader处理函数，不进行RGB颜色插值，每个像素都使用相同的颜色，并将对某个颜色分量进行插值的代码改为对Z值进行插值的代码。

 

 

void ddraw_math::Draw_Triangle_2DZB_16(                  POLYF4DV2_PTR                  face,         //指向多边形面的指针

                                                             UCHAR                     *    _dest_buffer,//指向视频缓存的指针

                                                             int                           mem_pitch,   //每行占用多少字节（,640）

                                                             UCHAR                     *    _zbuffer,    //指向z缓存的指针

                                                             int                           zpitch )

中，把U,I坐标改为Z坐标，其余没变。

 

对于Gouraud shader,只需加入z值的代码即可。

 

 

void ddraw_math::Draw_Gouraud_TriangleZB16( POLYF4DV2_PTR    face,        //指向多边形的指针

                                                                  UCHAR    *       _dest_buffer,//指向视频缓存的指针

                                                                  int               mem_pitch, //每行占据的字节数

                                                                  UCHAR                     *    _zbuffer,    //指向z缓存的指针

                                                                                                                                        int                            zpitch ) //z缓存每行占用的字节数

 

 

对于支持固定着色的纹理映射函数。，也是插入Z代码，并Z缓存比较。

 

void ddraw_math::Draw_Textured_TriangleZB16(    POLYF4DV2_PTR     face,        //指向多边形的指针

                                                                  UCHAR    *       _dest_buffer,//指向视频缓存的指针

                                                                  int               mem_pitch, //每行占据的字节数

                                                                  UCHAR        *   _zbuffer,    //指向z缓存的指针

                                                                                                                                        int               zpitch ) //z缓存每行占用的字节数

 

对于支持恒定着色的纹理映射函数，更新Z缓冲将通过Z缓冲的绘制

 

void ddraw_math::Draw_Textured_TriangleFSZB16(  POLYF4DV2_PTR     face,        //指向多边形的指针

                                                                  UCHAR    *       _dest_buffer,//指向视频缓存的指针

                                                                  int               mem_pitch, //每行占据的字节数

                                                                  UCHAR        *   _zbuffer,    //指向z缓存的指针

                                                                                                                                        int               zpitch) //z缓存每行占用的字节数

对于接下来进行更新渲染列表函数，进行绘制的各个路径。

 

void DDRAW_LIUSHUIXIAN_TEXTURE::   Draw_RENDERLIST4DV2_SolidZB16(ddraw_math math2,RENDERLIST4DV2_PTR rend_list,UCHAR * video_buffer,int lpitch,

                                                                          UCHAR    *                 zbuffer,

                                                                          int                        zpitch)

{

    POLYF4DV2                 face;

 

    for(int poly =0; poly < rend_list->num_polys; poly++)

    {

         //获得当前多边形

         POLYF4DV2_PTR         curr_poly                 = rend_list->poly_ptrs[poly];

 

 

         //当且仅当多边形没有被剔除或者裁剪掉，同时处于活动状态且可见时，才对其进行变换）

         if(!( curr_poly->state& POLY4DV2_STATE_ACTIVE ) ||

             ( curr_poly->state& POLY4DV2_STATE_CLIPPED ) ||

             ( curr_poly->state& POLY4DV2_STATE_BACKFACE ) )

             continue;    //进入下一个多边形

 

         //先测试纹理，

         if(rend_list->poly_ptrs[poly]->attr& POLY4DV2_ATTR_SHADE_MODE_TEXTURE )

         {

             face.tvlist[0].x                    =( int ) rend_list->poly_ptrs[poly]->tvlist[0].x;

             face.tvlist[0].y                   = ( int) rend_list->poly_ptrs[poly]->tvlist[0].y;

             face.tvlist[0].z                   = ( int) rend_list->poly_ptrs[poly]->tvlist[0].z;

             face.tvlist[0].u0                  = ( int) rend_list->poly_ptrs[poly]->tvlist[0].u0;

             face.tvlist[0].v0                  = ( int) rend_list->poly_ptrs[poly]->tvlist[0].v0;

 

             face.tvlist[1].x                   = ( int) rend_list->poly_ptrs[poly]->tvlist[1].x;

             face.tvlist[1].y                   = ( int) rend_list->poly_ptrs[poly]->tvlist[1].y;

             face.tvlist[1].z                   =( int ) rend_list->poly_ptrs[poly]->tvlist[1].z;

             face.tvlist[1].u0                  = ( int) rend_list->poly_ptrs[poly]->tvlist[1].u0;

             face.tvlist[1].v0                  = ( int) rend_list->poly_ptrs[poly]->tvlist[1].v0;

 

             face.tvlist[2].x                   = ( int) rend_list->poly_ptrs[poly]->tvlist[2].x;

             face.tvlist[2].y                   = ( int) rend_list->poly_ptrs[poly]->tvlist[2].y;

             face.tvlist[2].z                   = ( int) rend_list->poly_ptrs[poly]->tvlist[2].z;

             face.tvlist[2].u0                  = ( int) rend_list->poly_ptrs[poly]->tvlist[2].u0;

             face.tvlist[2].v0                  = ( int) rend_list->poly_ptrs[poly]->tvlist[2].v0;

 

             face.texture                       =rend_list->poly_ptrs[poly]->texture;

 

             if(rend_list->poly_ptrs[poly]->attr& POLY4DV2_ATTR_SHADE_MODE_CONSTANT )

             {

                  math2.Draw_Textured_TriangleZB16(& face, video_buffer,lpitch, zbuffer,zpitch );

             }

             else

             {

                  face.lit_color[0]              = rend_list->poly_ptrs[poly]->lit_color[0];

 

                  math2.Draw_Textured_TriangleFSZB16(& face, video_buffer,lpitch, zbuffer,zpitch );

             }

 

         }

         else

             if(( rend_list->poly_ptrs[poly]->attr& POLY4DV2_ATTR_SHADE_MODE_FLAT )

                  || ( rend_list->poly_ptrs[poly]->attr& POLY4DV2_ATTR_SHADE_MODE_CONSTANT ) )

             {

                  //使用固定着色

                  face.lit_color[0]              = rend_list->poly_ptrs[poly]->lit_color[0];

 

                  //设置顶点坐标

                  face.tvlist[0].x               =( float ) rend_list->poly_ptrs[poly]->tvlist[0].x;

                  face.tvlist[0].y               =( float ) rend_list->poly_ptrs[poly]->tvlist[0].y;

                  face.tvlist[0].z               =( float ) rend_list->poly_ptrs[poly]->tvlist[0].z;

 

                  face.tvlist[1].x               =( float ) rend_list->poly_ptrs[poly]->tvlist[1].x;

                  face.tvlist[1].y               =( float ) rend_list->poly_ptrs[poly]->tvlist[1].y;

                  face.tvlist[1].z               =( float ) rend_list->poly_ptrs[poly]->tvlist[1].z;

 

                  face.tvlist[2].x               =( float ) rend_list->poly_ptrs[poly]->tvlist[2].x;

                  face.tvlist[2].y               =( float ) rend_list->poly_ptrs[poly]->tvlist[2].y;

                  face.tvlist[2].z               =( float ) rend_list->poly_ptrs[poly]->tvlist[2].z;

 

                  math2.Draw_Triangle_2DZB_16(& face, video_buffer,lpitch, zbuffer,zpitch );

 

 

                 

             }

             else

                  if( rend_list->poly_ptrs[poly]->attr & POLY4DV2_ATTR_SHADE_MODE_GOURAUD)

                  {

                      face.tvlist[0].x                   =( float ) rend_list->poly_ptrs[poly]->tvlist[0].x;

                      face.tvlist[0].y                   =( float ) rend_list->poly_ptrs[poly]->tvlist[0].y;

                      face.tvlist[0].z                   =( float ) rend_list->poly_ptrs[poly]->tvlist[0].z;

                      face.lit_color[0]                  =  rend_list->poly_ptrs[poly]->lit_color[0];

 

                      face.tvlist[1].x                   =( float ) rend_list->poly_ptrs[poly]->tvlist[1].x;

                      face.tvlist[1].y                   =( float ) rend_list->poly_ptrs[poly]->tvlist[1].y;

                      face.tvlist[1].z                   =( float ) rend_list->poly_ptrs[poly]->tvlist[1].z;

                      face.lit_color[1]                  =  rend_list->poly_ptrs[poly]->lit_color[1];

 

                      face.tvlist[2].x                   =( float ) rend_list->poly_ptrs[poly]->tvlist[2].x;

                      face.tvlist[2].y                   =( float ) rend_list->poly_ptrs[poly]->tvlist[2].y;

                      face.tvlist[2].z                   =( float ) rend_list->poly_ptrs[poly]->tvlist[2].z;

                      face.lit_color[2]                  =  rend_list->poly_ptrs[poly]->lit_color[2];

 

                      math2.Draw_Gouraud_TriangleZB16(& face, video_buffer,lpitch, zbuffer,zpitch );

                  }

 

 

 

 

    }

 

 

}

 

优化部分基本过时，主要看算法，看看例子如何运行。

 

首先定义了个庞大的物体，（因为要Z缓冲排序，所以物体较多。）

#define  CAM_DECEL                 0.25

#define  MAX_SPEED                 20

#define  NUM_OBJECTS               5

#define  NUM_SCENE_OBJECTS     500

#define  UNIVERSE_RADIUS           2000

 

摄像机改变位置

POINT4D  cam_pos    ={0,0,0,1};

物体名和当前物体序号

char *        object_filenames[NUM_OBJECTS]      ={ "cube_flat_01.cob", "cube_gouraud_01.cob",

"cube_flat_textured_01.cob","sphere02.cob","sphere03.cob",};

 

int                                                  curr_object  =2;

每个物体的位置

POINT4D           scene_objects[NUM_SCENE_OBJECTS];

摄像机速度和Z缓冲设置。

 

float             cam_speed         =0;

ZBUFFERV1                                   zbuffer;

 

在Game_Init()中，

设置摄像机参数

 

    liushuixian.Init_CAM4DV1( * math,&cam,      // the camera object

         CAM_MODEL_EULER,// the euler model

         &cam_pos,  // initial camera position

         &cam_dir,  // initial camera angles

         &cam_target,      // no target

         15.0,      // near and farclipping planes

         12000.0,

         120.0,      // field ofview in degrees

         SCREEN_WIDTH,   // size of finalscreen viewport

                                            SCREEN_HEIGHT);

加载物体

    for(int index_obj= 0; index_obj < NUM_OBJECTS;index_obj++ )

    {

 

         liushuixian_texture.Load_OBJECT4DV2_COB( * math,matiGroup, &obj_array[index_obj], object_filenames[index_obj], 

         &vscale, &vpos, &vrot, VERTEX_FLAGS_SWAP_YZ|

         VERTEX_FLAGS_TRANSFORM_LOCAL); 

                                           }

 

设置当前物体

 

 

    curr_object  = 2;

    obj_work = & obj_array[curr_object];

 

加载场景

 

    liushuixian_texture.Load_OBJECT4DV2_COB( * math,matiGroup, &obj_scene,"cube_gouraud_01.cob", 

         &vscale, &vpos, &vrot, VERTEX_FLAGS_SWAP_YZ|

         VERTEX_FLAGS_TRANSFORM_LOCAL); 

 

看了一下DEMO的例子效果，感觉不错，所以把4个灯光全加上

white.rgba = _RGBA32BIT(255,255,255,0);

    gray.rgba  = _RGBA32BIT(100,100,100,0);

    black.rgba = _RGBA32BIT(0,0,0,0);

    red.rgba   = _RGBA32BIT(255,0,0,0);

    green.rgba = _RGBA32BIT(0,255,0,0);

    blue.rgba  = _RGBA32BIT(0,0,255,0) ;

 

    light.Init_Light_LIGHTV2( * math,lightGroup,AMBIENT_LIGHT_INDEX,LIGHTV2_STATE_ON, LIGHTV2_ATTR_AMBIENT,gray, black,black, NULL,NULL, 0, 0, 0, 0, 0, 0 );

   

    VECTOR4D dlight_dir        = { -1, 0, -1, 1 };

    light.Init_Light_LIGHTV2( * math,lightGroup,INFINITE_LIGHT_INDEX,LIGHTV2_STATE_ON, LIGHTV2_ATTR_INFINITE,black, gray,black, NULL,& dlight_dir, 0, 0, 0, 0, 0, 0 );

 

    VECTOR4D plight_pos        = { 0, 200, 0, 1 };

    light.Init_Light_LIGHTV2( * math,lightGroup,POINT_LIGHT_INDEX,LIGHTV2_STATE_ON, LIGHTV2_ATTR_POINT,black, green,black, & plight_pos,NULL, 0, 0.002, 0, 0, 0, 1 );

 

    VECTOR4D slight2_dir       = { -1, 0, -1, 1 };

    VECTOR4D slight2_pos       = { 0, 1000, 0, 1 };

    light.Init_Light_LIGHTV2( * math,lightGroup,SPOT_LIGHT2_INDEX,LIGHTV2_STATE_ON, LIGHTV2_ATTR_SPOTLIGHT2,black, red,black, & slight2_pos,& slight2_dir, 0, 0.001, 0, 0, 0, 1 );

 

 

设置Z缓冲

 

      liushuixian_texture.Create_Zbuffer(& zbuffer, SCREEN_WIDTH,SCREEN_HEIGHT, ZBUFFER_ATTR_32BIT);

 

在每帧中，设定灯光旋转

    staticfloat plight_ang= 0, slight_ang = 0;

物体旋转

    staticfloat x_ang= 0, y_ang = 0, z_ang= 0;

Z缓冲模式

static int z_buffer_mode                 =1;

忘了背面消除，这里补上。

 

int DDRAW_LIUSHUIXIAN_TEXTURE::Cull_OBJECT4DV2( OBJECT4DV2_PTRobj, CAM4DV1_PTRcam, int cull_flags,ddraw_mathmath )

{

    //将物体包围球球心变换为相机坐标

    POINT4D                                sphere_pos;           //用于存储包围球球心变换后的坐标

    //对点进行变换

    math.Mat_Mul_VECTOR4D_4X4( & obj->world_pos,& cam->mcam,& sphere_pos );

    //根据剔除标记对物体执行剔除操作

    if(cull_flags & CULL_OBJECT_Z_PLANE)

    {

         //cull only based on z clipping planes

 

         //test far plane

         if( ((sphere_pos.z- obj->max_radius[obj->curr_frame]) > cam->far_clip_z)||

             ((sphere_pos.z + obj->max_radius[obj->curr_frame])< cam->near_clip_z))

         {

             SET_BIT(obj->state, OBJECT4DV2_STATE_CULLED);

             return(1);

         } //end if

 

    } //end if

 

    if(cull_flags & CULL_OBJECT_X_PLANE)

    {

         //cull only based on x clipping planes

         //we could use plane equations, but simple similar triangles

         //is easier since this is really a 2D problem

         //if the view volume is 90 degrees the the problem is trivial

         //buts lets assume its not

 

         //test the the right and left clipping planes against the leftmost and rightmost

         //points of the bounding sphere

         floatz_test = (0.5)*cam->viewplane_width*sphere_pos.z/cam->view_dist;

 

         if( ((sphere_pos.x-obj->max_radius[obj->curr_frame])> z_test) || // right side

             ((sphere_pos.x+obj->max_radius[obj->curr_frame])< -z_test) )  // left side, notesign change

         {

             SET_BIT(obj->state, OBJECT4DV2_STATE_CULLED);

             return(1);

         } //end if

    } //end if

 

 

    if(cull_flags & CULL_OBJECT_Y_PLANE)

    {

 

         //test the the right and left clipping planes against the leftmost and rightmost

         //points of the bounding sphere

         floatz_test = (0.5)*cam->viewplane_height*sphere_pos.z/cam->view_dist;

 

         if( ((sphere_pos.y-obj->max_radius[obj->curr_frame])> z_test) || // right side

             ((sphere_pos.y+obj->max_radius[obj->curr_frame])< -z_test) )  // left side, notesign change

         {

             SET_BIT(obj->state, OBJECT4DV2_STATE_CULLED);

             return(1);

         } //end if

    } //end if

 

    return( 0 );

}

 

根据Z缓冲，按照Z的大小不同图示如下：



directx3d_beginner
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
opengl与OSG的深度测试
10-09 524
（1）什么是深度？ 深度其实就是该象素点在3d世界中距离摄象机的距离（绘制坐标），深度缓存中存储着每个象素点（绘制在屏幕上的）的深度值！ 深度值（Z值）越大，则离摄像机越远。 深度值是存贮在深度缓存里面的，我们用深度缓存的位数来衡量深度缓存的精度。深度缓存位数越高，则精确度越高，目前的显卡一般都可支持16位的Z Buffer，一些高级的显卡已经可以支持3...
osgEarth使用对数深度缓存
hankern的专栏
01-22 2428
使用对数深度缓存可以在一定程度上解决z冲突(Z-Fighting)，osgEarth也支持使用对数深度缓存，方法是： if ( useLogDepth ) { OE_INFO &lt;&lt; LC &lt;&lt; "Activating logarithmic depth buffer (vertex-only) on main camera" &lt;&l...
OpenGL中的深度、深度缓存、深度测试
lysc_forever的专栏
10-30 2万+
1、深度     所谓深度，就是在openGL坐标系中，像素点Z坐标距离摄像机的距离。摄像机可能放在坐标系的任何位置，那么，就不能简单的说Z数值越大或越小，就是越靠近摄像机。     2、深度缓冲区        深度缓冲区原理就是把一个距离观察平面(近裁剪面)的深度值(或距离)与窗口中的每个像素相关联。     首先，使用glClear(GL_DEPTH_BUFFER_BIT),把所有
OSG 中深度值的一些理解
最新发布
qq_42491346的博客
06-07 509
如果用gl_FragColor = vec4(vec3(gl_FragCoord.z), 1.0)将其可视化，多半会看到一片白。这是由于变换的非线性，大多数点的深度都非常接近于1。gl_FragCoord.z其实就是深度缓冲区中的一个介于0.0到1.0的深度值,该glsl内置值是在片段着色器获得的，因为深度值是在顶点着色器之后，片段着色器之前计算出来的。观察空间的z值可能是投影平截头体的近平面(Near)和远平面(Far)之间的任何值。而观察空间的z值到深度值变换包括非线性和线性两种。
OpenGL和OSG正背面剔除、深度缓冲区
whl0071的专栏
06-24 2061
当2个三维模型有2个面离得比较近的时候，在渲染的时候，在不同的视角下，会发现闪烁的现象，解决这个问题主要依靠opengl的polygonoffset的功能，osg有对应的类， osg::ref_ptrosg::PolygonOffset polyoffset = new osg::PolygonOffset; polyoffset->setFactor(m_factor); polyoffset->setUnits(m_units); node.getOrCreateStateSet()-&gt
从SOURCE_BUFFER单元开始存放了20个字母A, 编程将这20个字母A的字符串传送到DEST_BUFFER开始的单元中.
z2431435的博客
04-05 1424
从SOURCE_BUFFER单元开始存放了20个字母A, 编程将这20个字母A的字符串传送到DEST_BUFFER开始的单元中. data segment source_buffer db 20 dup('A') data ends extra segment dest_buffer db ...
缓存应用--Memcached分布式缓存简介(二)
02-27
1命令行查看状态 很多时候我们需要去查看Memcached的使用状态，比如Memcached的运行时间，使用状态等等。在Windows系统中我们可以使用telnet命令来查看Memcached的相关运行情况。 开始—>运行àcmd运行得到如下：...
Mybatis-plus基于redis实现二级缓存过程解析
08-18
Mybatis-plus基于Redis实现二级缓存过程解析 Mybatis-plus是一款基于Java语言的持久层框架，旨在简化数据库交互操作。然而，在高并发、高性能的应用场景中，数据库的查询操作可能会成为性能瓶颈。为了解决这个问题...
微信小程序--缓存的二次开发封装
03-29
微信小程序缓存是永久性，实际开发中需要定制时效性缓存；因此做了二次开发 设置缓存-----------put(k, v, t) k为key，v为具体内容（支持字符串、json、数组、boolean等等），t为可选参数表示有效时间（单位：秒）如...
从0到1项目搭建-集成 Redis 配置MyBatis二级缓存
10-01
基于 SpringBoot 从0搭建一个企业级开发项目，基于SpringBoot 的项目，并集成MyBatis-Plus、Redis、Druid、Logback ，并使用 Redis 配置 MyBatis 二级缓存。
OpenGL深度测试与深度缓冲以及Z-fighting的消除
菜鸟进化史
12-15 6735
1.深度：是指坐标系中像素点距离摄像机的距离，摄像机可能放在坐标系的任何位置，不能简单地说像素的z越大或越小就是越靠近摄像机。 2.深度缓冲区原理：就是把一个距离观察平面，也就是所谓的近裁剪面的深度值与窗口中每一个像素关联起来，这个深度值我么哦你吧它存储在一个统一的缓冲区中，那么这个缓冲区就被称为深度缓冲区。 3.深度值的产生过程：当GPU执行渲染时，首先要执行的是vertex shader，
openGL 深度测试
热门推荐
05-16 2万+
openGL里常出现深度测试，一直不清楚。今天就来弄清楚。   （1）什么是深度？         深度其实就是该象素点在3d世界中距离摄象机的距离（绘制坐标），深度缓存中存储着每个象素点（绘制在屏幕上的）的深度值！    深度值（Z值）越大，则离摄像机越远。    深度值是存贮在深度缓存里面的，我们用深度缓存的位数来衡量深度缓存的精度。深度缓存位数越高，则精确度越高，目前的显卡一般都可支
OpenGL 深度缓冲区 Z缓冲区 介绍
UnrealEngine4 、Delta3D、OSG
02-08 9529
【颜色缓冲区】 　　颜色缓冲区（COLOR_BUFFER）就是帧缓冲区（FRAME_BUFFER）,你需要渲染的场景最终每一个像素都要写入该缓冲区,然后由它在渲染到屏幕上显示. 【深度缓冲区】 　　深度缓冲区（DEPTH_BUFFER）与帧缓冲区对应,用于记录上面每个像素的深度值,通过深度缓冲区,我们可以进行深度测试,从而确定像素的遮挡关系,保证渲染正确. 【模板缓冲区】
OPENGL深度缓存精度问题及解决
wang371372的专栏
11-09 5931
    前段时间做的小项目需要读取场景的深度图，本打算使用OPENGL自带函数glReadPiexles()去实现此功能，但OPENGL中只提供读取单个像素处的深度信息，不支持读取整个深度缓存的功能。且当时感觉读取到深度是个单字节的，也看到网上有人说深度缓冲和模板缓冲共用4个字节，就自己使用GLSL改写了渲染管道，将深度信息直接渲染出来，这种方法可生成32位精度的深度图。这段时间又翻阅了OPENG...
OpenGL（九） 三维混色和深度缓存设置
牧野的博客
11-12 1849
颜色的混合在现实世界中非常常见，例如隔着有色玻璃观看物体，此时在观察者严重呈现出来物体的颜色就是玻璃的颜色和物体的颜色的混合。 OpenGL在RGBA颜色模式下使用函数glenable(GL_BLEND)开启混色功能，使用glDisable(GL_BLEDN)关闭混色功能。混色功能开启之后，最终显示的颜色的RGBA分量是两个颜色各自的RGBA分量经过一定的公式计算出来。 源因子和目标因
什么是OpenGL中的深度、深度缓存、深度测试？
xiaoquanhuang的专栏
07-18 6513
1）直观理解深度其实就是该象素点在3d世界中距离摄象机的距离，深度缓存中存储着每个象素点（绘制在屏幕上的）的深度值！深度测试决定了是否绘制较远的象素点（或较近的象素点），通常选用较近的，而较远优先能实现透视的效果！！！2）Z值（深度值)、Z buffer(深度缓存)
把ASCII码的字符串转为数字的16进制
奋斗的菜鸟博客
02-17 1万+
/* 函数名称：AsciiToHex 功能：把ASCII码的字符串转为数字的16进制 参数dst：存储16进制数组数据指针 参数src：存储ASCII码的字符串指针 返回值：16进制的数组数据长度 */ int16_t AsciiToHex(uint8_t*dst,uint8_t*src) { uint8_t ch; uint16_t index=0; if(strlen(src) == NULL) { return -1; } if(strl...............
后缓存 深度缓存 模板缓存
kanguolaikanguolaik的专栏
07-07 914
模板测试：http://baike.baidu.com/view/2895466.htm 深度缓存：http://anony3721.blog.163.com/blog/static/511974201141104813412/                   http://
深度缓存
Jave.Lin 的学习笔记
04-14 820
看到了这篇文章的简单描述深度缓存： http://blog.csdn.net/aa20274270/article/details/48735229为了加深理解，写了以下的伪代码： 很多渲染引擎的低层架构，我一点都不了解，都是靠猜的方式， 后面，如果能找到什么更好的学习方法，再拿出来分享； 欢迎大家指点// @authro Jave.Lin // @date 2016-04-14 01:17
Mybatis缓存（1）--------系统缓存及简单配置介绍
08-10
Mybatis提供了两种缓存机制：一级缓存和二级缓存。 一级缓存是Mybatis默认开启的，它是基于SqlSession的缓存，也就是说在同一个SqlSession中，如果多次查询同样的SQL语句并且参数也相同，那么Mybatis会直接从缓存中...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值