思思久久精品在热线热,国内精品久久人妻互换,一本久久a久久精品综合夜夜

Introduction To Octrees

Code Knight — Tue, 23 Feb 2010 13:18:00 GMT

Introduction

Hidden surface removal is among the biggest problems when writing a 3D engine.

I struggled with it since the very beginning of writing 3D engines and still have no satisfactory solution to it. The ideal visibility detection scheme would allow unlimited data, extremely dynamic worlds and would have zero overdraw. The first 3d engine which implements these three demands still has to be written.

The Z buffer for example allows dynamical worlds and even crossing faces, but it suffers from immense overdraw. The BSP-tree on the other hand, if well implemented, has no overdraw at all but needs that much pre-processing that dynamical worlds are a definite nono.

It wasn't until recently i first heard of the octree, and I must admit i was struck by it's simplicity. I never actually implemented this structure and therefore I will present no pseudo code at all. This explanation is merely an attempt to make it more clear to people who have never heard of it. Besides, if you really understand the structure, then implementation is a piece of cake.

The Octree Structure

Our virtual world or level is actually nothing more then a soup of polygons. Some of you people might have thrown in a couple of curves and voxels but most of it will be polygons. Here it is:

Fig 1. Our little level.

In the picture I just built a simple level containing no more than 250 polys. Now imagine a cube surrounding the world like in the next image:

Fig. 2. Our little level surrounded by a cube.

Now it isn't hard to see that this cube can be divided into eight smaller cubes, hence the name octree. Take a look at this picture:

Fig 3. Our little level with the surrounding cube subdivided.

Call the larger cube the parent and the smaller cubes the children. On their turn subdivide each children into eight smaller cubes, and you will notice we are creating a tree where each node has eight children.

There is still one little problem left. When should we stop dividing cubes into smaller ones? There are two possible solutions. The first one is to stop when a cube has some size smaller then a fixed number. The second one is more common. You might have noticed that every child has less polygons then it's parent. The trick is to stop subdividing when the number of polygons in a cube is smaller then some fixed number.

Creating The Octree

Trees are recursion, recursion is trees. It is as simple as that. If you have a correct definition of you cubeNode it is very easy to create an octree recursively. First of all you check all polygons against the boundarys of the cube. This is very simple cause these boundaries are all axis aligned. This means that the cube has six plane equations, which are:

1. X = Q.X

2. Y = Q.Y

3. Z = Q.Z

4. X = Q.X + cubeSize

5. Y = Q.Y + cubeSize

6. Z = Q.Z + cubeSize

Where Q is the position of one corner of the cube. This are very easy equations and the all parent polygons can very easily be checked against them.

It could occur that a polygon crosses a cube boundary. Again two possible solution are at hand. First of all we could clip the polygon against the cube, which is simple, because of the axis aligned boundarys. On the other hand we could put the polygon in all cubes it is in. This means that some cubes can contain the same polygons. In order to prevent us from drawing one poly more than one time we should have a flag on each polygon which will be set if the poly is drawn for the first time.

The implementation of an octree is very straight forward. I haven't done it myself yet, but I will soon. It is all matter of recursion. In order to construct a tree, the first thing you should think of is recursion. Whether we are talking about binary trees, quad trees or octrees, it doesnt matter, just build the darn thing recursively. So have a class definition of one cubeNode and put the creation of the tree in it's constructor. In this constructor you will call the constructor itself for smaller cubes.

The Purpose Of The Octree

An octree is actually nothing more then a data structure. It can be used for very different things. It is not only handy for visibility detection but also for collision detection, realtime shadows and many more things. The most important thing to understand about octrees is that if a parent is not important then it's children aren't either. Let's makes this a little bit more clear with an example.

We will do this in 2d, which therefore resembles a quadtree, but with some imagination it can very easily be extended to 3d. Here we test the cubes (squares) against the viewing frustrum. Take a look at the next picture:

Fig 4. An octree from the top and a viewing frustrum.

In this picture a colored square that has one color was dumped without checking it�K�s children. As you can see some squares had to be checked all the way to the final node, but some large squares could be dumped at once. The colored squares are the ones that are outside the viewing frustrum and the greyscale ones are the one inside the viewing frustrum. As you can see this is actually a worst case scenario because the viewing frustrum crosses the middle of the surrounding square and therefore all the four children have to be checked.

You could also apply the octree to many other things. Collision detection for example. Just check in which cube your bounding sphere or box is and you will only have to check against those faces. There are many more examples.

Conclusion

There is already a lot written about octrees. I tried to give my view on them in the hope somebody might read this. As you can see octrees are way easier to implement than BSP-trees (although some disagree) while offering a better structure. The main point about an octrees is that when a parent is discarded so are it's children. Actually that is all there is to it.

Code clean, play Goldeneye and go vegetarian.

Jaap Suter a.k.a .........

译文�Q?br>1、引�a��Q?span class=English>Introduction�Q?br>　　隐面�U�除是写3D引擎时候最大的问题之一�?br>　　Hidden surface removal is among the biggest problems when writing a 3D engine.

　　在我�?D引擎的开始阶�D�就开始和它斗争�ƈ且一直没有满意的解决�Ҏ��。理想的可见��方案应当做到允许（使用�Q�无限的数据、大动态的世界和零重画。第一��的3D引擎一直在�q�求实现�q?个要求�?br>　　I struggled with it since the very beginning of writing 3D engines and still have no satisfactory solution to it. The ideal visibility detection scheme would allow unlimited data, extremely dynamic worlds and would have zero overdraw. The first 3d engine which implements these three demands still has to be written.

　　Z buffer允许动态世界以及即使是交叉的面�Q�但是得忍受大量的重甅R��另一斚w��Q�BSP树如果能够被很好的实玎ͼ�可以避免重画�Q�但是它需要大量的预处理计��而且不适合动态世界�?br>　　The Z buffer for example allows dynamical worlds and even crossing faces, but it suffers from immense overdraw. The BSP-tree on the other hand, if well implemented, has no overdraw at all but needs that much pre-processing that dynamical worlds are a definite nono.

　　直到最�q�我�W�一�ơ听说了八叉树（Octree�Q�，我必��L��认我被它的简易�?#8220;狠狠地打了一下儿”。我从来没有真正地去实现�q�个�l�构�Q�因此我不会��d��C��些代码。这个解释只是想让从没有听说�q�八叉树的�h感到更清晰易懂。如果你真的了解了这个结构（Octree�Q�，实现它只是一个小意思�?br>　　It wasn't until recently i first heard of the octree, and I must admit i was struck by it's simplicity. I never actually implemented this structure and therefore I will present no pseudo code at all. This explanation is merely an attempt to make it more clear to people who have never heard of it. Besides, if you really understand the structure, then implementation is a piece of cake.

2、八叉树的结�?/strong>�Q?span class=English>The Octree Structure�Q?br>　　我们的实�?#8216;世界’或者说是关卡只不过是一些多边�Ş。你们或许在其中加入了一些曲面（Curves�Q�和Voxels�Q�地形实现方法的一�U�）�Q�但是大多数也都是多边�Ş�?br>　　Our virtual world or level is actually nothing more then a soup of polygons. Some of you people might have thrown in a couple of curves and voxels but most of it will be polygons. Here it is:

�?

　　�?�Q�我们设计的��型兛_��?br>　　Fig 1. Our little level.

　　在这张图片中我徏立了一个不��过250个多边�Ş�?#8216;兛_��’。现在想象有一个包围了�q�个世界的立方体�Q�像下一张图片那栗��?br>　　In the picture I just built a simple level containing no more than 250 polys. Now imagine a cube surrounding the world like in the next image:

�?

　　�?�Q�我们设计的兛_��被一个立方体所包围着�?br>　　Fig. 2. Our little level surrounded by a cube.

　　现在不难看出�q�个立方体可以被八等分�ؓ八个��些的立方体�Q�所以才叫八叉树。看看这张图�Q?br>　　Now it isn't hard to see that this cube can be divided into eight smaller cubes, hence the name octree. Take a look at this picture:

�?

　　�?�Q�对围绕着兛_��的立方体�q�行�l�分�?br>　　Fig 3. Our little level with the surrounding cube subdivided.

　　大点儿的�q�个立方体被叫做‘父亲’��些的立方体叫做‘孩子’。处理每�?#8216;孩子’的时候，再�ؓ更小的八个立方体�Q�你会发现我们在创徏一个每个节�Ҏ��八个子节点（孩子�Q�的树�?br>　　Call the larger cube the parent and the smaller cubes the children. On their turn subdivide each children into eight smaller cubes, and you will notice we are creating a tree where each node has eight children.

　　�q�有一个小问题。什么时候我们该�l�束�l�分的过�E�呢�Q�有两个可行的解��x��法。第一个是当一个立方体的尺寸已�l�比一个预定的固定值小的时候。第二个更普通。你可以注意到每�?#8216;孩子’都比他的‘父亲’有更��的多边形。这��是��_��当一个立方体包含的多边�Ş数量比一个预定的固定值少的时候停止细分�?br>　　There is still one little problem left. When should we stop dividing cubes into smaller ones? There are two possible solutions. The first one is to stop when a cube has some size smaller then a fixed number. The second one is more common. You might have noticed that every child has less polygons then it's parent. The trick is to stop subdividing when the number of polygons in a cube is smaller then some fixed number.

3、创建八叉树�Q?span class=English>Creating The Octree�Q?br>　　树是递归的，递归的是树。就那么��单。如果你正确的定义了你的立方体节点，那么递归地创��Z��个八叉树是很�Ҏ��的。首先，��查所有的多边形（多边形上位置最外面的点作�ؓ�Q�立方体的边界。这很简单因为所有边界都是和坐标轴对其的。这意味着立方体有六个�q�面方程�Q�分别是�Q?br>　　Trees are recursion, recursion is trees. It is as simple as that. If you have a correct definition of you cubeNode it is very easy to create an octree recursively. First of all you check all polygons against the boundarys of the cube. This is very simple cause these boundaries are all axis aligned. This means that the cube has six plane equations, which are:

1. X = Q.X

2. Y = Q.Y

3. Z = Q.Z

4. X = Q.X + cubeSize

5. Y = Q.Y + cubeSize

6. Z = Q.Z + cubeSize

　　在这里Q是立方体一个顶角的位置。这是个很简单的方程�Q�而且所有的父亲多边形可以容易地用这些方�E�来��?br>　　WhereQ is the position of one corner of the cube. This are very easy equations and the all parent polygons can very easily be checked against them.

　　一个多边�Ş�I�过了一个立方体边界�q�样的事情是会发生的。再一�ơ，有两个解��x��案可用。首先我们可以沿着立方体剪切这个多边�Ş�Q�这也是很简单的�Q�因为（立方体的�Q�边界是与坐标��u寚w��的。还有，我们可以把一个多边�Ş攑֜�所有它所在的立方体里面。这��意味着一些立方体可能包含着同一个多边�Ş。�ؓ了防止重��M��个多边�Ş�Q�我们应当在每一个多边�Ş上做一个标讎ͼ�当多边�Ş�W�一�ơ被�ȝ��时候，讄��q�个标记�Q�当然画之前也要��查这个标记啦�Q�不�q�肯定媄响效率�?br>　　It could occur that a polygon crosses a cube boundary. Again two possible solution are at hand. First of all we could clip the polygon against the cube, which is simple, because of the axis aligned boundarys. On the other hand we could put the polygon in all cubes it is in. This means that some cubes can contain the same polygons. In order to prevent us from drawing one poly more than one time we should have a flag on each polygon which will be set if the poly is drawn for the first time.

　　实现一个八叉树是很��单明了的事情�Q�我�q�没有自己做�q�，但是我不久会做的。只不过是递归而已。�ؓ了构造一个树�Q�第一件你该想的事情就是递归。不��我们讨论的是二叉、四叉还是八叉树�Q�都没有区别�Q�都是递归的方法。所以定义一个立方体节点的类�Q�在构造函数里面写上创建树的代码。在�q�个构造函数里面，你会调用到更��立方体的构造函数�?br>　　The implementation of an octree is very straight forward. I haven't done it myself yet, but I will soon. It is all matter of recursion. In order to construct a tree, the first thing you should think of is recursion. Whether we are talking about binary trees, quad trees or octrees, it doesnt matter, just build the darn thing recursively. So have a class definition of one cubeNode and put the creation of the tree in it's constructor. In this constructor you will call the constructor itself for smaller cubes.

4、八叉树的用�?/strong>�Q?span class=English>The Purpose Of The Octree�Q?br>　　一个八叉树实际上就是一个数据结构。它可以用做不同的事情。不仅仅对于‘可见��?#8217;来说很方便，�q�有实时阴媄以及其它斚w��。理解八叉树�q�程中最重要的事情是�Q�如果一�?#8216;父亲’节点�?#8216;没用’的，那么他的‘孩子’节点也同栗��让我们举个例子让它更清楚�?br>　　An octree is actually nothing more then a data structure. It can be used for very different things. It is not only handy for visibility detection but also for collision detection, realtime shadows and many more things. The most important thing to understand about octrees is that if a parent is not important then it's children aren't either. Let's makes this a little bit more clear with an example.

　　我们�?D来表�C�它�Q�这样就很像一个四叉树�Q�但是想象一下它也可以很�Ҏ��的扩展到3D上。在�q�里我们沿着视锥�Q?span class=English>viewing frustrum�Q�检��立方体�Q�正方�Ş�Q��?br>　　We will do this in 2d, which therefore resembles a quadtree, but with some imagination it can very easily be extended to 3d. Here we test the cubes (squares) against the viewing frustrum. Take a look at the next picture:

�?

　　�?�Q�顶部视锥内的八叉树�?br>　　Fig 4. An octree from the top and a viewing frustrum.

　　在这个图片中�Q�彩色的正方形是没有�Q�没必要�Q�检��它�?#8216;孩子’的。就像你看到的那样一些正方�Ş�Q�灰色的一些）被检��直到最�l�节点，但是一些大的正方�Ş只被涂了一�U�颜艌Ӏ�那些彩色的正方形就是超��Z��视锥范围的，灰色的是在视锥范围内的。就像你看到的那��P��q�确实是最�p�糕的一�U�情况，因�ؓ视锥�I�过了包围正方�Ş的中央，所以所有的四个‘孩子’都得被检��?br>　　In this picture a colored square that has one color was dumped without checking it�?children. As you can see some squares had to be checked all the way to the final node, but some large squares could be dumped at once. The colored squares are the ones that are outside the viewing frustrum and the greyscale ones are the one inside the viewing frustrum. As you can see this is actually a worst case scenario because the viewing frustrum crosses the middle of the surrounding square and therefore all the four children have to be checked.

　　你可以应用八叉树到很多别的地斏V��例如碰撞检��。只��查你的碰撞球或者碰撞盒子所在的立方体，而且只需要检��那些面。还有更多的例子�?br>　　You could also apply the octree to many other things. Collision detection for example. Just check in which cube your bounding sphere or box is and you will only have to check against those faces. There are many more examples.

5、结�?/strong>�Q?span class=English>Conclusion�Q?br>　　关于八叉树已�l�写了很多了。我设法表述自己对它的看法，�q�且希望有�h会读到它。就像你看到的那��P��当提供好的结构的时候，八叉树比BSP树更�Ҏ��实现�Q�有人持异议�Q�。主要的一�Ҏ��Q�当一�?#8216;父亲’节点被丢弃的时候，他的‘孩子’节点也同栯��丢弃。实际上�q�就是全部�?br>　　There is already a lot written about octrees. I tried to give my view on them in the hope somebody might read this. As you can see octrees are way easier to implement than BSP-trees (although some disagree) while offering a better structure. The main point about an octrees is that when a parent is discarded so are it's children. Actually that is all there is to it.
　　Code clean, play Goldeneye and go vegetarian. Jaap Suter a.k.a .........

Code Knight 2010-02-23 21:18 发表评论

囑�Ş学学习笔�?(cel-shading分析)

Code Knight — Tue, 23 Feb 2010 13:14:00 GMT

参看word文档
// -------------------------------

// Cel Shading Section

// -------------------------------

vertex_program Ogre/CelShadingVP cg

{

    source Example_CelShading.cg

    entry_point main_vp

    profiles vs_1_1 arbvp1

    default_params

    {

        param_named_auto lightPosition light_position_object_space 0        param_named_auto eyePosition camera_position_object_space

        param_named_auto worldViewProj worldviewproj_matrix

        param_named shininess float 10

    }

}

fragment_program Ogre/CelShadingFP cg

{

    source Example_CelShading.cg

    entry_point main_fp

    profiles ps_1_1 arbfp1 fp20

}

material Examples/CelShading

{

    technique

    {

        pass

        {

            vertex_program_ref Ogre/CelShadingVP

            {

                // map shininess from custom renderable param 1

                param_named_auto shininess custom 1

// �l�于知道param_named_auto�W�三个参数的作用了，用于�l�程序中赋值的索引

sub->setCustomParameter(CUSTOM_SHININESS, Vector4(10.0f, 0.0f, 0.0f, 0.0f)); CUSTOM_SHININESS == 1

            }

            fragment_program_ref Ogre/CelShadingFP

            {

                // map diffuse from custom renderable param 2

                param_named_auto diffuse custom 2

                // map specular from custom renderable param 2

                param_named_auto specular custom 3

            }

            texture_unit

            {

                texture cel_shading_diffuse.png 1d

                tex_address_mode clamp

                filtering none

            }

            texture_unit

            {

                texture cel_shading_specular.png 1d

                tex_address_mode clamp

                filtering none

            }

            texture_unit

            {

                texture cel_shading_edge.png 1d

                tex_address_mode clamp

                filtering none

            }

        }

    }



}

////////////////////////////////////////////////////////////////////////////////////下面�?span>cg文�g

////////////////////////////////////////////////////////////////////////////////

/* Cel shading vertex program for single-pass rendering

   In this program, we want to calculate the diffuse and specular

   ramp components, and the edge factor (for doing simple outlining)

   For the outlining to look good, we need a pretty well curved model.

*/

void main_vp(float4 position    : POSITION,

            float3 normal      : NORMAL,[U1]

            // outputs

            out float4 oPosition    : POSITION,

            out float diffuse     : TEXCOORD0,

            out float specular    : TEXCOORD1,

            out float edge        : TEXCOORD2,[U2]

            // parameters

            uniform float3 lightPosition, // object space�Q�世界坐标系

            uniform float3 eyePosition,   // object space

            uniform float4 shininess,

            uniform float4x4 worldViewProj)

{

    // calculate output position

    oPosition = mul(worldViewProj, position);

    // calculate light vector

    float3 N = normalize(normal);

    float3 L = normalize(lightPosition - position.xyz);



    // Calculate diffuse component

    diffuse = max(dot(N, L) , 0);

    // Calculate specular component

    float3 E = normalize(eyePosition - position.xyz);

    float3 H = normalize(L + E);

    specular = pow(max(dot(N, H), 0), shininess[U3] );

    // Mask off specular if diffuse is 0

    if (diffuse == 0) specular = 0;

    // Edge detection, dot eye and normal vectors

    edge = max(dot(N, E), 0); // 法线与视�U��^行的点认为是标远�Q�给予黑色沟�?/span>

}

void main_fp(float diffuseIn    : TEXCOORD0,

            float specularIn   : TEXCOORD1,

            float edge         : TEXCOORD2,

[U4]

            out float4 colour : COLOR,



            uniform float4 diffuse,

            uniform float4 specular,



            uniform sampler1D diffuseRamp,

            uniform sampler1D specularRamp,

            uniform sampler1D edgeRamp[U5] )

{

    // Step functions from textures

    diffuseIn = tex1D(diffuseRamp, diffuseIn).x;

    specularIn = tex1D(specularRamp, specularIn).x;

    edge = tex1D(edgeRamp, edge).x;

    colour = edge * ((diffuse * diffuseIn) +

                    (specular * specularIn));

}

[U1]�q�里�?/span>GPU传进来的�Q?/span>POSITION�Q�顶点坐标，NORMAL法线�Q�去看看hlsl的语意定�?/span>

[U2]out都是输出参数�Q�改变他们的��D��Z��后被ps获取

[U3]�?/span>m下标gls�Q��ؓ材料的光泽度

[U4]得到的是vs�?/span>out出来的�?/span>

[U5]�?/span>texture_unit中得刎ͼ��序�Ҏ��定义的顺�?/span>texture_unit

                     {

                            texture cel_shading_diffuse.png 1d

                            tex_address_mode clamp

                            filtering none

                     }

                     texture_unit

                     {

                            texture cel_shading_specular.png 1d

                            tex_address_mode clamp

                            filtering none

                     }

                     texture_unit

                     {

                            texture cel_shading_edge.png 1d

                            tex_address_mode clamp

                            filtering none

                     }

Code Knight 2010-02-23 21:14 发表评论

[原]囑�Ş学学习笔�?(光照着色模�?

Code Knight — Tue, 23 Feb 2010 13:13:00 GMT

一�Q�四�U�光照着色模�?/span>

1�Q�固定着�?span>(constant shading)

    固定着色根本不考虑光照模型�Q�只是根据多边�Ş颜色的烦引或RGB值绘制它�?/span>

PS:基本已经被游戏淘汎ͼ�太简单的着色模�?/span>

2�Q�恒定着�Ԍ��flat shding�Q?/span>

    对于每个多边形只需要根据一个顶�Ҏ��行光照计��，然后�Ҏ��计算�l�果�Ҏ��个多边�Ş�q�行着�Ԍ��q�就是恒定着�Ԍ��也称为面片着�?span>(faceted shading)�Q�对于由�q�面�l�成的多边�Ş�q�种�Ҏ��是可行的�Q�立方体�Q�，但对于由曲面�l�成的多边�Ş�q�种着色方式会出现非你惌��的结�?span>.

3�Q?span>Gougraud着�?/span>

　　对于��点之间的像素值采用两个顶点之间的插��D��来��定�Q�顶点之间的颜色�q�渡自然�Q�渲染效果也比较�q�x��,没有恒定着色那��L��兀�?/span>

4�Q?span>Phong着�?/span>

　　�?span>Gougraud着色类��|��不过优点在于�q�对每个像素�q�行了法�U�的插��|��对于镜面反射效果比较好�?/span>

Code Knight 2010-02-23 21:13 发表评论

【�{贴】了解凹凸映��Bump Map技术的内幕

Code Knight — Tue, 23 Feb 2010 13:09:00 GMT
我翻译这��教�E�的目的是�ؓ了帮助那些对囑�Ş渲染技术有兴趣却又苦于找不到免费中文学习资料的人。在我的�w�边没有��M��一位从事计��机专业的前辈，从刚学会WINDOWS的基本操作到现在�Q�我的计��机技术完全都是一步步自学�q�来的，��算学编�E�的历史也近5�q�时间了。我往往要花一半以上的学习旉��用来查学习资料（记得我学GIF囑փ�压羃解压��法�Ӟ��用了�q?个星期时间才�~�出了显�C�GIF囄��的程序，主要原因��是资料不够�Q�只看一两篇短篇�q�的教程来写�E�序�Q�其中多数时间花在调试代码和猜格式上�Q�。所以我寚w��些不是从事计��机专业�Q��n边又没有计算机高手的学习者深有同感——查一堆堆资料是自学中最痛苦的过�E�。这几天我也正在学BUMP MAPPING��法�Q�在看完一��简单的E文教�E�后�Q�我觉得自己也确实应该�ؓ中国的教�E�事业做��Z��Ҏ��微薄的�A献。我�q�不是个3D高手�Q�也只是个初学OpenGL的新手，所以只能先做翻译了。我也希望我的翻译小栯��够抛砖引玉，看到中国��来��多的高手能够真正写点自��q��东西�Q�拿出来与大家分享。由于本人水�q�x��限，��译隑օ�有错误和不妥之处�Q�请多加指正�?br>
��Z��重原作者，同时也是��Z��读者能够对照原文，在此贴出原文地址�Q?br>http://freespace.virgin.net/hugo.elias/graphics/x_polybm.htm　
　

凹凸映射Bump Mapping

　　凹凸映射和纹理映��非常相伹{��然而，�U�理映射是把颜色加到多边形上�Q�而凹凸映��是把粗�p�信息加到多边�Ş上。这在多边�Ş的视觉上会��生很吸引人的效果。我们只需要添加一点信息到本来需要��用大量多边�Ş的物体上。需要注意的是这个物体是�q�的�Q�但是它看�v来却是粗�p�不�q�的。让我们来看看左边的那个立方体。如果你很近地观察它�Ӟ��你会发现它上面的很多�l�节。它看�v来好像是由成千上万个多边形构成的�Q�其实它只是�?个矩形构成。你或许会问�Q?#8220;�q�和�U�理映射有什么不同？”它们的不同之处在于——凹凸映��是一�U�负责光方向的纹理映��?br>
�Q?�Q�凹凸映��背后的原理

　　让我们来看看一个粗�p�的表面�?br>　　　　

　　从远处看�Q�你判断�q�个物体是粗�p�的的唯一证据是在它表面上下的亮度有改变。你的大脑能够获得这些亮暗不一的图案信息，然后判断出它们是表面中有凹凸的部位�?/p>
　　那么你也�怼�问：我是怎么知道哪些点要亮，哪些点要暗呢�Q�这不难。绝大多��C�h生活在这样一�U�环境下——这个环境的大多数光源来自上方（译者注�Q�比如白天主要的光来自太阻I��夜晚主要的光来自天花板上的日光灯�Q�。所以向上倄��地方��׃��更亮�Q�而向下倄��地方��׃��更暗。所以这�U�现象��你的眼睛看到一个物体上亮暗区域�Ӟ��可以判断出它的凹凸情��c��相对亮的块被判断是面向上的�Q�相�Ҏ��的块被判断是面向下的。所以我只需要给物体上的�U�条��单得上色�?br>
　　如果你想要更多的证据�Q�这里还有一�q�几乎相同的图，不同于前的是它旋转了180度。所以它是前一�q�图倒�{的图像。那些先前看��h��是凹�q�去的区域，现在看�v来是凸出来的了�?br>　　　　

　　�q�个时候你的大脑�ƈ没有被完全欺骗，你脑中存留的视觉印象使你仍然有能力判断出�q�是前一�q�图�Q�只是它的光源变了，是从��往上照的你的大脑可能强�q�性地判断出它是第一�q�图。事实上�Q�你只要始终盯着它，�q�且努力地想像着光是从右下方向照��的�Q�你��׃��理解它是凹的�Q�译者注�Q�因为日常生�zȝ��习惯�Q�你会很�Ҏ��把这些图形判断成凸出的图形，但是因�ؓ有了上一�q�对照图的印象，你可能才会特别注意到�q�些囑֝�其实�q�是凹入的，只是判断�Ҏ��不符合我们日常生�z�M��惯，因�ؓ�q�时大多数光不是从上方照��，而是从下往上照��）�?br>
�Q?�Q�什么是凹凸图（Bump Map�Q?/strong>

　　凹凸囑֒��U�理囑־��怼�。但是不同的是，凹凸囑֌�含的不是颜色信息�Q�而是凹凸信息。最通常的方法是通过存储高度值实现。我们要用到一个灰色的�U�理图，灰色的亮度体现出每个点分别凸出多��（见右图）。这��是一个非常方便的保存凹凸囄��Ҏ��Q�而且�q�种囑־��Ҏ��制作。这副图具体又是怎样被渲染器使用的呢�Q�你接着往下看��׃��明白了�?br>
　　当然�Q�你�q�不一定要把自己局限于�q�些��单的囑�Ş�Q�你可以扩展�Q�用它来做木材，做石��_��做脱了漆的墙面，做�Q何你惛_��的物体�?br>　　　　

�Q?�Q�那么它是怎么工作�?/strong>

　　凹凸映射是补色渲染技术（Phong Shading Technique�Q�的一��Ҏ��展，只是在补色渲染里�Q�多边�Ş表面上的法线��被改变�Q�这个向量用来计��该点的亮度。当你加入了凹凸映射�Q�法�U�向量会略微地改变，怎么改变则基于凹凸图。改变法�U�向量就会改变多边�Ş的点的颜色倹{��就�q�么��单�?br>
　　现在�Q�有几种�Ҏ��来达到这个目的（译者注�Q�这个目的指改变法线向量�Q�。我�q�没有实际编写补色渲染和凹凸映射的程序，但是我在�q�里��介�l�一�U�我喜欢的方法来实现�Q?br>
　　现在我们需要将凹凸图中的高度信息�{换成补色渲染用到的法�U�的调节信息。这个做��h��不难�Q�但是解释�v来比较费劌Ӏ?br>
　　　　
　　好的�Q�我们现在将凹凸位图的信息�{换成一些小向量——一个向量对应于一个点。请看左边一副放大的凹凸图。相对亮的点比相�Ҏ��的点更�ؓ凸出。看清楚了吗�Q�现在计��每个点的向量，�q�些向量表征了每个点的倾斜情况�Q�请看下囄��描绘。图中红色小圆点表示向量是向下的�Q?br>　　　　

　　有很多计��向量的�Ҏ��Q�不同的�Ҏ��_��度不同，但是选择什么方法要取决于你所要求的精��度是个什么层�ơ。最通常的方法是分别计算每个点上X和Y的倾斜度：

　　x_gradient = pixel(x-1, y) - pixel(x+1, y)
　　y_gradient = pixel(x, y-1) - pixel(x, y+1)

在得��Z��q�两个倾斜度后�Q�你��可以计��多边�Ş点的法线了�?br>
　　　　

　　�q�里有一个多边�Ş�Q�图上绘��Z��它的一条法�U�向量——n。除此，�q�有两条向量�Q�它们将用来调节该点法线向量。这两条向量必须与当前被渲染的多边�Ş的凹凸图寚w��Q�换句话��_��它们要与凹凸图��用同一�U�坐标��u。下边的囑ֈ�别是凹凸囑֒�多边形，两副��N��昄��了U、V两条向量�Q�译者注�Q�也��是�q�面2D坐标的两条��u�Q�：

　　　　

　　现在你可以看到被调节后的新法�U�向量了。这个调节公式很��单：

　　New_Normal = Normal + (U * x_gradient) + (V * y_gradient)

有了新法�U�向量后�Q�你��可以通过补色渲染技术计��出多边形每个点的亮度了

Code Knight 2010-02-23 21:09 发表评论

OCTREE 教程

Code Knight — Tue, 23 Feb 2010 13:08:00 GMT

对OCTREE的描�q?/strong>

　　OCTREE 是对3D�I�间�q�行划分�Q�也可以叫空间分剌Ӏ�他允许你只对你�?D世界中摄象机照射的区域进行作甅R��他也能用于冲突��。下面讲一下�ؓ什么要�q�行�I�间分割。假设你建立了一个游戏世界，�q�个世界有超�q?00�Q?00个多边�Ş要画。如果你建立一个��@环�ƈ传递这些多边�Ş�Q�那速度是很慢的。即使你有一块很好的昄��卡，他也会有很大的麻烦。但是玩你游戏的玩家的显�C�卡不会��过300$。有没有一�U�方法只渲染摄象机看见的多边形？那就是美丽的OCTREE。他允许你快速的扑ֈ�你要渲染的多边�Ş�?br>

OCTREE是怎样工作�?/strong>

　　OCTREE工作在立方体中。最初，OCTREE从根接点开始，�q�个�Ҏ��点对齐于立方体中整个世界�Q�水�q�x��场景的axis中心�Uѝ��因此，把我们的整个世界惌��成一个不可见的立方体�?br>　

　　现在�Ҏ��点存储了世界中的全部��点。这是，他还是不能给我们��M��好处�Q�因��Z��q�会��L��有的东西。我们想把这个接点分�?个部分。一�ơ，我们划分�Ӟ��?个立方体包含那最初的�Ҏ��点的立方体。那意味着�?个立方体在上面，4个立方体在下面。请看下图：

　　��C��图中黄色轮廓�U�没有�?br>　　我们刚刚把这个世界分�?个部分。想象一下如果我们有2�Q?�Q?个部分，我们的世界将是怎样�Q�我们的摄象机在世界的中��_��向着后面靠右的角落。如果你看这些线�Q�你��注意到在OCTREE�?个结点中的第4个。这些结点包�?个后面的��和底结炏V��这意味着我们只用��d��储在�q�些�l�点中的��点�?/font>

　　我们如何��出我们要画的结点？如果你学�q�破片拣选（frustum culling),�q�将是很��单的。你能得到这些破片的大小�q�检��每个结点，看他是否被截断或在你的视觉破片中。有一个关于破片拣选的教程�?a >http://www.gametutorials.com. 如果一个立方体截断破片�Q�我们就��画�q�些�l�点。在�q�个例子中，我们切的数量是我们需要画�?0%。记住，�q�只是我们世界中的一个部分。部分越多，我们��将��精��。当�Ӟ��我们不会需要太多的炏V��下面，我们来看一下下面的图：

　　在上面这�q�图中，你将发现许多的不同。这个例子中�Q�不是在原始�?个立方体的每一个结点中建立8个新的立方体。原始的8个结点的��和底面没有�l�分。你��L��把一个结点分�?个或更多的结点，但是�Q�如果在�q�个面没有三角�Ş可以存储�Q�我们将忽视�q�个�l�点�q�不�l�他分配内存。如果我们进一步的�l�分�Q�更多的�l�点��Ş成原始的世界。如果我们变换到另一个部分，那立方体��相似的变换。�ؓ了说明这一点，��L��图：

　　在图中，有两个球�Q�但是方向相反。注意左边的部分�Q�他��那世界分成2个结点，不是8个。这是因为球只要2个结炏V��请看右边的球是不是和左边的很相伹{��这�q�图告诉我们�Q�只昄��需要的部分�l�点。如果没有三角�Ş占用�I�间�Q�结点将不会建立�?br>

何时停止�l�分

　　现在�Q�我们明白了如何�l�分�Q�但是我们也需要知道怎样停止�l�分。有许多的方法：
　　1。如果当时的三角形数量少于我们定义的最大的三角形数量，我们可以停止�l�分当前的结炏V��D个例子，我们定义三角形的最大数量�ؓ100。这意味着我们在细分结点之前，要检��一下当前三角�Ş的��L��量是否小于或�{�于我们定义的最大数量，然后再做军_��。如果数量少于或�{�于�Q�我们将停止�l�分�q�指定这些三角�Ş到那个结炏V��请注意我们从不指定��M��三角形到��M��l�点�Q�除非他是末�l�点。如果我们划分一个结点，我们不能存储三角形到那个�l�点�Q�但是可以存储在他的子结�Ҏ��他们的子�l�点中，甚至��C��们的子中�Q�等�{�。当我们复习了怎样�?C树后�Q�将会有更多的了解�?br>
　　2。另一个方法是在停止细分时�Q�看我们是否�l�分的数目是否超�q�了�l�分的标准。例如，我们可以先徏立细分的标准�?0�Q�如果细分的数量大于�q�个标准�Q�我们将停止�q�指定这些在立方体中�q�个面的��点到那个结炏V��当我们�?#8220;大于�q�个标准”��意味着�l�分的数量有11个�?br>
　　3。最后的�Ҏ��是看�l�点数是否超�q�结点变量定义时的倹{��例如，我们讄��l�点变量的��gؓ500。每�ơ，我们建立一个结点，相应的结�Ҏ��增加1。然后在我们每次建立另一个结�Ҏ��Q�检��一下我们当前的�l�点数是否超�q�结点变量。如果结�Ҏ��?01�Q�我们将不会�l�分�q�个�l�点�Q�但是指定他的当前顶点给他。我自己�?1�?的方法，但是1�?也很好，因�ؓ你可以测试不同的�l�分的标准�?br>
　
怎样画OCTREE

　　OCTREE建立后，我们��可以画我们需要的�l�点。那些立方体不是全部包含在我们的视觉中的�Q�只有一部分。这��是我们��Z��么要计算每个�l�点的三角�Ş的数量，如果我们只需要一个结点中的一部分�Q�这��h��们就不需要画成千上万个三角�Ş。我们从根目录开始画OCTREE。对于每个结炚w��存储着一个中心点。这是非常好的，比如在下面这个函��C��Q?br>
　　//�q�个函数取走立方体（X�Q�Y�Q�Z�Q�的中心点和他的大小�Q�width/2)
　　bool CubeInFrustum(float x,float y,float z,float size);

　　�q�个函数�q�回true or false,是由立方体是否在破片中决定的。如果立方体在破片中�Q�我们将��所有他的结点，看他们是否在破片中，否则我们��忽�U�树中的整个分枝。当我们得到了破片中的结点，但是没有��M��l�点在他下面。我们想�ȝ��点存储在末�l�点中。记住，只有末结�Ҏ��点存储。看下面的图�Q?/font>

　　有阴��q��立方体是在破片中。白色的立方体不是在破片中。这里显�C�Z��l�分�?层�?br>

OCTREE 中的冲突

　　OCTREE 不是用于渲染�Q�但是用于冲�H�检��很好。随着游戏的发展，冲突��也在改变，你将不得不在游戏世界中运用自��q��式��你的角色或目标是否冲突。下面是一些冲�H�检��的例子�Q?br>　　1。你��徏立一个函数允�怽�转�?D�I�间中的点到你的OCTREE�q�返回在�q�个点周围的��点。你��{递的那个�Ҏ��你的角色和目标的中心炏V��这虽然可以工作一端时��_��但如果这个点靠近一个立方体的边时呢�Q�你的角色或目标可能和另一个立方体的顶点相冲突。�ؓ了解册��个问题，你将做一些事情。你可以转递角�?目标的半径或一定的�I�间�Q�然后检��半径或一定的�I�间是否和周围的�l�点相冲�H�。这�׃��的角�?目标的�Ş状决定。下面是一些典型的函数�Q?br>
　　//�q�个函数取走角色/目标�Q�X�Q�Y�Q�Z�Q�的中心点�ƈ�q�回靠近他的��点
　　CVector3 *GetVerticesFromPoint(float x,float y,float z);

　　//�q�个函数取走角色/目标�Q�X�Q�Y�Q�Z�Q�的中心点和半径�Q�然后返回和他冲�H�的�l�点中的��点
　　CVector3 *GetVerticesFromPointAndRadius(float x,float y,float z,float radius);

　　//�q�个函数取走角色/目标�Q�X�Q�Y�Q�Z�Q�的中心点和立方体的大小�Q�然后返回和他冲�H�的�l�点中的��点
　　CVector3 *GetVerticesFromPointAndCube(float x,float y,float z,float size);

　　我相信你有更好的�Ҏ��快速的��，在这里只是给你一点基��?br>

�ȝ��

　　�q�篇教程只是�l�你讲截如何建立自己的OCTREE。关于这��文章中的代码在www.gametutorials.com�Q�我希望�q�篇文章对你有用�?br>

中文译者：antking
http://akinggame.gameres.com
�q�篇文章的英文版�?a >http://www.gametutorials.com/Tutorials/OpenGL/Octree.htm

Ben Humphrey (DigiBen)
Game Programmer
DigiBen@GameTutorials.com
Co-Web Host of www.GameTutorials.com

Code Knight 2010-02-23 21:08 发表评论

Code Knight — Tue, 29 Dec 2009 13:54:00 GMT

Code Knight 2009-12-29 21:54 发表评论

shader��综

Code Knight — Sun, 27 Dec 2009 14:17:00 GMT
注明�Q�摘自七星重剑的BLOG
�U�理�Q�Texture�Q?amp;取样器（Sampler�Q?/strong>

�q? 俩东西可以看作特�D�类型变量。纹理就是Shader中用到的贴图资源�Q�这我想没什么好说的。来解释一下取样器�Q�实际上每张贴图在��用的时候都要用一个取�? 器。取样器相当于这样一个结构，除了保存贴图本��n数据之外�Q�还包括�q��o参数�{�取样信息。通常�Q�读取脓图这��L��指��o接收的都是取样器�c�d��的参数而�ƈ非直接接收纹理脓图。声明及使用�U�理或取样器跟��用普通变量一栗��这里有一些初始化取样器的�Ҏ��Q�还是等到后面的实例中讲�q�吧�?br>
Semantic & Annotation

�? 何类型的变量�Q�包括纹理和取样器）�Q�我们都可以用Semantic或Annotation修饰来�v��C��些特�D�作用。Semantic暂时��译成语义； Annotation暂时��译成注解，�q�是HLSL中独特的东西。下面这两行中，�W�一个变量冒号后面的POSITION��是Semantic�Q�第二个变量后面用一对尖括号<>圈�v来的表达式就是Annotation�Q�一�l?lt;>中可以有很多个表辑ּ��?br>
float3 OmniPos : POSITION;
texture TexMap < string name = "test.dds"; >;

一般来�Ԍ��Semantic是告诉应用程序或D3D�q�个被修饰的变量是做什么用的，Annotation是告诉程序这个变量怎么用�? 很云山雾�|�是吗，是这��P��在应用程序代码中�Q�是可以调用D3D的API认出Semantic和Annotation的。例如上面这两行�Q�程序的逻辑��可�? 是这��P��首先写主�E�序的甲和写Shader的乙�U�定好POSITION标识该变量代表灯泡A的位�|�，甲在�E�序里写�Q�{灯��A.位置 = XXX; 扑ֈ�Shader中带POSITION的变�? �l�该变量赋��gؓ灯��A.位置; return;} 那么甲可以不知道乙在Shader中给�q�个要用灯��A位置的变量�v了什么名�Q�而且乙可以在好几个Shader中给用这个数据的变量起不同的名。然后，甲和乙再�U�定遇到Annotation中的“name”��将后面的字�W�串作�ؓ文�g名徏立脓图。于是甲的程序就从Shader中读��Z��一个文件名�Q�徏立了一个脓图以供这个texture变量使用。Semantic和Annotation大概��p��么用�Q�首先要�U�定好各个Semantic和Annotation都是什么意思，�q�是up to you的，然后��是通过它们的标识来�l�变量赋值或作其他辅助性工作了�?br>
既然都是做辅助说明的��Z��么还要分成Semantic和Annotation�Q�我的想法是Semantic��单方便而Annotation能干的事更多。不说这个了�Q�无兛_��局。要说的是，D3D也跟我们�U�定了一套Semantic�Q�它们大体上都能��֐�思义,控制��?br>
�? 制流�Q�就是if…else�Q�for�Q�while什么的。在CPU中，�q�些控制��造成的实际上是指令蟩转。但在GPU中指令蟩转�ƈ不被�q�泛的支持，以往的大部分昑֍�只懂得按��序一句一句执行指令。因此HLSL的编译器可能会做��如展开循环、遍历分支等�{�莽撞的事来适应昑֍�。所以��用时要特别小心，而且不是所有情�늚�控制��语句都被支持�?br>
函数

HLSL 中提供了很多函数可供调用�Q�在Direct3D 文档 -> DirectX Graphics -> Reference -> HLSL Shader Reference -> HLSL Intrinsic Functions中有�q�些函数的详�l�列表。也可自己写函数用，但是在较早的Shader版本中，��像内联函数一��L��译时最�l�要��函数展开插入到函数调�? 处。还有一�Ҏ��想你一定会惛_��的就是主函数会是什么。Vertex Shader和Pixel Shader各自需要一个主函数�Q�由�E�序员来指定�Q�没错，�E�序员在Shader外部指定�?

Code Knight 2009-12-27 22:17 发表评论

Code Knight — Tue, 08 Dec 2009 14:28:00 GMT

Code Knight 2009-12-08 22:28 发表评论

昏头�Q�被Intersect折腾了半天！

Code Knight — Wed, 11 Feb 2009 09:41:00 GMT
          D3D中的PICK例程中有�q�样的一个检��函敎ͼ��拾取，具体原理�|�上有很多，自己改了一下，却掉了两个重要的东西�Q�不�q�还不是很明白是怎么一回事�Q�修�Ҏ��线起始点的坐标有何用呢�Q?br>
  1 BOOL IntersectTest(LPDIRECT3DVERTEXBUFFER9 pVB,
  2                    LPDIRECT3DINDEXBUFFER9 pIB,
  3                    int nStride,
  4                    int dwNumFaces,
  5                    D3DXVECTOR3* vPickRayOrig,
  6                    D3DXVECTOR3* vPickRay,
  7                    D3DXVECTOR3 *pVRet,
  8                    DWORD dwFlag=0) // 主要��与地�Ş�怺� // 此函数相当耗费CPU// 生成地�Ş�?3W个面�Q�逐一��查是否相�?/span>
  9 {
10     WORD*        pIndices;
11     BYTE*        pVertices;
12     D3DINDEXBUFFER_DESC IB_Desc;
13
14     FLOAT fBary1, fBary2,fDist=1e+32f;
15
16     FLOAT t_fBary1, t_fBary2,t_fDist;
17     DWORD dwFace=-1;
18     DWORD  dwUpperLower;
19
20     D3DXVECTOR3* pV[3];
21     ULONG  n;
22
23     pIB->GetDesc(&IB_Desc);
24     pIB->Lock( 0, 0, (void**)&pIndices, 0 );
25     pVB->Lock( 0, 0, (void**)&pVertices,0 );
26
27
28     for( DWORD i=0; i<dwNumFaces; i++ )
29     {
30         for(int j=0;j<3;j++)
31         {
32             if(IB_Desc.Format==D3DFMT_INDEX16)
33                 n=(WORD)pIndices[3*i+j];
34             else if(IB_Desc.Format==D3DFMT_INDEX32)
35                 n=*(DWORD*)&pIndices[2*(3*i+j)];
36             else
37                 return FALSE;
38             pV[j]=(D3DXVECTOR3*)(pVertices+nStride*n);
39         }
40
41         dwUpperLower=0;
42
43          if(dwFlag) // �q�段是必��要的，具体是怎么做到的？
44          {
45              if(dwFlag & INTERSECT_NEGATIVEY)
46              {
47                 for(int j=0;j<3;j++)
48                 {
49                     dwUpperLower|=vPickRayOrig->x>pV[j]->x? 0x0010:0x0001;
50                     dwUpperLower|=vPickRayOrig->z>pV[j]->z? 0x1000:0x0100;
51
52                 }
53                 if(dwUpperLower!=0x1111) continue;
54             }
55             else if(dwFlag & INTERSECT_HORIZENTAL)
56             {
57                 for(int j=0;j<3;j++)
58                 {
59                     dwUpperLower|=(vPickRayOrig->y > pV[j]->y)? 0x0010:0x0001;
60                 }
61
62                 if(dwUpperLower!=0x0011) continue;
63             }
64
65
66         }
67
68
69
70         // ��是否穿�q�三角�Ş
71         if( IntersectTriangle( *vPickRayOrig, *vPickRay, *pV[0], *pV[1], *pV[2],
72             &t_fDist, &t_fBary1, &t_fBary2 ) )
73         {
74             if(    t_fDist < fDist )    //是否�q�回最�q�的一个点
75             {
76                 dwFace = i;
77                 fBary1 = t_fBary1;
78                 fBary2 = t_fBary2;
79                 fDist  = t_fDist;
80             }
81         }
82     }
83
84
85     if(dwFace<dwNumFaces && dwFace>=0 )
86     {
87
88         for(int j=0;j<3;j++)
89         {
90             if(IB_Desc.Format==D3DFMT_INDEX16)
91                 n=(WORD)pIndices[3*dwFace +j];
92             else if(IB_Desc.Format==D3DFMT_INDEX32)
93                 n=*(DWORD*)&pIndices[2*(3*dwFace+j)];
94             else
95                 return FALSE;
96             pV[j]=(D3DXVECTOR3*)(pVertices+nStride*n);
97         }
98         *pVRet=*pV[0] +fBary1*(*pV[1]-*pV[0])+fBary2*(*pV[2]-*pV[0]);
99
100
101         pVB->Unlock();
102         pIB->Unlock();
103         return 1;
104     }
105
106
107     pVB->Unlock();
108     pIB->Unlock();
109
110
111
112     return 0;
113 }
另一个问题，大规模的地�Ş一般如何最大程度的优化避免�Ҏ��有的面进行检��？用LOD么？

Code Knight 2009-02-11 17:41 发表评论

思思久久精品在热线热,国内精品久久人妻互换,一本久久a久久精品综合夜夜

Introduction To Octrees

囑�Ş学学习笔�?(cel-shading分析)

[原]囑�Ş学学习笔�?(光照着色模�?

【�{贴】了解凹凸映���Bump Map技术的内幕

OCTREE 教程

shader���综

昏头�Q�被Intersect折腾了半天！

【�{贴】了解凹凸映��Bump Map技术的内幕

shader��综