亚洲精品一区在线观看,国产亚洲一区二区三区,亚洲第一主播视频

bloodbao — Sun, 09 Nov 2008 12:47:00 GMT

DX9下��?br>D3DXPLANE plane;
D3DXPlaneFromPointNormal( &plane, &vPoint, &vNormal ); //生成�q�个�q�面
D3DXMatrixReflect( &matReflect, &plane ); //取得该��^面的反射矩阵
//讄��剪切�q�面�Q��反射面上的内容被渲染�Q�面下的被丢�?
m_pd3dDevice->SetClipPlane( 0, plane );
m_pd3dDevice->SetRenderState( D3DRS_CLIPPLANEENABLE, 0x01 );
DX10下模拟：
User Clip PlanesUser Clip Planes are emulated by specifying a clip distance output from the Vertex Shader with the SV_ClipDistance[n] flag, where n is either 0 or 1. Each component can hold up to 4 clip distances in x, y, z, and w giving a total of 8 clip distances.

用户裁减�q�面通过在VS里设定一个SV_ClipDistance[n]标记�Q�定义一个裁减距��输出得�?n�?�?。这里一��p��存放8个Clip Plane距离�Q�分别��用数�l�两个元素的x,y,z,w通道�?/p>

In this scenario, each clip planes is defined by a plane equation of the form:

在这个场景里�Q�每个clip plane被一个��^面方�E�定义：

Ax + By + Cz + D =0;

Where is the normal of the plane, and D is the distance of the plane from the origin. Plugging in any point into this equation gives its distance from the plane. Therefore, all points that satisfy the equation Ax + By + Cz + D = 0 are on the plane. All points that satisfy Ax + By + Cz + D < 0 are below the plane. All points that satisfy Ax + By + Cz + D > 0 are above the plane.

是��^面法向，D是��^面到原点的距��R��把��L��?lt;x,y,z>代入方程能得到它到��^面的距离。所有满��x��E�＝0的点在��^面上�Q?lt;0的点在��^面下�?>0的点在��^面上�?/p>

In the Vertex Shader, each vertex is tested against each plane equation to produce a distance to the clip plane. Each of the three clip distances are stored in the first three components of the output component with the semantic SV_ClipDistance0. These clip distances get interpolated over the triangle during rasterization and clipped if the value every goes below 0.

在VS中，每个��点会带入��^面方�E�做��试。每个三角�Ş的Clip距离存在SV_ClipDistance0语义输出的前三个通道中。这个距��d��光栅化中被线性插��|��所有小�?的像素被剔除�?/p>

bloodbao 2008-11-09 20:47 发表评论

rendering调试

bloodbao — Thu, 23 Oct 2008 13:55:00 GMT

�q�期较闲�Q�主要修改rendering架构�Q�减��DX9的接口，全面使用DX10的接口，修改变动非常大，初调试三千多个ERROR�Q�现减�ؓ850多个�Q�不�q�，内部错误�q�是很多。希望能在DX11发布前，全部改完。第二步�Q�会建立更庞大的ISCENENODE�Q�以满��快速测试和新版SCENEEDIT需要。暂��C��?

bloodbao 2008-10-23 21:55 发表评论

Main Features in my blood engine

bloodbao — Mon, 11 Aug 2008 07:05:00 GMT

Main Features in my blood engine
Direct3D 9 is used to render the scene
User input is gathered though DirectInput
Single pass multi-texturing using the fixed-function pipeline (FFP)
Light-mapping
Frustum culling
Simple skybox
Keyframe Animation with GPU-based frame interpolation through a custom vertex and pixel shader written in HLSL. This technique is also known as Vertex Tweening or even Morph Target
Support for Quake2 models (.md2)
Support for DirectX models (.x)
Support for PCX texture loading in addition to the other image formats already supported by Direct3D
Support for Quake3:Arena levels
Lightmaps
Curved surfaces using Bezier patches
Partial support of Quake3 materials and effects (.shader)
Uses the BSP/PVS to quickly discard non visible geometry
Collision detection using the BSP tree (supports ray, sphere and box sweeps)
A flexible scene graph system where entities can be attached to each other in order to perform hierarchical transformations and geometry culling
Quake-like player movement physics
A powerful in-game console system:
Outputs vital information
Can take command inputs from the user
Console variables can be dynamically edited at runtime
Commands and console variable settings can be loaded from a user-specified text file (cfg)
Garbage collection of unused resources through reference counting
Control keys can be dynamically changed in-game through the console, using the bind command
User input is abstracted through an Action Manager which maps inputs to actions
A smart chase-camera controller that will detect collisions with the world to prevent the view from being occluded by other pieces of world geometry.
Error handling through exceptions
The in-game HUD can display vital performance statistics about the game, such as frames per second, total number of triangles on the screen, number of textures loaded, etc…

bloodbao 2008-08-11 15:05 发表评论

又失败了

bloodbao — Wed, 06 Aug 2008 02:36:00 GMT

��Z��q�次面试�Q�我休息了很多天�Q�都没工作。结果，得到的又是一个失败的�l�局。分析原因，都认为我的C++基础很薄弱吧�Q�要不就是因为我以前从事的工作和现在的工作差别太大了�?br> 作�ؓ一名新手，我很�q��Q�在学习的道路我没有被打败，却在两次面试中，深受打击。我不仅在想�Q�这是否是我要选择的�\。仅剩半个多月的旉��Q�暑期就�l�束了，我再不出去，��没��Z��了。事实上�Q�做不做游戏�Q�我无所谓，但现在的生活一直不是我惌��的。我不断地在否定自已的�\上，��走��远�Q�找不到真实的我�?br> 两个月很快就�q�去了，我只能静下心来去做事情，把这些烦人的事，都抛于脑后。�\�q�是要走�Q��h��L��要成长的�Q�希望能从失败中走出来�?br> ��C��今天的失败，以作自勉�?/p>

bloodbao 2008-08-06 10:36 发表评论

bloodbao — Sun, 20 Jul 2008 02:48:00 GMT

主要是用模板�~�冲区来实现�?br>DepthStencilState StencilShadow
{
    DepthEnable = true;
    DepthWriteMask = ZERO;
    DepthFunc = LESS;

    StencilEnable = true;
    StencilReadMask = 0xFFFFFFFF;
    StencilWriteMask = 0xFFFFFFFF;

    FrontFaceStencilFunc = ALWAYS;
    FrontFaceStencilPass = INCR;
    FrontFaceStencilFail = Keep;

    BackFaceStencilFunc = ALWAYS;
    BackFaceStencilPass = DECR;
　BackFaceStencilFail = Keep;
};
BlendState AdditiveBlending
{
    AlphaToCoverageEnable = FALSE;
    BlendEnable[0] = TRUE;
    SrcBlend = SRC_ALPHA ;
    DestBlend = INV_SRC_ALPHA ;
    BlendOp = ADD;
    SrcBlendAlpha = ZERO;
    DestBlendAlpha = ZERO;
    BlendOpAlpha = ADD;
    RenderTargetWriteMask[0] = 0x0F;
};

Rendering Shadows

At the top level, the rendering steps look like the following:

If ambient lighting is enabled, render the entire scene with ambient only.
For each light in the scene, do the following:
- Disable depth-buffer and frame-buffer writing.
- Prepare the stencil buffer render states for rendering the shadow volume.
- Render the shadow volume mesh with a vertex extruding shader. This sets up the stencil buffer according to whether or not the pixels are in the shadow volume.
- Prepare the stencil buffer render states for lighting.
- Prepare the additive blending mode.
- Render the scene for lighting with only the light being processed.

Shadow Volume�q�不是一个没有缺��L��技术。除了高像素填充率和阴媄边界��外�Q�在�l�制�q�程中还可能出现错误。错误的主要原因是当一个几何模型在计算自阴影时�Q�它的面通常被完全照亮或者完全变暗，�q�取决于�q�个面是否朝向光源。光照计��必��M��用顶�Ҏ��向而非表面法向。对于接�q��^行光源的面，它会被完全照亮或者完全变暗，而实际上应该部分处于光源中。这是从stencil shadow volume中��承来的问题，在计��阴影时必须被考虑。这个问题可以通过增加mesh密度来解冻I��q�也增加了处理mesh的时间。顶�Ҏ��向和面法向越接近�Q�表面的问题��p��。如果程序不能把问题限制在可接受的范围内�Q�就必须考虑使用其他的算法，比如PRT或者Shadow Map�?

bloodbao 2008-07-20 10:48 发表评论

dx10之模拟DX9

bloodbao — Sun, 20 Jul 2008 02:31:00 GMT

Fixed-function Lighting Pipeline
ColorsOutput CalcLighting( float3 worldNormal, float3 worldPos, float3 cameraPos )
{
    ColorsOutput output = (ColorsOutput)0.0;

    for(int i=0; i<8; i++)
{
     //光线方向
        float3 toLight = g_lights[i].Position.xyz - worldPos;
         //��d��源距��?br>        float lightDist = length( toLight );
         //atten�Q�（1/(a[2]*d*d+a[1]*d+a[1])
        float fAtten = 1.0/dot( g_lights[i].Atten, float4(1,lightDist,lightDist*lightDist,0) );
        float3 lightDir = normalize( toLight );
         //H
        float3 halfAngle = normalize( normalize(-cameraPos) + lightDir );

         //Phong方程�Q�逐顶点光�?br>        output.Diffuse += max(0,dot( lightDir, worldNormal ) * g_lights[i].Diffuse * fAtten) + g_lights[i].Ambient;
        output.Specular += max(0,pow( dot( halfAngle, worldNormal ), 64 ) * g_lights[i].Specular * fAtten );
    }

    return output;
}
��单ALPHA��试
//
// PS for rendering with alpha test
//
float4 PSAlphaTestmain(PSSceneIn input) : COLOR0
{
         float4 color = tex2D( g_samLinear, g_txDiffuse, input.tex ) * input.colorD;
         if( color.a < 0.5 )
                 discard;
         return color;
}
雑֌��Q?/p>

//
// Calculates fog factor based upon distance
//
// E is defined as the base of the natural logarithm (2.71828)
float CalcFogFactor( float d )
{
         float fogCoeff = 1.0;

         if( FOGMODE_LINEAR == g_fogMode )
         {
                 fogCoeff = (g_fogEnd - d)/(g_fogEnd - g_fogStart);
         }
         else if( FOGMODE_EXP == g_fogMode )
         {
                 fogCoeff = 1.0 / pow( E, d*g_fogDensity );
         }
         else if( FOGMODE_EXP2 == g_fogMode )
         {
                 fogCoeff = 1.0 / pow( E, d*d*g_fogDensity*g_fogDensity );
         }

         return clamp( fogCoeff, 0, 1 );
}

Finally, the pixel shader uses the fog factor to determine how much of the original color and how much of the fog color to output to the pixel.

最后，PS使用雑֌�参数��定��N��色和�U�理颜色的�؜合程度�?br>return fog * normalColor + (1.0 - fog)*g_fogColor;

bloodbao 2008-07-20 10:31 发表评论

bloodbao — Thu, 17 Jul 2008 02:26:00 GMT

刚开始学习DX10�Q�发觉模型文件已�l�从原来的X格式变�ؓSDKMESH格式�Q�也��是说DX10不直接支持X文�g了，
那现在该怎么办，我在NVSDK下找��C��他的解决�Ҏ��Q�先用DX9的接口打开X文�g�Q�再用DX10接口来渲染文件�?br>         在DX10下，�~�少了很多以前在DX9下的元素。比如，光照�Q�材质等�?br>         要实现这些元素，��必��d��SHADER下手动去实现�Q�那��意味着你必��ȝ��悉图形学的内容，特别是其中的光照模型�{�内宏V�?br>比如�Q�方向光的实玎ͼ�
    //directional light-----------------------------------------------------------------
    float3 lightDir = g_lightPos - In.worldPos;
    float3 lightDirNorm = normalize(lightDir);
    float3 SDir = normalize( g_lightPos - g_eyePos);
    float cosGammaDir = dot(SDir, V);
    float dirLighting = g_Kd*dirLightIntensity*saturate( dot( N,lightDirNorm ) );
    //diffuse
    float3 diffuseDirLight = dirLighting*exDir;
    //airlight
    float3 dirAirLight = phaseFunctionSchlick(cosGammaDir)* dirLightIntensity*float3(1-exDir.x,1-exDir.y,1-exDir.z);
    //specular
    float3 specularDirLight = saturate( pow( dot(lightDirNorm,reflVect),g_specPower)) * dirLightIntensity * g_KsDir * exDir;
点光源的实现�Q?br> //point light 1---------------------------------------------------------------------
    //diffuse surface radiance and airlight due to point light
    float3 pointLightDir = g_PointLightPos - In.worldPos;
    //diffuse
    float3 diffusePointLight1 = calculateDiffusePointLight(0.1,Dvp,g_DSVPointLight,pointLightDir,N,V);
    //airlight
    float3 airlight1 = calculateAirLightPointLight(Dvp,g_DSVPointLight,g_VecPointLightEye,V);
    //specular
    float3 specularPointLight = Specular(g_PointLightIntensity, g_KsPoint, length(pointLightDir), Dvp, g_specPower, normalize(pointLightDir), reflVect);
计算点光源的漫射光：
float3 calculateDiffusePointLight(float Kd,float Dvp,float Dsv,float3 pointLightDir,float3 N,float3 V)
{

    float Dsp = length(pointLightDir);
    float3 L = pointLightDir/Dsp;
    float thetas = acos(dot(N, L));
    float lightIntensity = g_PointLightIntensity * 100;

    //spotlight
    float angleToSpotLight = dot(-L, g_SpotLightDir);
    if(g_useSpotLight)
    {    if(angleToSpotLight > g_cosSpotlightAngle)
             lightIntensity *= abs((angleToSpotLight - g_cosSpotlightAngle)/(1-g_cosSpotlightAngle));
         else
             lightIntensity = 0;
    }

    //diffuse contribution
    float t1 = exp(-g_beta.x*Dsp)*max(cos(thetas),0)/Dsp;
    float4 t2 = g_beta.x*Gtable.SampleLevel(samLinearClamp, float2((g_beta.x*Dsp-g_diffXOffset)*g_diffXScale, (thetas-g_diffYOffset)*g_diffYScale),0)/(2*PI);
    float rCol = (t1+t2.x)*exp(-g_beta.x*Dvp)*Kd*lightIntensity/Dsp;
    float diffusePointLight = float3(rCol,rCol,rCol);
    return diffusePointLight.xxx;
}
计算高光�Q?br>float3 Specular(float lightIntensity, float Ks, float Dsp, float Dvp, float specPow, float3 L, float3 VReflect)
{
    lightIntensity = lightIntensity * 100;
    float LDotVReflect = dot(L,VReflect);
    float thetas = acos(LDotVReflect);

    float t1 = exp(-g_beta*Dsp)*pow(max(LDotVReflect,0),specPow)/Dsp;
    float4 t2 = g_beta.x*G_20table.SampleLevel(samLinearClamp, float2((g_beta.x*Dsp-g_20XOffset)*g_20XScale, (thetas-g_20YOffset)*g_20YScale),0)/(2*PI);
    float specular = (t1+t2.x)*exp(-g_beta.x*Dvp)*Ks*lightIntensity/Dsp;
    return specular.xxx;
}
下一步，考虑如何不通过DX9接口�Q�直接导入X文�g�?/p>

bloodbao 2008-07-17 10:26 发表评论

学习光线�q�踪

bloodbao — Sun, 06 Jul 2008 02:53:00 GMT

                           学习光线�q�踪�Q�格式都�׃��Q�郁��P��
��线�cȝ��定义�Q?br>class Ray
{
   public:
Ray() : m_Origin( vector3( 0, 0, 0 ) ), m_Direction( vector3( 0, 0, 0 ) ) {};
Ray( vector3& a_Origin, vector3& a_Dir );
   private:
vector3 m_Origin;
vector3 m_Direction;
};
光线�q�踪��法�Q?br>For each pixel
{
Construct ray from camera through pixel
Find first primitive hit by ray
Determine color at intersection point
Draw color
}
求最�q�交�?br> // find the nearest intersection
for ( int s = 0; s < m_Scene->GetNrPrimitives(); s++ )
{
Primitive* pr = m_Scene->GetPrimitive( s );
int res;
if (res = pr->Intersect( a_Ray, a_Dist ))
{
  prim = pr;
  result = res; // 0 = miss, 1 = hit, -1 = hit from inside primitive
}
}
交点的颜�Ԍ��
// determine color at point of intersection
pi = a_Ray.GetOrigin() + a_Ray.GetDirection() * a_Dist;
// trace lights
for ( int l = 0; l < m_Scene->GetNrPrimitives(); l++ )
{
Primitive* p = m_Scene->GetPrimitive( l );
if (p->IsLight())
{
  Primitive* light = p;
  // calculate diffuse shading
  vector3 L = ((Sphere*)light)->GetCentre() - pi;
  NORMALIZE( L );
  vector3 N = prim->GetNormal( pi );
  if (prim->GetMaterial()->GetDiffuse() > 0)
  {
   float dot = DOT( N, L );
   if (dot > 0)
   {
    float diff = dot * prim->GetMaterial()->GetDiffuse();
    // add diffuse component to ray color
    a_Acc += diff * prim->GetMaterial()->GetColor() * light->GetMaterial()->GetColor();
   }
  }
}
}
计算反射�Q?br>// calculate reflection
float refl = prim->GetMaterial()->GetReflection();
if (refl > 0.0f)
{
vector3 N = prim->GetNormal( pi );
vector3 R = a_Ray.GetDirection() - 2.0f * DOT( a_Ray.GetDirection(), N ) * N;
if (a_Depth < TRACEDEPTH)
{
  Color rcol( 0, 0, 0 );
  float dist;
  Raytrace( Ray( pi + R * EPSILON, R ), rcol, a_Depth + 1, a_RIndex, dist );
  a_Acc += refl * rcol * prim->GetMaterial()->GetColor();
}
}
Phong光照公式�Q�intensity = diffuse * (L.N) + specular * (V.R)n

vector3 V = a_Ray.GetDirection();
vector3 R = L - 2.0f * DOT( L, N ) * N;
float dot = DOT( V, R );
if (dot > 0)
{
float spec = powf( dot, 20 ) * prim->GetMaterial()->GetSpecular() * shade;
// add specular component to ray color
a_Acc += spec * light->GetMaterial()->GetColor();
}
计算阴媄
// handle point light source
float shade = 1.0f;
if (light->GetType() == Primitive::SPHERE)
{
vector3 L = ((Sphere*)light)->GetCentre() - pi;
float tdist = LENGTH( L );
L *= (1.0f / tdist);
Ray r = Ray( pi + L * EPSILON, L );
for ( int s = 0; s < m_Scene->GetNrPrimitives(); s++ )
{
  Primitive* pr = m_Scene->GetPrimitive( s );
  if ((pr != light) && (pr->Intersect( r, tdist )))
  {
   shade = 0;
   break;
  }
}
}

bloodbao 2008-07-06 10:53 发表评论

我名字的由来

bloodbao — Sun, 29 Jun 2008 09:42:00 GMT

自从我迷上了星际SC以后�Q�就有了�q�个名字�Q�网名）�?br>Blizzard=暴雪
Bloodbao=血�?雪�v-----------------刚好和暴雪的音相反！
沉迷于游戏，沉迷于游戏编�E�，Bloodbao正在逐渐成长�?br>特记录，以作怀念！

bloodbao 2008-06-29 17:42 发表评论

3DEditor

bloodbao — Tue, 17 Jun 2008 07:27:00 GMT

我做的第二个�~�辑器，是基于OPENGL+WXWIDGETS的，本来��x��囄��的�?br>但昨天看了群里AZ的设计界面，深感作品的不成熟�Q�所以对界面开始重新编写�?/p> �q�个�~�辑器，用来做地形的�Q�参考了很多人的作品�Q�希望最�l�不要成为四不象�Q?br>�l�箋努力中。。。�?br>MARK!

bloodbao 2008-06-17 15:27 发表评论

IRR的效果图

bloodbao — Thu, 05 Jun 2008 02:33:00 GMT

�l�箋学习�?

bloodbao 2008-06-05 10:33 发表评论

bloodbao — Fri, 30 May 2008 12:11:00 GMT

BSP技术详�?

eXtreme3D

��译自一��老外的文�?lt;Binary Space Partioning Trees and Polygon Removal in Real Time 3D Rendering>,最后一�Ҏ��有翻译完,呵呵,不太好意�?!!!!
BSP技术作为室内引擎渲染的��L��技术虽然已�l�存在多�q?但是生命力仍焉��帔R��?最新的DOOM3,HL2仍然��它作�ؓ渲染的主��技�?但是在网上对它介�l�文章虽然多却非常浅�?大多是��用Q3的BSP文�g�q�行渲染,而BSP文�g如何产生则介�l�非常少,盖因��一部分是场景编辑器的工�?而完成一个这��L��BSP�~�辑器是非常困难�?需要掌握的知识非常�?下面我将对BSP�~�辑器这一部分需要用到的BSP知识�q�行一下介�l?�q�只是一些很初步的知�?如希望了解更多的内容,Q2开源代码中有一个BSP�~�辑器的代码是你研究的重�?�q�有��是HL2泄露代码中的�~�辑器代�?(一个痛苦的研究�q�程,可能要花费你几个月甚至一�q�的旉��,不过�q�是值得�?如果你想完成一个主��的��击游戏引擎的话,没有BSP�~�辑器是不可惌��?.

�W�一�?BSP Trees
BSP Trees英文全称为Binary Space Partioning trees�Q�二�l�空间分割树�Q�简�U�Cؓ二叉树。它�?969�q�被Shumacker在文章《Study for Applying Computer-Generated Images to Visual Simulation》首�ơ提出，�q�被ID公司�W�一�ơ��用到FPS游戏Doom中，Doom的推��得了�I�前的成功，不仅奠定了ID公司在FPS游戏开发的宗师��C��Q�也使BSP技术成为室内渲染的工业标准�Q�从BSP产生到现在已�l�有30多年了，光��虽然产生了大量的室内渲染的算法，但却无�h能撼动它的地位，对于以摩��定律发展的计算��Z��来说�q�不能不是一个奇�q�V�?br>��Z��么��用BSP Trees
一个BSP Trees如同它的名字一��h��一个层�ơ树的结构，�q�个树的叶节点保存了分割室内�I�间所得到的图元集合。现在随着��g加速Z�~�冲的出玎ͼ�我们只需要用很小的代价就可以对空间中的图元进行排序，但是�?0�q�代初由于硬件的限制�Q��用BSP的主要原因是因�ؓ它可以对�I�间中的囑օ��q�行排序来保证渲染图元的��序是按照由后至前进行的�Q�换句话��_��Z值最��的物体��L��最后被渲染。当然还有其他的��法可以完成�q�个功能�Q�例如著名的��d��法�Q�但是它与BSP比较��h��速度太慢了，�q�是因�ؓBSP通常对图元排序是预先计算好的而不是在�q�行时进行计��。从某种意义上说BSP技术实际上是画家算法的扩展�Q�正如同BSP技术的原始设计一��P��d��法也是使用由后臛_��的顺序对场景中的物体�q�行渲染。但是画家算法有以下的缺点：
l 如果一个物体从另一个物体中�I�过时它不能被正��的渲染�Q?br>l 在每一帧对被渲染的物体�q�行排序是非常困隄��Q�同时运��的代�h非常大；
l 它无法管理��@环覆盖的情况�Q�如图所�C?

�?.1
BSP原理
建立BSP Trees的最初想法是获得一个图元的集合�Q�这个集合是场景的一部分�Q�然后分割这个图元集合�ؓ更小的子集合�Q�这里必��L��意子集合必须�?#8220;凸多边�Ş”。这意味着子集合中��M��个多边�Ş都位于相同集合中其它多边形的“前面”。是不是有点难以理解呢，举一个例子，如果多边形A的每一个顶炚w��位于由多边�ŞB所�l�成的一个面的正面，那么可以说多边�ŞA位于多边形B�?#8220;前面”�Q�参考左图。我们可以想象一下，一个盒子是�?个面�l�成的，如果所有的面都朝向盒子的内部，那么我们可以说盒子是一�?#8220;凸多边�Ş”�Q�如果不是都朝向盒子的内部，那么盒子��׃��?#8220;凸多边�Ş”�?nbsp;

�?.2
下面让我们看一下如何确定一个图元集合是否是一�?#8220;凸多边�Ş”�Q�伪��法如下�Q?br>l 函数CLASSIFY-POINT
l 参数:
l Polygon – ��定一�?D�I�间中点相对位置的参考多边�Ş�?br>l Point – 待确定的3D�I�间中的炏V�?br>l �q�回�?
l 点位于多边�Ş的哪一辏V�?br>l 功能:
l ��定一个点位于被多边�Ş定义的面的哪一辏V�?br>CLASSIFY-POINT (Polygon, Point)
1 Sidevalue = Polygon.Normal * Point
2 if (Sidevalue == Polygon.Distance)
3 then return COINCIDING
4 else if (Sidevalue < Polygon.Distance)
5 then return BEHIND
6 else return INFRONT
l 函数 POLYGON-INFRONT
l 参数:
l Polygon1 – 用来��定其它多边形是否在�?#8220;前面”的多边�Ş�?br>l Polygon2 – ��是否在�W�一个多边�Ş“前面”的多边�Ş�?br>l �q�回�?
l �W�二个多边�Ş是否在第一个多边�Ş�?#8220;前面”�?br>l 功能:
l ��第二个多边形的每一个顶�Ҏ��否在�W�一个多边�Ş�?#8220;前面”�?br>POLYGON-INFRONT (Polygon1, Polygon2)
1 for each point p in Polygon2
2 if (CLASSIFY-POINT (Polygon1, p) <> INFRONT)
3 then return false
4 return true
l 函数 IS-CONVEX-SET
l 参数:
l PolygonSet – 用来��是否�ؓ“凸多边�Ş”的图元集合�?br>l �q�回�?
l 集合是否�?#8220;凸多边�Ş”�?br>l 功能:
l 相对于集合中的其它多边�Ş��查每一个多边�Ş�Q�看是否位于其它多边形的“前面”�Q�如果有��L��两个多边形不满��q�个规则�Q�那么这个集合不�?#8220;凸多边�Ş”�?br>IS-CONVEX-SET (PolygonSet)
1 for i = 0 to PolygonSet.Length ()
2 for j = 0 to PolygonSet.Length ()
3 if(i != j && not POLYGON-INFRONT(PolygonSet, PolygonSet[j]))
4 then return false
5 return true

在函数POLYGON-INFRONT中�ƈ没有�q�行对称的比较，�q�意味着如果多边形A位于多边形B�?#8220;前面”你�ƈ不能惛_��然的认�ؓ多边形B一定位于多边�ŞB�?#8220;前面”。下面的例子��单的昄��了这一炏V�?br>
                �?.3
在图1.3中我们可以看到多边�Ş1位于多边�?�?#8220;前面”�Q�这是因为顶点p3、p4位于多边�?�?#8220;前面”�Q�而多边�Ş2却没有位于多边�Ş1�?#8220;前面”�Q�因为顶点p2位于多边�?�?#8220;后面”�?br>对于一个BSP层次树来说可以用下面�l�构来定义：
class BSPTree
{
BSPTreeNode RootNode // 树的根节�?br>}
class BSPTreeNode
{
BSPTree Tree // 接点所属的层次�?br>BSPTreePolygon Divider // 位于两个子树之间的多边�Ş
BSPTreeNode *RightChild // 节点的右子树
BSPTreeNode *LeftChild // 节点的左子树
BSPTreePolygon PolygonSet[] // 节点中的多边形集�?br>}
class BSPTreePolygon
{
3DVector Point1 // 多边形的��点1
3DVector Point3 // 多边形的��点2
3DVector Point3 // 多边形的��点3
}
现在你可以看见每一个多边�Ş�?个顶�Ҏ��定义�Q�这是因为硬件加速卡使用三角形来对多边�Ş�q�行渲染。将多边形集合分割�ؓ更小的子集合有很多方法，例如你可以�Q意选择�I�间中的一个面然后用它来对�I�间中的多边形进行分�Ԍ��把位于分割面正面的多边�Ş保存到右子树中而位于反面的多边形保存到左子树中。��用这个方法的�~�点非常明显�Q�那��是如果想选择一个将�I�间中的多边形分割�ؓ两个相等的子集合的面非常困难�Q�这是因为在场景中有无数个可选择的面。如何在集合中选择一个最佳的分割面呢�Q�下面我��对�q�个问题�l�出一个比较适当的解��x��案�?br>我们现在已经有了一个函数POLYGON-INFRONT�Q�它的功能是��定一个多边�Ş是否位于其它多边形的正面。现在我们要做的是修改这个函敎ͼ�使它也能够确定一个多边�Ş是否横跨�q�其它多边�Ş定义的分割面。算法如下：
l 函数 CALCULATE-SIDE
l 参数 :
l Polygon1 – ��定其它多边形相对位�|�的多边形�?br>l Polygon2 – ��定相对位置的多边�Ş�?br>l �q�回�?
l 多边�?位于多边�?的哪一�?br>l 功能:
l 通过�W�一个多边�Ş对第二个多边形上的每一个顶点进行检��。如果所有的��点位于�W�二个多边�Ş的正面，那么多边�?被认��Z��于多边�Ş1�?#8220;前面”。如果第二个多边形的所有顶炚w��位于�W�一个多边�Ş的反面，那么多边�?被认��Z��于多边�Ş1�?#8220;后面”。如果第二个多边形的所有顶点位于第一个多边�Ş之上�Q�那么多边�Ş2被认��Z��于多边�Ş1的内部。最后一�U�可能是所有的��点即位于正面有位于反面�Q�那么多边�Ş2被认为横跨过多边�?�?br>CALCULATE-SIDE (Polygon1, Polygon2)
1 NumPositive = 0, NumNegative = 0
2 for each point p in Polygon2
3 if (CLASSIFY-POINT (Polygon1, p) = INFRONT)
4 then NumPositive = NumPositive + 1
5 if (CLASSIFY-POINT (Polygon1, p) = BEHIND)
6 then NumNegative = NumNegative + 1
7 if (NumPositive > 0 && NumNegative = 0)
8 then return INFRONT
9 else if(NumPositive = 0 && NumNegative > 0)
10 then return BEHIND
11 else if(NumPositive = 0 && NumNegative = 0)
12 then return COINCIDING
13 else return SPANNING
上面的算法也�l�我们解�{�了一个问题，当一个多边�Ş横跨�q�分割面时如何进行处理，上面的算法中��多边�Ş分割��Z��个多边�Ş�Q�这样就解决了画家算法中的两个问题：循环覆盖和多边�Ş�怺�。下面的囑�Ş昄��了多边�Ş如何�q�行分割的�?br>

�?.4
如图1.4所�C�，多边�?为分割面�Q�而多边�Ş2横跨�q�多边�Ş1�Q�如囑֏��Ҏ��C�，多边形被分割�?�?两部分，多边�?位于分割面的“前面”而多边�Ş3位于分割面的“后面”�?br>当徏立一个BSP树时�Q�首先需要确定的问题是如何保证二叉树的��^衡，�q�意味着对于每一个叶节点的分割深度而言不能有太大的差异�Q�同时每一个节点的左、右子树需要限制分割的�ơ数。这是因为每一�ơ的分割都会产生新的多边形，如果在徏立BSP树时产生太多的多边�Ş的话�Q�在囑�Ş加速卡对场景渲染时会加重渲染器的负担，从而降低��速。同时一个不�q��的二叉树在进行遍历时会耗费许多无谓的时间。因此我们需要确定一个合理的分割�ơ数以便于获得一个较为��^衡的二叉树，同时可以减少新多边�Ş的��生。下面的代码昄��了如何通过循环多边形集合来获得最佳的分割多边形�?br>l 函数 CHOOSE-DIVIDING-POLYGON
l 参数:
l PolygonSet – 用于查找最佛_��割面的多边�Ş集合�?br>l �q�回�?
l 最佳的分割多边形�?br>l 功能:
l �Ҏ��定的多边形集合进行搜索，�q�回��其分割为最佛_��集合的多边�Ş。如果指定的集合是一�?#8220;凸多边�Ş”则返回�?br>CHOOSE-DIVIDING-POLYGON (PolygonSet)
1 if (IS-CONVEX-SET (PolygonSet))
2 then return NOPOLYGON
3 MinRelation = MINIMUMRELATION
4 BestPolygon = NOPOLYGON
5 LeastSplits = INFINITY
6 BestRelation = 0
l 循环查找集合的最佛_��割面�?br>7 while(BestPolygon = NOPOLYGON)
8 for each 多边形P1 in PolygonSet
9 if (多边形P1在二叉树建立�q�程中没有作为分割面)
l 计算被当前多边�Ş定义的分割面的正面、反面和横跨�q�分割面的多边�Ş的数量�?br>10 NumPositive = 0, NumNegative = 0, NumSpanning = 0
11 for each 多边形P2 in PolygonSet except P1
12 value = CALCULATE-SIDE(P1, P2)
13 if(value = INFRONT)
14 NumPositive = NumPositive + 1
15 else if(value = BEHIND)
16 NumNegative = NumNegative + 1
17 else if(value = SPANNING)
18 NumSpanning = NumSpanning + 1
l 计算被当前多边�Ş分割的两个子集合的多边�Ş数量的比倹{�?br>19 if (NumPositive < NumNegative)
20 Relation = NumPositive / NumNegative
21 else
22 Relation = NumNegative / NumPositive
l 比较由当前多边�Ş获得的结果。如果当前多边�Ş分割了较��的多边形同时分割后的子集合比值可以接受的话，那么保存当前的多边�Ş为新的候选分割面�?br>l 如果当前多边形和最佛_��割面一样分割了相同数量的多边�Ş而分割后的子集合比值更大的话，��当前多边�Ş作�ؓ新的候选分割面�?br>23 if (Relation > MinRelation &&
(NumSpanning < LeastSplits ||
(NumSpanning = LeastSplits &&
Relation > BestRelation))
24 BestPolygon = P1
25 LeastSplits = NumSpanning
26 BestRelation = Relation
l 通过除以一个预先定义的帔R��来减��可接受的最��比倹{�?br>27 MinRelation = MinRelation / MINRELATIONSCALE
28 return BestPolygon
��法分析
对于上面的函数来��_��Ҏ��场景数据大小的不同它可能��p��很长一�D�|��间。常量MINRELATIONSCALE用来��定在每�ơ��@环时所分割的子集合多边形数量的比值每�ơ减��多��，��Z��么要使用�q�个帔R��呢，考虑一下，对于�l�定的MinRelation如果我们找不到最佳的分割面，通过除以�q�个帔R��比值减��来重新�q�行循环查找�Q�这样可以防止死循环的出玎ͼ�因此当这个比��D��够小时我们必定可以获得可接受的最佳结果。最坏的事情是我们有一个包含N个多边�Ş的非“�?#8221;集合�Q�分割多边�Ş��集合分割�ؓ一个包含N-1个多边�Ş的部分和一个包�?个多边�Ş的部分。这个结果只有在最��比值小�?/(n-1)才是可以接受的（参考算法的19-23行）。这意味着MinRelation /MINRELATIONSCALEi < 1/(n-1)�Q�这里i是��@环重复的�ơ数。让我们假设MinRelation的初始化��gؓ1�Q�由于比值永�q��ؓ0-1之间的值因此这是最可能的��|��参考算法的19-22行）。我们有
1 / MINRELATIONSCALEi < 1/(n-1)
1 < MINRELATIONSCALEi/(n-1)
(n-1) < MINRELATIONSCALEi
logMINRELATIONSCALE (n-1) < i
�q�里的i没有上边界，但是因�ؓi非常接近于logMINRELATIONSCALE (n-1)�Q�我们可以简单的假设两者是相等的。另外我们也假设MINRELATIONSCALE永远大于或等�?�Q�因此我们可以有
logMINRELATIONSCALE (n-1) = i
MINRELATIONSCALE >= 2
i = logMINRELATIONSCALE (n-1) < lg(n-1) = O(lg n)
在��@环的内部�Q�对多边形的集合需要重复进行两�ơ��@环，因此�Ҏ��们来说最坏的情况下这个算法的复杂度�ؓO(n2lg n)�Q�而通常情况下这个算法的复杂度接�q�于O(n2)�?br>在函数CHOOSE-DIVIDING-POLYGON的��@环中看�v来如果不发生什么事情的话好象永�q�不会停止，但是�q�不会发生，�q�是因�ؓ如果多边形集合�ؓ�?#8220;�?#8221;集合的话总能扑ֈ�一个多边�Ş来把集合分割��Z��个子集合。CHOOSE-DIVIDING-POLYGON函数��L��选择分割集合的多边�Ş数量最��的多边形，��Z��防止选择�q�不分割集合的多边�Ş�Q�分割后的子集合的多边�Ş数量之比必须大于预先定义的倹{��ؓ了更好的理解我上面所讲解的内容，下面我将举一个例子来说明如何选择一个多边�Ş对一个很��数量多边�Ş的集合进行分剌Ӏ?/p>

�?.5
在上面的例子中无��Z��选择多边�?�?�?�q�是多边�?�q�行渲染旉��不会分割��M��其它的多边�Ş�Q�换句话说也��是所有的其它多边形都位于�q�些多边形的“正面”�?br>关于分割旉��择产生多边形最��的分割面另外一个不太好的原因是大多数时候它所产生的层�ơ树通常是不�q��的，而一个��^衡的层次树在�q�行的时候通常比不�q��的层�ơ树性能更好�?br>当获得最佳的分割面后伴随着必然产生一些被分割的多边�Ş�Q�如何对被分割的多边形进行处理呢�Q�这里有两个�Ҏ��Q?br>1. 建立一个带叶节点的二叉树，�q�意味着每一个多边�Ş��被攑֜�叶节点中�Q�因此每一个被分割的多边�Ş也将被分开攑֜�二叉树的一辏V�?br>2. 另外一个方法是��被分割的多边�Ş保存到公��p��点中�Q�对每一个子树重复这个过�E�直到每一个叶节点都包含了一�?#8220;�?#8221;多边形集合�ؓ止�?br>产生带叶节点的BSP树的��法如下�Q?br>l 函数GENERATE-BSP-TREE
l 参数:
l Node – �Ʋ徏立的�c�d��为BSPTreeNode的子树�?br>l PolygonSet – 建立BSP-tree的多边�Ş集合�?br>l �q�回�?
l 保存到输入的父节点中的BSP-tree�?br>l 功能:
l 对一个多边�Ş集合产生一个BSP-tree�?br>GENERATE-BSP-TREE (Node, PolygonSet)
1 if (IS-CONVEX-SET (PolygonSet))
2 Tree = BSPTreeNode (PolygonSet)
3 Divider = CHOOSE-DIVIDING-POLYGON (PolygonSet)
4 PositiveSet = {}
5 NegativeSet = {}
6 for each polygon P1 in PolygonSet
7 value = CALCULATE-SIDE (Divider, P1)
8 if(value = INFRONT)
9 PositiveSet = PositiveSet U P1
10 else if (value = BEHIND)
11 NegativeSet = NegativeSet U P1
12 else if (value = SPANNING)
13 Split_Polygon10 (P1, Divider, Front, Back)
14 PositiveSet = PositiveSet U Front
15 NegativeSet = NegativeSet U Back
16 GENERATE-BSP-TREE (Tree.RightChild, PositiveSet)
17 GENERATE-BSP-TREE (Tree.LeftChild, NegativeSet)
��法分析
函数CHOOSE-DIVIDING-POLYGON的时间复杂度为O(n2 lg n)�Q�除非出现递归调用否则它将控制其它的函敎ͼ�如果我们假设对多边�Ş集合的分割是比较公��^的话�Q�那么我们可以通过公式来对函数GENERATE-BSP-TREE的复杂度�q�行表达�Q?br>T(n) = 2T(n/2) + O(n2 lg n)
通过公式我们可以知道�q�个函数的复杂度为Q (n2 lg n)。这里n��入的多边形集合的多边形数量�?br>下面我要用一个例子来演示如何产生一个BSP-tree。下面的�l�构是一个多边�Ş的原始集合，��Z��表示方便�Ҏ��一个多边�Ş都进行了�~�号�Q�这个多边�Ş集合��被分割��Z��个BSP-tree�?/p>

�?.6
��Z��能够�q�行�q�个��法我们必须对常量MINIMUMRELATION和MINRELATIONSCALE�q�行赋��|��在实际运行中我们发现当MINIMUMRELATION=0.8而MINRELATIONSCALE=2时可以获得比较好的结果。但是你也可以对�q�些数��D��行试验来比较一下，通常当常数MINIMUMRELATION比较大时获得的层�ơ树会比较��^衡但同时分割产生的多边�Ş也会大量增加。在上图昄��的多边�Ş集合�q�不是一�?#8220;�?#8221;的，因此首先我们需要选择一个合适的分割面。在快速的对上面的�l�构�q�行一下浏览后我们可以知道多边形（1�?�?�?2�?8�Q�不能被用来作�ؓ分割面，�q�是因�ؓ它们定义了包含所有多边�Ş集合的外形。但是其它的多边形都可以作�ؓ候选的分割面。分割��生的多边形最��同时分割�ؓ两个子集合的多边形数目之比�ؓ最佳的多边形是16�?7�Q�它们位于同一条直�U�上同时�q�不会分割�Q何的多边形。而分割后的子集合的多边�Ş数目也是一��L��Q�都�?#8220;正面”�?3�?#8220;反面”�?5。让我们选择多边�?6作�ؓ分割面，那么分割后的的结构如下：

�?.7
现在从图1.7我们可以看到无论是左子树�q�是叛_��树都没有包含“�?#8221;多边形集合，因此需要对两个子树�l�箋�q�行分割�?br>在左子树中多边�Ş1�?�?�?作�ؓ多边形集合的“凸边”不能用做分割面，而多边�Ş4�?0在同一条直�U�上同时没有分割��M��多边形，而分割后的多边�Ş子集合：“正面”�?�?#8220;反面”�?非常的��^衡，我们选择多边�?为分割面�?br>在右子树中多边�Ş16�?7�?2�?3�?8不能作�ؓ分割面，而多边�Ş18�?9�?6�?7虽然没有分割��M��多边形但是分割后的多边�Ş子集合：“正面”�?1�?#8220;反面”�?�Q?/11�q�个比值小于最��比�?.5因此我们需要寻扑օ�它更适合的多边�Ş。多边�Ş20�?1�?4�?5都只分割了一个多边�Ş�Q�但是多边�Ş21看�v来分割后的结果更合理�Q�在分割�q�多边�Ş22后多边�Ş子集合的�l�果为：“正面”�?�?#8220;反面”�?�?br>下图昄��了操作后的结果：

�?.8
在图中每一个子集合�q�不是一�?#8220;�?#8221;集合�Q�因此需要��l�进行分�Ԍ��按照上面的法则对�?.8所�C�的�l�构�q�行分割后，�l�果如下�Q?br>

�?.9
上图昄��了最后的�l�果�Q�这可能不是最优的�l�果但是我们对它�q�行处理所��p��的时间�ƈ不太�ѝ�?br>渲染BSP
现在我们已经建立好一个BSP树了�Q�可以很�Ҏ��Ҏ��中的多边形进行正��的渲染�Q�而不会��生�Q何错误。下面的��法描述了如何对它进行渲染，�q�里我们假设函数IS-LEAF的功能�ؓ�l�定一个BSP节点如果为叶节点�q�回真否则返回假�?br>函数DRAW-BSP-TREE
参数:
l Node – 被渲染的节点�?br>l Position – 摄象机的位置�?br>l �q�回�?
l None
l 功能:
l 渲染包含在节点及其子树中的多边�Ş�?br>DRAW-BSP-TREE (Node, Position)
1 if (IS-LEAF(Node))
2 DRAW-POLYGONS (Node.PolygonSet)
3 return

l 计算摄象机包含在哪一个子树中�?br>4 Side = CLASSIFY-POINT (Node.Divider, Position)
l 如果摄象机包含在叛_��树中先渲染右子树再渲染左子树�?br>5 if (Side = INFRONT || Side = COINCIDING)
6 DRAW-BSP-TREE (Node.RightChild, Position)
7 DRAW-BSP-TREE (Node.LeftChild, Position)

l 否则先渲染左子树�?br>8 else if(value = BEHIND)
9 DRAW-BSP-TREE (Node.LeftChild, Position)
10 DRAW-BSP-TREE (Node.RightChild, Position)
用这个方法进行渲染�ƈ没有减少渲染到屏�q�上的多边�Ş数量�Q�由于一个场景可能包含成百上千个多边形因此这个方法�ƈ不是很好的解��x��案。通常情况下有大量的节点和多边形�ƈ没有处于摄象机的视野范围之内�Q�它们�ƈ不需要被渲染到屏�q�上�Q�如何查找这些不可见的节点和多边形防止它们渲染到屏幕上呢�Q�隐藏面剔除��是��Z��解决�q�个问题而提��Z��Ҏ��术，在下一节中我们��对�q�项技术进行详�l�的阐述�?br>BSP技术详�?

eXtreme3D

�W�二�?隐藏面剔�?br>    对不可见物体�q�行剔除是游戏行业�ؓ了满��x��高画面渲染速度的要求而��生的一��Ҏ��术，��是在硬件加速技术飞跃发展的今天�Q�虽然现在已�l�可以完成许多在�q�去被认为是不可能实现的工作�Q�但是对于隐藏面�q�行剔除仍是加速图形渲染的一��w��要技术。通常当一个游戏运行的时候，它最��需要以每秒30帧的速度�q�行。在几年前这意味着如果每一帧你渲染的带�U�理的多边�Ş数量��过5000个就被认为是不可接受的，而现在几乎所有的商业昑֍�每一�U�都可以渲染几千万个多边形。可是现在仍焉��要��用隐藏面剔除�q�项技术，�q�是��Z��么呢�Q�显而易见，对不可见物体渲染以后��会被可见物体遮挡住�Q�这样做无谓的浪费了昑֍�的带宽，但是同时它也增加了场景的�l�节�Q��游戏画面看�v来更加吸引�h。现在的问题是多大程度上来剔除隐藏的多边形，象view frustum culling和portal渲染�q�样的技术来剔除一个不可见多边形是非常耗费旉��的，用来��d��q�些计算的CPU旉��可以用来完成其它诸如AI或碰撞检��这��L��工作�Q�因此开发一个隐藏面剔除��法必须注意到这一炏V��对于现在的游戏来说几乎没有一个是��每一个隐藏的多边形都�q�行剔除�Q�而是剔除一个多边�Ş的集合如一个节�Ҏ��一个物体等�{�。对于一个单独的多边形它�q�不�q�行剔除�Q�因此一个正��的隐藏面剔除方案是允许一定的重复渲染来适当的减��计��量�?br>    当徏立一个FPS游戏时进行隐藏面剔除最通常的方法是使用portal渲染。这��Ҏ��术可以非常充分的利用BSP的优点，但是��h��意portal技术�ƈ不仅仅只能用于BSP中。Portal技术还可以用来产生一些特效如镜子和监视器�{�等�?br>Portal渲染
在这里我��介�l�一下portal技术的原理�Q�通常对于一个室内场景来说它可以被描�q�Cؓ�׃��个个“�z�口”�怺��q�接�?#8220;戉K��”�l�成�Q�这�?#8220;�z�口”被称为portal�?#8220;戉K��”被称为sector�Q�通常sector被定义�ؓ一�?#8220;�?#8221;�?#8220;闭合”的多边�Ş集合�Q�定义中�?#8220;�?#8221;阅读�q�前面的内容你应当已�l�能很好的理解了�Q��?#8220;闭合”是什么意思呢�Q�它意味着在sector内部��L��q�接两个��点做一条线�D�，�q�条�U�段不会和其它的多边形相交。换句话说如果你惛_��sector内部��L��M��条线�D�通到sector的外部必定与�l�成sector的多边�Ş�怺�。这也意味着�q�接每一个sector�?#8220;�z�口”必须被一个组成portal的多边�Ş所填充�Q�而对于放�|�portal多边形来说你既可以手工放�|�也可以��q��序自动��生，在我讲解�q�项技术之前我必须提醒一下，�׃��g加速Z�~�冲的出现对sector必须�?#8220;�?#8221;的限制已�l�消除，因此有许多游戏引擎已�l�不再遵守这个标准，但是在这里我�q�是要对�q�去的方法进行一下介�l��?br>一个portal引擎的基本方法是当你通过一个指定观察位�|�的可视�q�x��体（view frustum�Q�进行渲染时�Q�如果一个portal出现在可视范围内�Q�那么portal��对可视�q�x��体进行剪切，�q�样与其相连的sector��会通过一个观察位�|�相同但已经改变�q�的可视�q�x��体进行渲染。这是一个非常简单而且非常适合�q�行递归调用的方法，�׃��可视�q�x��体被portal�q�行了精��的限制�Q�因此被隐藏的物体可以很��单进行剔除。下面的例图昄��了一个portal引擎中的可视�q�x��体是如何被剪切的�?br>
�?.10
在图6.10中观察者的位置位于V�Q�而初始的可视�q�x��体�ؓF1�Q�当它通过一个portal多边形P1后被P1剪切产生新的可视�q�x��体F2�Q�接着当它通过portal多边形P2、P3后F2被剪切�ؓF3、F4�Q�而F3通过P4后被剪切为F5而F4被剪切�ؓF6。观察这个过�E�我们可以发现portal技术非帔R��合�q�行递归调用�?br>接着需要考虑的是如何对物体进行拣选剔除，通常对于所有的3D引擎来说都需要通过一�p�d��步骤来加速这个处理过�E�，回忆一下前面讲解的内容�Q�这个过�E�首先要计算出物体的“最大包围球”或是“最大包围盒”�Q�它是包含了物体所有顶点的最��包围体�Q�接着用包围体来和“可视�q�x��?#8221;每一个剪切面�q�行��撞��，如果包围体位于每一个剪切面�?#8220;反面”那么物体��不会进行渲染，下图昄��了这个过�E�：

�?.11
图中物体1位于叛_��切面�?#8220;正面”但位于左剪切面的“反面”因此它将不会被渲染，而物�?不仅位于左剪切面�?#8220;正面”而且有一部分位于叛_��切面�?#8220;正面”因此��会被渲染出来�?br>Portal技术最初的��x��是通过剪切多边形来保证只有物体可见的部分被渲染出来�Q�也��是无效渲染的多边�Ş数量�?。但是现在这�U�想法被认�ؓ不是很理惻I��因�ؓ它无谓的��费了处理时间。但是由于一个多边�Ş在递归循环�q�程中将被遍历多�ơ因此我们需要知道在渲染场景时它是否已经被渲染过�Q�一个较好的�Ҏ��是��用一个��数来标识�q�个多边形，�q�样可以很容易的来描�q�这个多边�Ş在上一帧是否被渲染�q�。再看一下图6.10中最双��的墙�Q�它同时通过F5和F6来进行渲染，通过对它�q�行标识我们可以知道它是否被渲染�q�，否则��׃��产生Z�~�冲错误�?br>��Z��便于在portal引擎中进行渲染我们需要对“可视�q�x��?#8221;�q�行一下定义，一�?#8220;可视�q�x��?#8221;是一个保存了多个剪切面的�l�构�Q�每一个剪切面的法�U�K��指�?#8220;可视�q�x��?#8221;的内部，因此在它内部��生一个闭合的锥体。下面的��法昄��了如何计��一个多边�Ş是否包含�?#8220;可视�q�x��?#8221;的内部。在�q�个��法中我们��用了一个函数CLASSIFY-POINT�Q�它使用一个剪切面和一个点作�ؓ输入参数�?br>l 函数INSIDE-FRUSTUM
l 参数:
l Frustum – 用于��多边�Ş是否位于其中�?#8220;可视�q�x��?#8221;�?br>l Polygon – 用于��的多边形�?br>l �q�回�?
l 多边形是否位�?#8220;可视�q�x��?#8221;的内部�?br>l 功能:
l 使用“可视�q�x��?#8221;的每一个剪切面来对多边形的每一个顶点进行检��，如果所有的��点都位于所有剪切面�?#8220;正面”�Q�那么多边�Ş处于“可视�q�x��?#8221;的内部�?

INSIDE-FRUSTUM (Frustum, Polygon)
1 for each point Pt in Polygon
2 Inside = true
3 for each plane Pl in Frustum
4 if (CLASSIFY-POINT (Pl, Pt) <> INFRONT)
5 Inside f false
6 if (Inside)
7 return true
8 return false
在一个portal引擎中它的主渲染函数可以��单的用下面的�Ҏ��来实现�?br>函数RENDER-PORTAL-ENGINE
参数:
Sector – 观察者所处的sector�?br>ViewFrustum – 当前�?#8220;可视�q�x��?#8221;�?br>�q�回�?
None
功能:
渲染portal引擎中的多边形，场景被描�q�Cؓ由多个portal�q�接的sectors所�l�成�?br>RENDER-PORTAL-ENGINE (Sector, ViewFrustum)
1 for each polygon P1 in Sector
2 if (P1是一个portal and INSIDE-FRUSTUM (ViewFrustum, P1))
3 NewFrustum = CLIP-FRUSTUM (ViewFrustum, P1)
4 NewSector = 获得由当前sector通过portal P1相连接的sector
5 RENDER-PORTAL-ENGINE (NewSector, NewFrustum)
6 else if (P1�ȝ��没有被渲�?
7 draw P1
8 return
如何攄��portal
正如我前面提到的在一个portal引擎中最大的问题��是如何攄��portal�Q�如果手工来攄��它的话非常花�Ҏ��_��同时要求地图的设计者有熟练的技巧。因此一个良好的自动攄��portal的算法非常有必要�Q�在�q�里我将要介�l�一下关于这斚w��的几个解��x��案，�q�些�Ҏ��都��用了BSP�?br>我介�l�的�W�一个解��x��案是��q��典DICE公司的Andreas Brinck提出的，它的原理非常��单，观察一下一个完整的BSP层次树，可以发现�q�样一个现象，对于每一个portal来说它必定与BSP层次树中由分割多边�Ş定义的分割面位置相同�Q�因此在相同的位�|�上我们可以在分割面之外建立一个portal多边形，portal多边形被初始化�ؓ一个矩形，�q�个矩�Ş的大��将��过portal所处的BSP节点�?#8220;最大包围盒”的大��，接着��portal多边形放入包含它的节�Ҏ��位于的子树中�Q�当节点不是叶节�Ҏ��Q�那么portal��l�被传送到节点的子树中�Q�这样子节点中的分割面将对它�q�行分割�Q�而当包含它的节点为叶节点�Ӟ��它也会被节点中的多边形进行剪切，因�ؓportal初始化的大小��过了节点的范围。当portal被分割后�Q�被分割的两个部分会�l�箋传送到最��层的节炚w��复这个过�E�，而当portal不需要进行分割时�Q�根据它所处于分割面的位置来放�|�到相应的子节点中，如果位于分割面的“正面”它将被放�|�在叛_��树中�Q�而当它位于分割面�?#8220;反面”��被攄��于左子树中。如果portal正好位于分割面之上它��同时放在左叛_��树中�?br>��Z��方便方便��所有的portal攄��到BSP中我们需要定义如何对一个多边�Ş�q�行分割�Q��ؓ了方便��用我们假讑֮�成这个功能的函数为INTERSECTION-POINT�Q�它��返回一个面与一个线�D늚�交点�?br>l 函数CLIP-POLYGON
l 参数:
l Clipper – ��d��割其它多边�Ş的多边�Ş或面�?br>l Polygon – 被分割的多边形�?br>l �q�回�?
l 被分割后的两个部分�?br>l 功能:
l 由指定的分割面来分割多边形。如果多边�Ş没有被分割将会返回一个空的多边�Ş�?br>CLIP-POLYGON (Clipper, Polygon)
1 RightPart = {}
2 LeftPart = {}
3 for each point edge E in Polygon
4 Side1 = CLASSIFY-POINT (Clipper, E.Point1)
5 Side2 = CLASSIFY-POINT (Clipper, E.Point2)
6 if (Side1 <> Side2 and
Side1 <> COINCIDING and
Side2 <> COINCIDING)
7 Ip = INTERSECTION-POINT (Clipper, E)
8 if (Side1 = INFRONT)
9 RightPart = RightPart U E.Point1
10 RightPart = RightPart U Ip
11 LeftPart = LeftPart U Ip
12 LeftPart = LeftPart U E.Point2
13 if (Side1 = BEHIND)
14 LeftPart = LeftPart U E.Point1
15 LeftPart = LeftPart U Ip
16 RightPart = RightPart U Ip
17 RightPart = RightPart U E.Point2
18 else
19 if (Side1 = INFRONT or Side2 = INFRONT or
Side1 = COINCIDING and Side2 = COINCIDING)
20 RightPart = RightPart U E.Point1
21 RightPart = RightPart U E.Point2
22 if (Side1 = BEHIND or Side2 = BEHIND)
23 LeftPart = LeftPart U E.Point1
24 LeftPart = LeftPart U E.Point2
25 return (RightPart, LeftPart)
现在我们可以定义如何在一个BSP层次树中对portal�q�行分配了，在算法中portal被初始化��Z��个大于BSP根节�?#8220;最大包围盒”的多边�Ş�?br>l 函数PLACE-PORTALS
l 参数:
l PortalPolygon – 攄��到BSP中的多边形�?br>l Node – 我们当前遍历的节炏V�?br>l �q�回�?
l None
l 功能:
l 攄��一个portal多边形到BSP层次树中�Q�如果需要的话对它进行剪切。这个函数将会��生一个节点将由portal�q�接而每一个节点将包含一个portal多边形列表的BSP层次树�?br>PLACE-PORTALS (PortalPolygon, Node)
1 if (IS-LEAF (Node))

l ��portal和节点中的每一个多边�Ş�q�行��。当portal所包含的多边�Ş和由一个多边�Ş定义的面�怺�时它��被�q�个面进行分�Ԍ��分割后的两个部分��被重新传送到最��层的节点中�l�箋�q�行��?br>2 for (each polygon P2 in Node)
3 IsClipped = false
4 if (CALCULATE-SIDE (P2, PortalPolygon) = SPANNING)
5 IsClipped = true
6 (RightPart, LeftPart) = CLIP-POLYGON (P2, PortalPolygon)
7 PLACE-PORTALS (RightPart, RootNode)
8 PLACE-PORTALS (LeftPart, RootNode)
9 if (not IsClipped)
10 从当前节点中��portal的多边�Ş剔除�Q�因为它的位�|�和节点中一个多边�Ş的位�|�相同�?br>l 参考下面的描述�?br>11 ��d��当前节点到portal多边形所�q�接的节炚w��合中�?br>12 else
13 if (当前节点的分割多边�Ş没有攄��在树�?
14 建立一个多边�ŞP�Q�它的大��将��过包含当前节点所有多边�Ş的最大包围盒的范��_��q�且和分割多边�Ş的位�|�相同�?br>15 PLACE-PORTALS (P, Node.LeftChild)
16 PLACE-PORTALS (P, Node.RightChild)
17 Side = CALCULATE-SIDE (Node.Divider, PortalPolygon)
18 if (Side = POSITIVE)
19 (RightPart, LeftPart) = CLIP-POLYGON(P2, PortalPolygon)
20 PLACE-PORTALS (RightPart, RootNode)
21 PLACE-PORTALS (LeftPart, RootNode)
22 if (Side = POSITIVE or COINCIDING)
23 PLACE-PORTALS (PortalPolygon, Node.RightChild)
24 if (Side = NEGATIVE or COINCIDING)
25 PLACE-PORTALS (PortalPolygon, Node.LeftChild)
下面我将对算法中的第10行进行一下解释，当剔除和当前节点中一个多边�Ş位置相同的portal多边形部分将会��生什么样的结果。参考一下图6.12�?/p>

�?.12
在图6.12中一个portal已经到达了一个叶节点�Q�图中灰色的区域是是portal多边形在遍历BSP树过�E�中被剔除的区域�U�它�?。而图中标注�ؓ2�?�?的亮灰色部分是和portal多边形位�|�相重叠的多边�Ş�Q�因此这一部分的portal多边形也��会被剔除，而剩下的部分5��被用来做�ؓ一个portal�?br>在上面的��法�W�一�ơ看的话会觉的非常复杂，但实际上它非常简单和�Ҏ��理解�Q�最�l�的�l�果��是每一个portal��会在两个节点上�l�束而对于�Q一个portal来说它必定可以和一个portal之间�怺�可见。在下面我将用一个实际的例子来解释一下这个算法�?/p>

�?.13
对于�?.13中的�l�构�Q�需要进行下面的几步�Q?br>�W�一步，portal多边形s1�q�入节点n1中�?/p>

在节点n1中portal多边形s1��会被分�Ԍ��因�ؓ它的一部分和节点中间的一个多边�Ş位置相同�Q�因此portal多边形s1��会被分割�ؓ两部分分别�ؓp1、p2�Q�重叠的部分被剔除�?br>�W�二步，p1、p2�q�入节点s2中�?br>在节点s2中由于p1位于分割面s2�?#8220;正面”�Q�因此将和分割面s2一赯��送入到节点n2中，而p2�׃��位于分割面s2�?#8220;反面”�Q�因此将和分割面s2一赯��送入到节点s3中。由于p1、p2没有和分割面�怺�因此�q�一步没有出现分割操作�?br>�W�三步，p1、s2�q�入节点n2中�?/p>

在节点n2中n2被认可作��Z��个portal�Q�因此在节点n1和n2中它不会再发生�Q何变化。而多边�Şp3的一部分��会被剔除，因�ؓ它的一部分和节点中间的一个多边�Ş位置相同�Q�在上一步中多边形s2也被送入到节点s3中，而在�q�里它又被称为p3�?/p>

�W�四步，p3和s3�q�入节点n3中�?/p>

在节点n3中多边�Şp3被认可�ؓ一个portal�Q�而多边�Şs3的一部分因�ؓ和上面的原因一栯��剔除�Q�同时在�q�里它又被称为p4�?/p>

�W�五步，p2和p4�q�入节点s4中�?br>没有��M��多边形要�q�行分割�Q�因此多边�Şp2和p4��与s4一赯��送入节点n4中，而s4��被单独送入节点n5中�?br>�W�六步，p2、p4和s4一赯��入节点n4中�?/p>

无论是p2�q�是p4都不需要分�Ԍ��但是�׃��s4和中间的一个多边�Ş完全重叠因此��会被剔除�?/p>

�W�七步，�l�束�Q�没有�Q何多边�Ş�q�入节点n5中�?br>�q�个节点��没有portal�Q�因为对于�Q何节�Ҏ��说它都是不可见的�Q�而从�q�个节点位置上将不会看见��M��一个节炏V�?br>�l�果�Q?br>portal p1同时位于节点n1和n2中；
portal p2同时位于节点n1和n4中；
portal p1同时位于节点n2和n3中；
portal p1同时位于节点n3和n4中�?/p>

上面我所讲解的内�Ҏ��建立一个简单的portal引擎所必备的功能，它能�l�我们提供一个较高的�q�行帧速�?br>PVS
一个portal引擎虽然能够提供许多非常好的�Ҏ��，但是它的�l�构太复杂。当你��用portal技术来构徏一个游戏引擎时你会发现它存在许多问题，最大的一个问题是在渲染场景的每一帧都需要进行可视性检��，�q�会产生大量的多边�Ş剪切操作�Q�在场景非常复杂的情况下�Q�运��的费用会非常的高，因此需要寻找一�U�技术来对场景中可视性检��进行预计算而不是在�q�行期间�q�行计算。PVS�Q�Potentially Visible Set�Q�可视性集合，��是��Z��解决�q�个问题而出现的一��Ҏ��术，可以通过对BSP中每一个叶节点讄��一个PVS�Q�这个PVS保存了从�W�一个叶节点开始看到的叶节炚w��合，它不仅可以用来帮助加速场景渲染，�q�可以用来加速场景中光照�q�算和进行网�l�优化�?br>PVS是在场景�q�行预渲染时计算出来的，每一个BSP的叶节点都保存一个可视节点的集合�Q�当对场景进行渲染时�Q�摄象机所在的叶节点将被渲染，同时保持在PVS中的叶节点也��会被渲染出来，�q�里需要一些算法来避免场景重复渲染�Q�由于今天硬件加速卡的发展，它所提供的硬件Z�~�冲的大��已�l�可以方便的解决�q�个问题�?br>计算PVS
如果要求PVS必须在BSP的叶节点之间�q�行标准的光�U�跟�t�计��，来查找一下在一个叶节点中�Q一个点是否在其它叶节点中可见。�ؓ了加速光�U�跟�t�的计算�Q�在每一个叶节点中必��L��Z��些典型的位置�Ҏ��避免无谓的计��，现在的问题就是如何放�|�这些典型的炏V�?br>对于一个portal引擎的portal来说�Q�典型点可以沿着树的分割面放�|�，�q�是因�ؓ只有在两个portal是相互开攄��情况下才可以�q�行可视化检��。如果位于一个叶节点中间的一个点被从另一个叶节点发射出来的光�U�认为是可见的话�Q�那么这条光�U�必焉��过�q�接两个节点的portal�Q�参考下图：

�?.14
在图6.14中我们可以看见如果在一个节点中的一个点可以从其它节点看见，那么视线必然通过两个节点�怺��q�通的区域。这是非常明昄��Q�如果视�U�被物体��L��的话那么两点之间必定不可见。因此将典型�Ҏ��|�在两个节点之间所开攄��区域是非常合适的�Q�下面描�q�的��法��在一个BSP树上攄��典型炏V��对于这个函数需要一�l�帮助函数来把点攄��在一个节点上�Q�它们是
l DISTRIBUTE-POINTS (Node) �q�个函数��按照一定的间隔沿着�l�定节点的分割面来放�|�点�Q�点的位�|�会处于节点包围盒的内部。它��返回一个点的集合，复杂度�ؓO(xy)�Q�这里x��点包围盒内分割面的宽度，而y为高度�?br>l CLEANUP-POINTS (Node, PointSet) 从点的集合中剔除不合格的点，�q�些点可能和节点中的一个多边�Ş位置相同�Q�也可能是位于节点包围盒的外部。函数的复杂度�ؓO(np)�Q�这里n��点中多边形的数量而p为集合中点的数量�?br>l 函数 DISTRIBUTE-SAMPLE-POINTS
l 参数:
l Node – 当前我们遍历的节炏V�?br>l PointSet – 攄��到给定节点子树中的点的集合�?br>l �q�回�?
l None
l 功能�Q?br>l 沿着�l�定节点的分割面攄��炏V��它��按照分割面的位�|�来对输入的点进行检��，如果�q�些点和节点中的一个多边�Ş位置相同�Q�或者位于节点包围盒的外部那么将会被剔除。新产生的点��会被添加到左、右两个集合中，当一个点的集合遍历到一个叶节点旉��么它��是�q�个叶节点的典型炏V�?br>DISTRIBUTE-SAMPLE-POINTS (Node, PointSet)
1 CLEANUP-POINTS (Node, PointSet)
2 if (IS-LEAF (Node))
3 讄��点的集合为当前节点的典型炏V�?br>4 else
5 RightPart = NewPoints
6 NewPoints = DISTRIBUTE-POINTS (Node)
7 RightPart = NewPoints
8 LeftPart = NewPoints
9 for each point P in PointSet
10 Side = CLASSIFY-POINT (Node.Divider, P)
11 if (Side = COINCIDING)
12 RightPart = RightPart U P
13 LeftPart = LeftPart U P
14 if (Side = INFRONT)
15 RightPart = RightPart U P
16 if (Side = BEHIND)
17 LeftPart = LeftPart U P
18 DISTRIBUTE-SAMPLE-POINTS (Node.LeftChild, LeftPart)
19 DISTRIBUTE-SAMPLE-POINTS (Node.RightChild, RightPart)
��法分析
每一�ơ调用这个函数的复杂度�ؓO(np + xy)�Q�参考函数CLEANUP-POINTS�?br>DISTRIBUTE-POINTS�Q�，��Z��计算完整的复杂度我们可以用下面的公式来表�C�（我们假设典型点的集合同时分布在两个集合之中）�Q?br>T(n) = 2T(n/2) + O(np + xy)
�q�个函数�W�一�ơ调用时��会从BSP树的根节点开始�ƈ会传入一个空的集合。换句话说它是按照下面的�Ҏ��q�行的，它是从被BSP树根节点所定义的分割面上的点开始的�Q�由于一个面的大��没有限制因此也会有无限个典型点�Q�因此就需要对典型点进行限�Ӟ��q�个现在��是根节点的包围盒�?br>在根节点上获得合格的典型点后需要把所有的点发送到根节点的两个子树中，当一个典型点的集合进入一个节点后会被分割��Z��个部分，一个部分包含了所有位于节点分割面�?#8220;正面”的点�Q�而另一部分包含了所有位于节点分割面�?#8220;反面”的点。而位于分割面上的点将会同时放在两个集合中。接着“正面”集合��会被传入到叛_��树中�?#8220;反面”集合��会被传入到左子树中。重复这个过�E�直到进行到叶节�Ҏ��l�束�Q�在�q�些操作后每一个叶节点��包含一个典型点的集合，�q�些炚w��位于节点所�q�通的地方�?br>如果我们现在在这个阶�D�对每一个节点进行光�U�跟�t�那么是非常耗费旉��的，但是如果我们知道叶节�Ҏ��与哪一个节点相�q�的�Q�那么这个过�E�将会变的简单，因�ؓ�q�样可以减少一些不必要的光�U�跟�t�运��。查扄��互连接的叶节炚w��常简单，可以通过��每一个叶节点的典型点来查找，如果同时有两个节点共享一个点那么�q�两个节点必然是�怺��q�通的�Q�因为在遍历BSP树放�|�典型点的过�E�中�Q�点不是没有攄��到节点上��是同时攄��在两个节点上。当我们知道哪些节点是相互连通的�Q�就可以定义�q�行光线跟踪的算法了�Q�不�q�首先我们需要定义一些帮助函数�?br>��Z��方便�q�行光线跟踪我们需要一些基本的光线跟踪函数�Q�BSP树是非常适合�q�行光线跟踪的结构，因�ؓ大部分不可见的区域通过BSP树可以很��单的剔除掉，不用�q�行遍历�Q�因此花费的旉��也非常少。我们需要的函数如下�Q?br>POLYGON-IS-HIT (Polygon, Ray) �q�回光线是否和多边�Ş�怺��?br>RAY-INTERSECTS-SOMETHING-IN-TREE (Node, Ray) �q�回光线是否和节点中的子树相交�?br>INTERSECTS-SPHERE (Sphere, Ray) �q�回光线是否和球体相交�?br>CREATE-RAY (Point1, Point2) 通过两个�Ҏ��建立一条光�Uѝ�?br>上面的函数RAY-INTERSECTS-SOMETHING-IN-TREE是一个非常有��的函数�Q�因为它昄��了一些BSP树的优点�Q�同时也昄��了如何��用BSP树来加速光�U�跟�t�的处理。它是一个递归函数�Q�首先在树的根节点上使用�Q�伪��法如下�Q?br>l 函数RAY-INTERSECTS-SOMETHING-IN-TREE
l 参数�Q?br>l Node – 用来�q�行跟踪的节炏V�?br>l Ray – 用来�q�行求交的光�Uѝ�?br>l �q�回��|��
l 光线是否和节点中的物体相交�?br>l 功能�Q?br>l ��光�U�是否与�l�定节点极其子树中的物体�怺��?br>RAY-INTERSECTS-SOMETHING-IN-TREE (Node, Ray)
1 for each polygon P in Node
2 POLYGON-IS-HIT (P, Ray)
3 startSide = CLASSIFY-POINT (Ray.StartPoint, Node.Divider)
4 endSide = CLASSIFY-POINT (Node.EndPoint, Node.Divider)
l 如果光线和节点的分割面相交或和分割面的位�|�重叠，对节点的两个子节点进行检��?br>5 if ((startSide = COINCIDING and endSide = COINCIDING) or
startSide <> endSide and startSide <> COINCIDING and
endSide <> COINCIDING)
6 if (RAY-INTERSECTS-SOMETHING-IN-TREE (Node.LeftChild, Ray))
7 return true
8 if (RAY-INTERSECTS-SOMETHING-IN-TREE (Node.RightChild, Ray))
9 return true
l 如果光线只位于分割面�?#8220;正面”对节点的叛_��树进行检��。在if语句中��用or操作�W�是因�ؓ光线的一个端点可能与分割面的位置重叠�?br>10 if (startSide = INFRONT or endSide = INFRONT)
11 if(RAY-INTERSECTS-SOMETHING-IN-TREE (Node.RightChild, Ray))
12 return true
l 如果光线只位于分割面�?#8220;反面”对节点的左子树进行检��。在if语句中��用or操作�W�是因�ؓ光线的一个端点可能与分割面的位置重叠�?br>13 if (startSide = BEHIND or endSide = BEHIND)
14 if (RAY-INTERSECTS-SOMETHING-IN-TREE (Node.LeftChild, Ray))
15 return true
l 光线没有和�Q何物体相交，�q�回��C��一层�?br>16 return false
��法分析
最坏的情况是光�U�K��历了BSP树中每一个节点，�q�样光线��与节点中每一个单独的多边形进行检��，�q�时函数的复杂度��ؓO(n)�Q�这里n为BSP树中所有多边�Ş的数量。一般情况下光线�q�不会检��树中的每一个节点，�q�样��会大大减少�q�行��的多边形数量。最佳的情况是光�U�被限制在一个节点中�Q�这时函数的复杂度接�q�于�Q?lg n)�Q�这取决于BSP树的�l�构大小�?br>l 函数CHECK-VISIBILITY
l 参数�Q?br>l Node1 – 开始处的节炏V�?br>l Node2 – �l�束处的节点�?br>l �q�回��|��
l Node2是否可以被node1看见�?br>l 功能�Q?br>l 在两个叶节点的典型点之间�q�行跟踪�Q�检��两个节点之间是否可见�?br>CHECK-VISIBILITY (Node1, Node2)
1 Visible = false
2 for each 典型点P1 in Node1
3 for each 典型点P2 in Node2
4 Ray = CREATE-RAY (P1, P2)
5 if(not RAY-INTERSECTS-SOMETHING-IN-TREE(Node1.Tree.RootNode,
Ray)
6 Visible = true
7 return Visible
��法分析
函数CHECK-VISIBILITY非常耗费旉��Q�当我们在两个叶节点之间�q�行光线跟踪来检��两者之间是否可见时�Q�我们不得不从Node1的每一个典型点开始对Node2的每一个典型点�q�行跟踪�Q�最坏的情况是每一�ơ跟�t�都��对树中所有的多边形进行检��，�q�时函数的复杂度O(s1 s2 p)�Q�这里s1为Node1中典型点的数量，s2为Node2中典型点的数量，p为树中多边�Ş的数量。通常它的性能是比较好的，接近于O(s1 s2 lg p)�?br>l 函数TRACE-VISIBILITY
l 参数�Q?br>l Tree – 去进行光�U�跟�t�的BSP-tree�?br>l �q�回��|��
l None
l 功能�Q?br>l 对于树中每一个叶节点�Q�它��进行光�U�跟�t�运��来��和它相�q�的节点的可见性。每一个被发现是可见的节点��会被添加到当前节点的PVS中。当一个叶节点发现是可见的�Q�我们还要对和它相连的节点进行光�U�跟�t�运��来��可见性�?br>TRACE-VISIBILITY (Tree)
1 for (each 树中的叶节点L)
2 for (each 和叶节点L相连的叶节点C)
3 ��d��节点C到节点L的PVS�?br>4 for (each 树中的叶节点L1)
5 while (在叶节点L的PVS中存在一个叶节点L2�Q�它所�q�接的节�Ҏ��有进行可见性检��?
5 for (each �q�接到节点L2中的叶节点C)
6 if (节点C没有位于节点L1的PVS�?and
CHECK-VISIBILITY (L1, C))
7 ��d��节点C到节点L1的PVS�?br>7 ��d��节点L1到节点C的PVS�?br>��法分析
如果我们没有使用�Ҏ��叶节点的相连情况来进行处理的优化技术，那么必须�Ҏ��中的每一个叶节点�q�行��，�q�时函数的复杂度为O(n2)�Q�这里n为树中叶节点的数量。要对上面的��法估计一个对处理�q�程提高了多��性能的具体数值非常困难，因�ؓ它依赖于所处理的结构的大小。对于每一个叶节点与其它节炚w��是可见的�l�构�Q�这个算法不会做��M��优化。对于每一个叶节点只有一��C��个可见的节点的结构，�q�个��法��会产生非常大优化，它的复杂度接�q�与O(n)�?br>现在在一个设计良好的地图上所产生的结构在每一帧上��会避免��大量的多边形。一个设计良好的地图在徏立时��会考虑物体的可见性，�q�意味着应尽可能的在地图中放入一些能障碍视线的物体，如墙壁等。如果在地图中包含一个有大量�l�节的大戉K��Q�那么在上面的算法中�Q�或在一个portal引擎中）�q�行的隐藏面剔除工作对它不会产生��M��效果。这时我们需要��用其它类��g��LOD�q�样的技术来�q�行多边形剔除�?/p>

静态物�?br>考虑一下这��L��场景�Q�一个球体位于一个立方体的中心，如果用BSP对它�q�行渲染那么��会产生大量的节点，�q�会产生大量的分割多边�Ş�Q�这是因为在球体上的每一个多边�Ş都会送入到叶节点中。如果球体有200个多边�Ş当渲染时��׃��产生200个叶节点的BSP树。这样做非常影响�q�行的速度�Q�因此必��d��找一个方法来避免�q�种现象的发生�?br>��Z��解决�q�个问题地图的设计者可以选择�l�成地图的几何体�Q�在上面的例子中也就是立方体�Q�接着��剩余的物体做�ؓ静态物体，它们��不会用来对BSP树进行渲染或�q�可见性检��，但是它们会参与到地图的光照运��当中去。当�q�行可见性运��时每一个静态物体会被添加到BSP树中�Q�每一个静态物体的多边形将会被��d��到BSP树中�Q�这个过�E�如下：
l 函数PUSH-POLYGON
l 参数�Q?br>l Node – 多边形当前所在的节点�?br>l Polygon – ��被��d��的多边�Ş�?br>l �q�回��|��
l None
l 功能�Q?br>l ��多边�Ş��d��到树中。如果多边�Ş的一些点与节点的分割面相交将会被分割。分割后的部分将会被�l�箋向下传送。当一个多边�Ş�q�入一个叶节点后它��被��d��到叶节点的多边�Ş集合中�?br>PUSH-POLYGON (Node, Polygon)
1 if (IS-LEAF (Node))
2 Node.PolygonSet = Node.PolygonSet U Polygon
3 else
4 value = CALCULATE-SIDE (Node.Divider, Polygon)
5 if (value = INFRONT or value = SPANNING)
6 PUSH-POLYGON (Node.RightChild, Polygon)
7 else if (value = BEHIND)
8 PUSH-POLYGON (Node.LeftChild, Polygon)
9 else if (value = SPANNING)
10 Split_Polygon28 (P1, Divider, Front, Back)
11 PUSH-POLYGON (Node.RightChild, Front)
12 PUSH-POLYGON (Node.LeftChild, Front)
PUSH-POLYGON是一个递归函数�Q�它��一个多边�Ş��d��到BSP树中�Q�这个函数对每一个静态物体的每一个多边�Ş都会调用一�ơ，
在这个过�E�处理之后叶节点可能不再成�ؓ一�?#8220;�?#8221;集合�Q�这在进行碰撞检��时可能会��生一些问题，后面的内容将会对�q�个问题�q�行阐述�?br>BSP技术详�?

eXtreme3D

�W�三�?室内场景中光照运��?br>关于Radiosity的算法最早是由Goral、Cindy M、Torrance、Kenneth E、Greenberg、Donald P、Battaile和Bennett在论文《Modelling the interaction of light between diffuse surfaces》提出的。他们��用Radiosity来模拟能量在漫反��表面之间进行传送，漫反��表面对照到表面上的光线在所有的方向上都�q�行相同的反��，和它相反的是镜面反射表面�Q�它只在反射方向上传播反��光。由于�O反射表面的这个特性，�q�就意味着对于所有的观察角度而言看�v来表面都是相同的�Q�这样对于场景中的每一个表面只需要进行一�ơ光照运��，而且可以在场景的预渲染时�q�行�Q�因此这��Ҏ��术被大量�?D游戏所采用�?br>下面我再��短的讲解一下Radiosity是如何工作的�Q�而将主要的精力放在如何��用BSP树来加速Radiosity的计��，对于Radiosity的详�l�介�l�请参考前面的章节。Radiosity技术是设计用来使场景中光照看�v来更加真实和光滑�Q�如果我们��用一个一直向前传播而不考虑反射的光照模型，那么当场景中的灯光照亮场景中的物体时�Q��ƈ不会计算�q�处�l�过反射�q�来的光�U�，�q�样场景中的阴媄看�v来非常尖锐而物体表面也看�v来非�怸�真实。�ؓ了��用radiosity技术我们需要把场景分割成一块一块很��的部分�Q�每一部分我们�U�它为patch�Q�每一个patch都有一个初始化的能量��别，如果它不是一个灯光这��L��发光体的话通常�?�Q�有许多�Ҏ��来分配场景中的能量，�q�里我们��要使用的方法称��Z��互式radiosity。这个方法的�q�程是我们从场景中未发送能量的�U�别最高的patch开始发送能量，能量�l�过传递后��不再发送能量的patch的等�U�设�?�Q�重复这个过�E�直到场景中的每一个patch的能量等�U�都��于一个预定��gؓ止�?br>当能量从一个patch�Q�j�Q�开始发送到另一个patch�Q�i�Q�时我们使用下面的公式：
Bi = Bi + Bj * Fij * Ai / Aj
�q�里Bi = patch�Q�i�Q�的能量�U�别    Bj = patch�Q�j�Q�的能量�U�别
    Ai= patch�Q�i�Q�的作用区域    Aj = patch�Q�j�Q�的作用区域
    Fij = patch�Q�i�Q�与patch�Q�j�Q�之间的�p�L��
在公式中�p�L��Fij是由以下公式来确定的�Q?br>Fij = (cos qi * cos qj) / d2 * Hij
�q�里Fij = patch�Q�i�Q�与patch�Q�j�Q�之间的�p�L��
qi = patch�Q�i�Q�与patch�Q�j�Q�法�U�之间的夹角
qj = patch�Q�i�Q�与patch�Q�j�Q�法�U�之间的夹角
d = patch�Q�i�Q�与patch�Q�j�Q�之间的距离
Hij = patch�Q�i�Q�与patch�Q�j�Q�之间的可见性系数。如果在两个patch之间只有一条光�U�可以跟�t�，�q�个��gؓ1�Q�如果没有光�U�可以跟�t��ؓ0。一般情况下�׃��每一个patch都不是一个点而是一个区域，因此光线有很多条�?br>从上面的公式中我们可以看到在场景中进行radiosity计算是非常耗费旉��的。这个函数的复杂度�ؓO(n3)�Q�这里的n为场景中patch的数量。由于对于场景中每一个patch你需要发送最��一条光�U�到其它patch上，因此需要对场景中的几乎所有的多边形都�q�行光线跟踪计算。在上面的公式中�p�L��H的计��非常耗费旉��Q�下面我们将看一下如何在BSP树中对它的计��进行优化�?

BSP树中的radiosity计算
在进行场景中的光照计��之前需要把场景中的面分割�ؓpatch�Q�一个方法是在开始的时候设定每一个patch为预定的大小�Q�当计算每一个patch的能量时�Q�如果在patch上的能量��_��大，对这个patch�q�行分割。不�q�这个方法是非常耗费旉��的，因此必须��L��一个更好的�Ҏ��来通过BSP树对计算�q�行优化�?br>在radiosity的一般算法中场景中的每一个光源都被看作�ؓ一个或多个patch�Q�这里我们可以改�q�一下，��每一个光源放在它所位于的叶节点中，接下来每一个光源都发送自��q��能量到场景中所有的patch上，当这个过�E�完成后radiosity计算也就�l�束了。�ؓ了��最后的�l�果看�v来更好可以��用一�U�称�?#8220;渐进�_�N�?#8221;�Q�progressive refinement�Q�的技术来对这个方法进行很��的修改。在每一�ơ过�E�中�Q�叶节点中具有高能量的patch��发送能量到其它低能量的patch上，�q�样做的�l�果是高亮度的patch��发送能量到处于阴媄中patch上。这是因为在实际生活中�ƈ没有真正黑暗的地方，它多多少��要获得一些其它物体反��过来的光亮�?br>�׃��计算非常耗费旉��需要做一下优化，使用渲染BSP树时获得的PVS信息可以在选择哪些patch��接受能量时剔除一些无用的计算。因为在计算PVS时��用了相同的方法来�q�行光线跟踪�?br>通过场景来分配能量的��法如下�Q?br>l 函数RADIOSITY
l 参数�Q?br>l Tree – �q�行radiosity计算的BSP树�?br>l �q�回��|��
l None
l 功能�Q?br>l 在场景中的patch之间发送能量�?br>RADIOSITY (Tree)
1 for(each leaf L in Tree)
2 for(each light S in L)
3 for(each leaf V that is in L’s PVS)
4 Send S’s energy to the patches in V
l 下面语句5是�ؓ了让地图�~�辑者在��M��时候都可以��查场景渲染的效果�Q�如果他感到看�v来已�l��够好了可以中断能量的传播�?br>5 while(not looks good enough)
6 for(each leaf L in Tree)
7 for(each leaf V that is in L’s PVS)
8 Send energy from the patch with the most unsent energy in L
to all patches in V.
复杂度分�?br>�q�个函数的运��费用实在是太高昂了�Q�可以称为时间杀手，在最坏的情况下每一条光�U�将不得不检��场景中的每一个多边�Ş�Q�此时复杂度为O(n3)�Q�这里n为树中patch的数量。一般情况下�׃��q�行了优化可以减��大量的计算�Q�但是减��多��ƈ不能计算出来�Q�因��依赖于树�l�构的复杂度�?br>上面的函数给��Z��一个充分利用BSP树的优点来加速场景光照运��的�Ҏ��Q�尤其是可以显著的减��光�U�跟�t�的计算量，而且地图设计者可以来军_��当场景渲染时如果渲染的效果可以接受中断渲染��@环。这对地囄��预渲染实在是太方便了�Q�运行的旉��可以�Ҏ��渲染的效果来军_��?br>�W�四�?BSP树的预渲�?br>现在我们需要完成一个完整BSP引擎的预处理�q�程�Q�下面的��法昄��如何��场景渲染到BSP树中�?br>l 函数RENDER-SCENE
l 参数�Q?br>l Scene – 被渲染的场景
l �q�回��|��
l 一个BSP树�?br>l 功能
l 预渲染来获得一个包含场景信息的BSP树�?br>RENDER-SCENE (Scene)
l 使用描述场景中图元的物体来渲染BSP树�?br>1 GeometryPolygons = {}
2 for (每一个包含场景图元的物体object O)
3 GeometryPolygons = GeometryPolygons U O.PolygonSet
4 GENERATE-BSP-TREE (Tree.RootNode, GeometryPolygons)
l 分配叶节点上的取��L��?br>5 DISTRIBUTE-SAMPLE-POINTS (Tree.RootNode, {})
6 TRACE-VISIBILITY (Tree)
7 for 每一个场景中的静态物体object O
8 for 物体O中每一个多边�ŞP
9 PUSH-POLYGON (Node, P)
l 函数CREATE-PATCHES是一个未定义的函敎ͼ��׃��我们的解��x��案效率�ƈ不是太好�Q�因此没有对它进行详�l�的介绍�?br>10 CREATE-PATCHES (Tree)
11 RADIOSITY (Tree)
复杂度分�?br>函数的复杂度如下�Q?br>函数最坏情�?一般情�?描述
GENERATE-BSP-TREE O(n2 lg n) O(n2) n为场景中多边形的数量
DISTRIBUTE-SAMPLE-POINTS Q (np + xy) Q (np + xy) n为树中多边�Ş的数量，p为树中典型点的数量，x和y为分割面的宽度和高度�?br>TRACE-VISIBILITY O(n2) O(n lg n), n为树中多边�Ş的数量�?br>RADIOSITY O(n3) O(n2 lg n) n为树中patch的数�?br>在一般情况这一列中昄��了算法通常所需�q�行的时��_��对算法时间媄响最大的是函数RADIOSITY�Q�它使整个算法的复杂度趋向于O(n3)�?/p>

bloodbao 2008-05-30 20:11 发表评论

ogre+cegui

bloodbao — Fri, 30 May 2008 09:32:00 GMT

OGRE是拿来玩的，IRR是拿来做��目的，BLOOD��是最强大的DX10引擎�Q?

bloodbao 2008-05-30 17:32 发表评论

bloodbao — Wed, 28 May 2008 01:33:00 GMT

DX10之GS生成��?br>1.�׃��角�Ş生成金字塔：
��析：triangle GSPS_INPUT input[3]代表输入的三角�Ş
inout TriangleStream TriStream 代表输出的三角�Ş��－即金字塔�?2个顶�?br>�W�一个��@环计��三个标出法向量的三角�Ş�Q�如图所�C��?br>�W�二个��@环计��出三角形与输入的三角�Ş一��P��但��^面的法向量刚好相反�?img src="http://www.shnenglu.com/images/cppblog_com/bloodbao/gs.jpg" border=0>

//--------------------------------------------------------------------------------
// Geometry Shader
//--------------------------------------------------------------------------------
[maxvertexcount(12)]
void GS( triangle GSPS_INPUT input[3], inout TriangleStream TriStream )
{
    GSPS_INPUT output;

    //
    // Calculate the face normal
    //
    float3 faceEdgeA = input[1].Pos - input[0].Pos;
    float3 faceEdgeB = input[2].Pos - input[0].Pos;
    float3 faceNormal = normalize( cross(faceEdgeA, faceEdgeB) );
    float3 ExplodeAmt = faceNormal*Explode;

    //
    // Calculate the face center
    //
    float3 centerPos = (input[0].Pos.xyz + input[1].Pos.xyz + input[2].Pos.xyz)/3.0;
    float2 centerTex = (input[0].Tex + input[1].Tex + input[2].Tex)/3.0;
    centerPos += faceNormal*Explode;

    //
    // Output the pyramid
    //
    for( int i=0; i<3; i++ )
    {
        output.Pos = input[i].Pos + float4(ExplodeAmt,0);
        output.Pos = mul( output.Pos, View );
        output.Pos = mul( output.Pos, Projection );
        output.Norm = input[i].Norm;
        output.Tex = input[i].Tex;
        TriStream.Append( output );

        int iNext = (i+1)%3;
        output.Pos = input[iNext].Pos + float4(ExplodeAmt,0);
        output.Pos = mul( output.Pos, View );
        output.Pos = mul( output.Pos, Projection );
        output.Norm = input[iNext].Norm;
        output.Tex = input[iNext].Tex;
        TriStream.Append( output );

        output.Pos = float4(centerPos,1) + float4(ExplodeAmt,0);
        output.Pos = mul( output.Pos, View );
        output.Pos = mul( output.Pos, Projection );
        output.Norm = faceNormal;
        output.Tex = centerTex;
        TriStream.Append( output );

        TriStream.RestartStrip();
    }

    for( int i=2; i>=0; i-- )
    {
        output.Pos = input[i].Pos + float4(ExplodeAmt,0);
        output.Pos = mul( output.Pos, View );
        output.Pos = mul( output.Pos, Projection );
        output.Norm = -input[i].Norm;
        output.Tex = input[i].Tex;
        TriStream.Append( output );
    }
    TriStream.RestartStrip();
}
2.GS�_�子
实现像烟�׃��L��效果�?br>首先要了解五�U�基本粒子�?br>Launcher Particles 发射�_�子�Q�不�U�d��也不��d��Q�用来发��Shell�_�子。一旦发��完Shell�_�子�Q�就重置旉��?br>Shell Particles 由发��粒子发��出随机速度的的Shell�_�子�Q�在生命周期内不发射本类型的�_�子�Q�而发��出一些Ember1和Ember2�c�d��的粒子�?br>Ember1 Particles 由Shell�_�子发射�Q�拥有很短的生命周期�Q�随着旉��而��E出死去，�q�不发射�_�子�?br>Ember2 Particles 由Shell�_�子发射�Q�在生命周期末发出Ember3�_�子�Q�第二次的爆炸源�?br>Ember3 Particles �c�M��Ember1�_�子�Q�除了有不同的颜艌Ӏ?br>[maxvertexcount(128)]
void GSAdvanceParticlesMain(point VSParticleIn input[1], inout PointStream ParticleOutputStream)
{
    if( input[0].Type == PT_LAUNCHER )
        GSLauncherHandler( input[0], ParticleOutputStream );
    else if ( input[0].Type == PT_SHELL )
        GSShellHandler( input[0], ParticleOutputStream );
    else if ( input[0].Type == PT_EMBER1 ||
              input[0].Type == PT_EMBER3 )
        GSEmber1Handler( input[0], ParticleOutputStream );
    else if( input[0].Type == PT_EMBER2 )
        GSEmber2Handler( input[0], ParticleOutputStream );
}

bloodbao 2008-05-28 09:33 发表评论

从dll导出其对应的lib

bloodbao — Sat, 17 May 2008 11:39:00 GMT

Visual   C++   开发工��h��供了两个命��o行工��P��一个是dumpbin.exe,另一个是lib.exe。利用这两个工具卛_��从dll导出其对应的lib�?nbsp;

1、在命��o行执行：
dumpbin   /exports   yourdll.dll   >   yourdll.def

2、编�?nbsp; yourdll.def   文�g�Q��之格式与.def文�g格式一致。比如：

EXPORTS;
                fn1;
                fn2;

3、在命��o行执行：
lib   /def:yourdll.def   /machine:i386   /out:yourdll.lib

�q�样��可以导出对应的LIB了，但你要用的话�Q�要在工�E�中自己手工加上

bloodbao 2008-05-17 19:39 发表评论

underwater scene

bloodbao — Fri, 16 May 2008 12:46:00 GMT

工作啊，工作�Q�有朋友说要推荐��M��和�q�东啦，不过�Q�估计还是要面试�Q�怕怕！
最�q�要��写��析多写CODE了！
刚做的场景：

bloodbao 2008-05-16 20:46 发表评论

bloodbao — Mon, 12 May 2008 11:51:00 GMT

有Effect版：
DWORD g_dwShaderFlags; // Shader compilate and link flags
LPD3DXBUFFER g_pCompiledFragments = NULL;

D3DXGatherFragmentsFromFile( L"FragmentLinker.fx", NULL,
NULL, g_dwShaderFlags, &g_pCompiledFragments, NULL );

D3DXGatherFragmentsFromFile requires the .fx file, pointers to the #define and #include handlers (both set to NULL in this example), and the shader compile flags. The method returns a buffer which contains the compiled shader fragment. The method can return a second buffer with compile errors, which is set to NULL in this example because it is not used. D3DXGatherFragments is overloaded to handle loading fragments from a string, a file, or a resource.

Set your debugger to break on this method to look for compile errors in the debugger. The compiler can catch errors in syntax, but it cannot check for registers that are shared incorrectly due to the fact that it has no way to predict which parameters a user may want to share between fragments.

You need a fragment linker to manage the compiled fragments. Create the fragment linker by calling D3DXCreateFragmentLinker:

ID3DXFragmentLinker* g_pFragmentLinker = NULL; // Fragment linker interface
IDirect3DDevice9* pd3dDevice = NULL;

    // Initialize the device before using it
...

    // Create the fragment linker interface
    D3DXCreateFragmentLinker( pd3dDevice, 0, &g_pFragmentLinker );

Then simply add the compiled fragments to the fragment linker using ID3DXFragmentLinker::AddFragments.

    // Add the compiled fragments to a list
    g_pFragmentLinker->AddFragments(
              (DWORD*)g_pCompiledFragments->GetBufferPointer() );

ID3DXFragmentLinker::AddFragments requires a pointer to the DWORD stream that contains the compiled shader.

After compiling fragments and creating a fragment linker, there are several ways to link fragments. One way to link a vertex shader fragment is to call ID3DXFragmentLinker::LinkVertexShader. Here is an example that links two vertex shader fragments:

    // Get a handle to each fragment
    D3DXHANDLE fragmentHandle[2];
fragmentHandle[0] =
     (D3DXHANDLE)g_pFragmentLinker->GetFragmentHandleByName("Ambient");
fragmentHandle[1] =
     (D3DXHANDLE)g_pFragmentLinker->GetFragmentHandleByName("AmbientDiffuseFragment");

    // Link the fragments together to form a vertex shader
    IDirect3DVertexShader9* pVertexShader = NULL;
    g_pFragmentLinker->LinkVertexShader( "vs_1_1", g_dwShaderFlags,
           fragmentHandle, 2, &pVertexShader, NULL );

This requires a shader compile target, the shader compile and link flags, and a handle to each of the fragments to link. If the fragments are successfully linked, ID3DXFragmentLinker::LinkVertexShader returns a vertex shader (IDirect3DVertexShader9). The vertex shader needs to be set in the effect before rendering. But before this, here's how the shader is declared in the effect:

VertexShader MyVertexShader; // Vertex shader set by the application

The effect technique contains all the state set for a pass. This pass specifies the vertex shader like this:

technique RenderScene
{
    pass P0
    {
        VertexShader = ;
        PixelShader = compile ps_1_1 ModulateTexture();
    }
}

With the effect's vertex shader created and initialized, the render code also sets the uniform constants and calls the render loop. Set the uniform constants similar to this:

    // Update the uniform shader constants.
    g_pEffect->SetMatrix( "g_mWorldViewProjection", &mWorldViewProjection );
    g_pEffect->SetMatrix( "g_mWorld", &mWorld );
    g_pEffect->SetFloat( "g_fTime", (float)fTime );
Then render the effect by setting the current technique and pass:

    // Render the scene
    if( SUCCEEDED( pd3dDevice->BeginScene() ) )
    {
        // Apply the technique contained in the effect
        UINT cPasses, iPass;
        g_pEffect->Begin(&cPasses, 0);

        for (iPass = 0; iPass < cPasses; iPass++)
        {
            g_pEffect->BeginPass(iPass);

// Render the mesh with the applied technique
g_pMesh->DrawSubset(0);

            g_pEffect->EndPass();
        }
        g_pEffect->End();

pd3dDevice->EndScene();
}

When setting uniform shader constants, it is more efficient to cache a handle to the parameter by calling ID3DXBaseEffect::GetParameterByName. This avoids the string lookup that is necessary when calling effect methods like ID3DXBaseEffect::SetMatrix.

// Instead of setting a uniform constant like this in the render loop
g_pEffect->SetMatrix( "g_mWorldViewProjection", &mWorldViewProjection );

// Get a handle to a uniform constant outside of the render loop
D3DXHANDLE hParameter;
GetParameterByName( hParameter,"g_mWorldViewProjection");

...

// Use the handle to set the uniform constant in the render loop
g_pEffect->SetMatrix(hParameter);

无Effect版：
LPD3DXCONSTANTTABLE pConstantTable;
LPD3DXBUFFER pShaderBuf;
IDirect3DVertexShader9* pVertexShader = NULL;

    // Compile the fragments to a buffer.
    D3DXGatherFragmentsFromFile( L"FragmentLinker.fx", NULL, NULL,
         g_dwShaderFlags, &g_pCompiledFragments, NULL );

    g_pFragmentLinker->AddFragments((DWORD*)g_pCompiledFragments->GetBufferPointer());
    g_pFragmentLinker->LinkShader(
    "vs_1_1",
    g_dwShaderFlags,
    aHandles,
    NUM_FRAGMENTS,
    &pShaderBuf,
    NULL);
    D3DXGetShaderConstantTable(
    (DWORD*)pShaderBuf->GetBufferPointer(),
    &pConstantTable );

    pDevice->CreateVertexShader(
    (DWORD*)pShaderBuf->GetBufferPointer(),
    &pVertexShader);
    RELEASE(pShaderBuf);

bloodbao 2008-05-12 19:51 发表评论

bloodbao — Sun, 11 May 2008 03:42:00 GMT

OGRE场景��理�Q?br>PCZSceneManager : public SceneManager
节点�Q?br>    typedef std::list < SceneNode * > NodeList;
    typedef std::list < WireBoundingBox * > BoxList;
摄像机：
    class PCZCamera;
天空�Q?br>    void setSkyZone(PCZone * zone);
光照�Q?br>    createLight(const String& name);
地带�Q?br>    class PCZone;
    PCZone * createZone(const String& zoneType, const String& instanceName);
释放节点�Q?br>    void removeSceneNode( SceneNode * );
节点查找�Q?br>    void findNodesIn( const AxisAlignedBox &box,
        PCZSceneNodeList &list,
        PCZone * startZone,
        PCZSceneNode *exclude = 0 );

    class PCZIntersectionSceneQuery;�Q�－�Q�－�Q�相交查�?br>    class PCZRaySceneQuery;�Q�－�Q�－�Q�－�Q�－�Q�射�U�查�?br>    class PCZSphereSceneQuery;�Q�－�Q�－�Q�－�Q�－球面查询
    class PCZAxisAlignedBoxSceneQuery;�Q�－�Q�－�Q�－��查询（沿��u向）
    class PCZPlaneBoundedVolumeListSceneQuery;-----�Q�－表查�?br>��单地看了OGRE的场景管理，除了OGREMAIN部分�Q�还用了PCZ插�g来实�l�承�q�实现�?br>�Q�class PCZSceneManagerFactory : public SceneManagerFactory�Q�挺复杂的，相比之下�Q�鬼火的场景��理��q��单了�Q?br>可调用多�U�节炏V�?/p>

bloodbao 2008-05-11 11:42 发表评论

bloodbao — Sat, 10 May 2008 14:00:00 GMT

bloodbao 2008-05-10 22:00 发表评论

nd面试分析

bloodbao — Thu, 08 May 2008 06:38:00 GMT

�q�一�ơ的应聘是彻底失败了�Q�不�q�，也算是见识了��徏的网游公司�?br>一天坐了九个小时的车，我算是体验到了讨生活的艰辛�?br>中午坐�R的时候天�q�是炎热的，下午开始狂下雨�Q�我�I�着两�g衣服�q�一直在发抖�?br>先来谈谈感受�Q?br>1.公司内部环境不错�Q�很漂亮的游��x��Q�攀沿壁�Q�会议室�Q�食堂。我比较喜欢那个游泳池，感觉很不错�?br>2.��女很多�Q�特别是��Z��部门的，那么��L��天气�Q�穿着��短裙，��是要风度不要温度。不�q�，特别�ȝ��?br>3.工作环境�Q�两三百个�h挤在一个大厅中。好像，各个开发组都在一起吧�Q�有些成员面前放着两台很大的液�Ӟ��很上��d��挺爽的。只是这么吵杂的环境适合开发吗�Q�偶是不知道的�?br>4.��Z��部的MM挺勤快的�Q�不�q�，依旧有被扔在一旁的感觉�Q�特别是在等与主�E�见面的旉��Q�差不多快一个小时。幸好旁边的一个帅哥给了本杂志�Q�让我打发时间�?br>5.每时每刻都有人在应聘�Q�不�q�，都是招文员。感觉就��M��一个PHP的，也算技术的�?br>6.�ȝ��很厉宻I��用现在的话讲�Q�叫很牛。�h事的MM�Q�说他很严格�Q�面试的题目都是他出的，非常难。面谈时果然很严�Q�偶不是计算机科班出�w�的�Q�虽然C++用的不是炉火�U�青�Q�但也有两三�q�的基础�Q�对基本概念都是��懂的，可是要我按书本上背出来，让我有点难以接受�Q�也背不出来啊）�?br>至于题目的难度，有用的C++的朋友，应该都是了解的。还有就是那个主�E�一直想让我讲优点和�~�点�Q�估计是��Z��岗位安排考虑�Q�可是俺一直找不来自已的特�Ԍ��q�算是我面试的��|�W�吧。最大的败笔可能是对��Z��的MM�Q�说了句�q�考题太EASY了�?br>7.带去代码用的调试环境太高�Q�这是我的错�Q�哎�Q�谁让我的开发环境是VISTA+VC2008�Q�嗯�Q�难道ND都没有一台电脑跑�q�个的？
那主�E�说�E�序打不开。哎�Q�我的错。直觉告诉我�Q�这个主�E�比华�ؓ面试官差多了�Q�简直是两个档次的。以前，在和华�ؓ的交��时�Q�那态度啊，对代码的分析�Q�都很不错。可怜，那时我刚学C++�Q�傻乎乎的就跑去面试�Q�华为招��g+C的比较多�Q�和偶的不适合�Q�我不懂数字电�\�Q�模�늭��g斚w��的知识）�?br>8.我说了我的优势在�Ҏ��学的了解上，比如矩阵可能在引擎上有一定的应用。那�ȝ��直接和我��_��数学在游戏开发上应用不太。我忽视了，ND好像用的是UNREAL�Q�别人的引擎�Q�不用自已开发底层吧�Q?br>C++
1.什么是�l�承�Q?br>2.什么是多态性？
3.什么是Iterator,有什么作用？
4.STL是什么？
5.STACK,LIST和MAP有什么不同？
6.什么是重蝲�Q�overloading)和重写（overridding)�Q�有什么区别？
7.多线�E�有几种。。。？
8.MUTEX和CRITICALSECTION有什么区别？
9.ENTERCRITICALSECTION和TRYENTERCRITICALSECTION有什么不同？
D3D
1.材质是什么？有些什么元素？
2.LOD时��生T型裂�~�和呼吸效应�Q�有什么优化方案？
3.��解HDR技术？
4.什么是BILLBOARD�Q�怎么实现�Q?br>5.什么是BSP?用在室内�q�是室外�Q�怎么实现�Q?br>6.模板�~�冲区的应用�Q?br>7.逆矩阉|��什么应用？
面试�Ӟ��
1.D3D或ONPENGL�Q�实��C��个三角�Ş�Q�（�q�程�Q?br>2.用过什么物理引擎？
3.用过什么脚本？
4.自已的优�~�点�Q?br>5.有什么作品�ƈ介绍�Q?br>6.�?D中的什么最熟悉�Q?br>�ȝ��Q��|军之��，谈什么都是没用的�Q�找不到好工作苦的是自已�Q�赶快加��p��w�的修养。特别是表达和沟通能力�?

bloodbao 2008-05-08 14:38 发表评论

bloodbao — Thu, 08 May 2008 02:31:00 GMT

该项目��用INI来实现数据的��d��?br>比如�Q?br>1.节点��d��
INI部分�Q?br>外观
Look
Body
  model=impreza.3ds
  scale=1 1 1
Wheels
  model=wheel.3ds
  scale=1 1 1
声音
Sound
Engine
  wave=206_engine.wav
  pitch_low=0.2
  pitch_high=1.5
�E�序部分�Q?br>//load car

body.node=loadModel(cfg, "Look/Body/", device, sm, driver);

body.node_debug=sm->addCubeSceneNode(1, 0, -1, core::vector3df(0, 0, 0), core::vector3df(0, 0, 0),
  cfg.Getval_vector("Body/Chassis/1/scale", core::vector3df(1, 1, 1))
  );
body.node_debug->setMaterialTexture(0, driver->getTexture("data/misc/checked.jpg"));
2.车轮的属�?br> Wheel #default
  damp=30000
  spring=50000
  radius=0.38
  weight=20
  width=0.10 #not yet used if user specifies wheel model
  brakes=0 # 0.0 - 1.0
Wheel_1 #fl
  pos=1.39 -0.145 0.823
  attr=STEER
  brakes=0.8
  rotation_z=1.5707963 #used just by client part
Wheel_2 #fr
  pos=1.39 -0.145 -0.823
  attr=STEER
  brakes=0.8
  rotation_z=4.7123889
Wheel_3 #rl
  pos=-1.350 -0.15 0.823
  attr=STRAIGHT|THURST
  brakes=0.2
  rotation_z=1.5707963
Wheel_4 #rr
  pos=-1.350 -0.15 -0.823
  attr=STRAIGHT|THURST
  brakes=0.2
  rotation_z=4.7123889
for (int i=0; ; i++) {
  char buf2[128];

sprintf(buf2, "Body/Wheel_%d/", i+1);
buf=buf2;

if (!cfg.Getval_exists(buf+"attr")) break;

double radius=cfg.Getval_double((string)buf+"radius", cfg.Getval_double("Body/Wheel/radius", 1));
double width=cfg.Getval_double((string)buf+"width", cfg.Getval_double("Body/Wheel/width", 1));

scene::ISceneNode* node=loadModel(cfg, "Look/Wheels/", device, sm, driver);
CModelAttr wm;

  scene::IMesh* cm=CreateCylinder(25, 2, 1);
  scene::ISceneNode* node_debug=sm->addMeshSceneNode(cm);
  node_debug->setScale(core::vector3df((f32)(radius), (f32)width, (f32)(radius)));
  node_debug->setMaterialTexture(0, driver->getTexture("data/misc/checked.jpg"));
  node_debug->getMaterial(0).EmissiveColor.set(255,255,255,255);

  wm.arot=core::vector3df((f32)cfg.Getval_double(buf+"rotation_x", 0),
    (f32)cfg.Getval_double(buf+"rotation_y", 0),
    (f32)cfg.Getval_double(buf+"rotation_z", 0));
  wm.node=node;
  wm.node_debug=node_debug;

  wheels.push_back(wm);
}
3.声音�Q�－�Q��R开动时的蘪鸣声
//load sounds
try {
  snd_engine = new openalpp::Source((ALbyte*)("data/cars/"+profile+"/"+cfg.Getval_str("Sound/Engine/wave")).c_str());
  if (!snd_engine.valid())
   DBGCOUT("ALUT", "Coulnd't load file", ("data/cars/"+profile+"/"+cfg.Getval_str("Sound/Engine/wave")).c_str());
  else {
   snd_engine->setGain(1);
   snd_engine->setPosition(0.0,0.0,0.0);
   snd_engine->setLooping(true);
  }
  snd_engine_pitch_low=cfg.Getval_double("Sound/Engine/pitch_low");
  snd_engine_pitch_high=cfg.Getval_double("Sound/Engine/pitch_high");
} catch(openalpp::Error e) {
  std::cerr << e << "\n";
}

bloodbao 2008-05-08 10:31 发表评论

bloodbao — Thu, 08 May 2008 02:27:00 GMT

ODE常用变量�Q?br>dWorldID world;
dSpaceID space;
dJointGroupID contactgroup;
dBodyID body;
dGeomID geom;
初始化：
void InitODE(){
dInitODE();
world=dWorldCreate();
space=dHashSpaceCreate(0);
contactgroup=dJointGroupCreate(0);
dWorldSetGravity(world,0,-9.8,0);
}
回调函数�Q�计��碰撞点
void nearCallback(void* node, dGeomID o1, dGeomID o2)
{
int i=0;
dBodyID b1=dGeomGetBody(o1);
dBodyID b2=dGeomGetBody(o2);
const int MAX_CONTACTS = 8;
if(b1 && b2 && dAreConnectedExcluding(b1,b2,dJointTypeContact))return;
dContact contact[MAX_CONTACTS];
    for(i=0;i {
    contact[i].surface.mode=dContactBounce | dContactSoftCFM;
    contact[i].surface.mu=100000.0;
    contact[i].surface.mu2=.00001;
    contact[i].surface.bounce=.2;
    contact[i].surface.bounce_vel=.1;
    contact[i].surface.soft_cfm=.0000001;
}
    int numc=dCollide(o1,o2,MAX_CONTACTS,&contact[0].geom,sizeof(dContact));
if(numc>0)
{
    for(i=0;i    {
      dJointID c=dJointCreateContact(world,contactgroup,&contact[i]);
      dJointAttach(c,b1,b2);
    }
}
}
�E�序��d�@�?br>while(device->run())
{
  setPosition(geom);
  dJointGroupEmpty (contactgroup);    //清空��撞点组
  driver->beginScene(true, true, SColor(0,200,200,200));
  dSpaceCollide (space,0,&nearCallback); //通过回调函数计算��撞点等数据
  dWorldQuickStep(world,0.025); //使物理世界随着旉��变化
  smgr->drawAll();
  guienv->drawAll();

driver->endScene();
}

bloodbao 2008-05-08 10:27 发表评论

bloodbao — Thu, 08 May 2008 02:25:00 GMT

概要�Q�雨�_�子每刻的动��M��用输出流�Q�在每一帧都使用geometry Shader扩成billboard.
最后，雨粒子的渲染使用的纹理库存储在一个纹理阵列。��用DX10和GeForce8 �p�d��GPU�?br>1.应用风和重力使粒子一直在作动甅R�?br>2.把粒子扩成要在每一帧渲染的�_��?br>3.渲染�_��
1.�Q?�Q�C++使用输出��?br>//讄��渲染点列表，每个�_�子存一个顶炏V�?br>pd3dDevice->IASetPrimitiveTopology(D3D10_PRIMITIVE_TOPOLOGY_POINTLIST);
pd3dDevice->IASetInputLayout(g_pVertexLayoutRainVertex);
//军_��哪个��点�~�冲我们既将要渲�?br>假如�q�是�W�一帧我们渲染一个预产生的顶点��g_pParticleStart
static bool firstFrame=true;
ID3D10Buffer* pBuffers[1];
if(firstFrame)
  pBuffers[0]=g_pParticleStart;
else
  pBuffers[0]=g_pParticleDrawFrom;
pDevice->IASetVertexBuffers(0,1,pBuffers,stride,offset);
//指向正确的输出缓�?br> pBuffers[0] = g_pParticleStreamTo;
        pd3dDevice->SOSetTargets( 1, pBuffers, offset );

        // ��d��Q��ɾ_�子动画
        D3D10_TECHNIQUE_DESC techDesc;
        g_pTechniqueAdvanceRain->GetDesc( &techDesc );
        g_pTechniqueAdvanceRain->GetPassByIndex(0)->Apply(0);

pd3dDevice->Draw(g_numRainVertices , 0 );

        // Get back to normal
        pBuffers[0] = NULL;
        pd3dDevice->SOSetTargets( 1, pBuffers, offset );

        // Swap buffers交换�~�冲�?br>        ID3D10Buffer* pTemp = g_pParticleDrawFrom;
        g_pParticleDrawFrom = g_pParticleStreamTo;
        g_pParticleStreamTo = pTemp;

        firstFrame = false;
2.�Q?�Q�HLSL�Q�－使用Geometry shader Expanding

GeometryShader gsStreamOut = ConstructGSWithSO( CompileShader( vs_4_0, VSAdvanceRain() ), "POSITION.xyz; SEED.xyz; SPEED.xyz; RAND.x; TYPE.x" );
technique10 AdvanceParticles
{
    pass p0
    {
        SetVertexShader( CompileShader( vs_4_0, VSAdvanceRain() ) );
        SetGeometryShader( gsStreamOut );
        SetPixelShader( NULL );

        SetDepthStencilState( DisableDepth, 0 );
    }
}
�Q?�Q�HLSL�Q�－使用Geometry shader Extruding
// GS for rendering rain as point sprites. Takes a point and turns it into 2 tris.
[maxvertexcount(4)]
void GSRenderRain(point VSParticleIn input[1], inout TriangleStream SpriteStream)
{
    float totalIntensity = g_PointLightIntensity*g_ResponsePointLight + dirLightIntensity*g_ResponseDirLight;
    if(!cullSprite(input[0].pos,2*g_SpriteSize) && totalIntensity > 0)
    {
        PSSceneIn output = (PSSceneIn)0;
        output.type = input[0].Type;
        output.random = input[0].random;

        float3 pos[4];
        GenRainSpriteVertices(input[0].pos.xyz, input[0].speed.xyz/g_FrameRate + g_TotalVel, g_eyePos, pos);

        float3 closestPointLight = g_PointLightPos;
        float closestDistance = length(g_PointLightPos - pos[0]);
        if( length(g_PointLightPos2 - pos[0]) < closestDistance )
           closestPointLight = g_PointLightPos2;

        output.pos = mul( float4(pos[0],1.0), g_mWorldViewProj );
        output.lightDir = g_lightPos - pos[0];
        output.pointLightDir = closestPointLight - pos[0];
        output.eyeVec = g_eyePos - pos[0];
        output.tex = g_texcoords[0];
        SpriteStream.Append(output);

        output.pos = mul( float4(pos[1],1.0), g_mWorldViewProj );
        output.lightDir = g_lightPos - pos[1];
        output.pointLightDir = closestPointLight - pos[1];
        output.eyeVec = g_eyePos - pos[1];
        output.tex = g_texcoords[1];
        SpriteStream.Append(output);

        output.pos = mul( float4(pos[2],1.0), g_mWorldViewProj );
        output.lightDir = g_lightPos - pos[2];
        output.pointLightDir = closestPointLight - pos[2];
        output.eyeVec = g_eyePos - pos[2];
        output.tex = g_texcoords[2];
        SpriteStream.Append(output);

        output.pos = mul( float4(pos[3],1.0), g_mWorldViewProj );
        output.lightDir = g_lightPos - pos[3];
        output.pointLightDir = closestPointLight - pos[3];
        output.eyeVec = g_eyePos - pos[3];
        output.tex = g_texcoords[3];
        SpriteStream.Append(output);

        SpriteStream.RestartStrip();
    }
}

3.
渲染点精�?br>使用DX10新特性Texture Array
渲染�?br>�q�行范例�Q?br>范例昄��两个点光源和一条直��光下的桥�?br>左键控制直射光�?br>

bloodbao 2008-05-08 10:25 发表评论

Race

bloodbao — Tue, 06 May 2008 13:28:00 GMT

bloodbao 2008-05-06 21:28 发表评论

crimson project

bloodbao — Sun, 04 May 2008 07:37:00 GMT

bloodbao 2008-05-04 15:37 发表评论

newton冲突�Q�－�Q�FOR IRRLICHT

bloodbao — Sun, 04 May 2008 04:20:00 GMT

//Function to create a NewtonCollision from irrlicht mesh
NewtonCollision *CreateCollisionFromMesh(NewtonWorld *nWorld, scene::IMesh *mesh)
{
  //Get number of vertices
  u32 nVertices = 0, nMeshBuffer;
  for( nMeshBuffer = 0 ; nMeshBuffer < mesh->getMeshBufferCount(); ++nMeshBuffer)
  {
    scene::IMeshBuffer *buffer = mesh->getMeshBuffer(nMeshBuffer);
    nVertices += buffer->getVertexCount();
  }

  // allocate block for positions of every vertex in mesh, no need to delete
  // anything, the array cleans up for us.
  core::array<core::vector3df> vertices;
  vertices.reallocate(nVertices);

  //Get mesh buffers and copy face vertices
  for( nMeshBuffer = 0 ; nMeshBuffer < mesh->getMeshBufferCount(); ++nMeshBuffer)
  {
    scene::IMeshBuffer *buffer = mesh->getMeshBuffer(nMeshBuffer);

    // handle the irrlicht supported vertex types
    switch(buffer->getVertexType())
    {
    case video::EVT_STANDARD:
      {
        video::S3DVertex* verts = (video::S3DVertex*)buffer->getVertices();
        for(u32 v = 0; v < buffer->getVertexCount(); ++v)
          vertices.push_back(verts[v].Pos);
      }
      break;

    case video::EVT_2TCOORDS:
      {
        video::S3DVertex2TCoords* verts = (video::S3DVertex2TCoords*)buffer->getVertices();
        for(u32 v = 0; v < buffer->getVertexCount(); ++v)
          vertices.push_back(verts[v].Pos);
      }
      break;

    case video::EVT_TANGENTS:
      {
        video::S3DVertexTangents* verts = (video::S3DVertexTangents*)buffer->getVertices();
        for(u32 v = 0; v < buffer->getVertexCount(); ++v)
          vertices.push_back(verts[v].Pos);
      }
      break;

    default:
      return 0; // don't know vertex type! bail.
    }
  }

  //Create Newton collision object
  return NewtonCreateConvexHull(nWorld, nVertices, &vertices[0].X, sizeof(core::vector3df), NULL);
}

core::array<f32> vertices;
vertices.reallocate(nVertices * 3);

// each loop should be updated
for(u32 v = 0; v < buffer->getVertexCount(); ++v)
{
  vertices.push_back(verts[v].Pos.X);
  vertices.push_back(verts[v].Pos.Y);
  vertices.push_back(verts[v].Pos.Z);
}

// this should be passed to the convex hull function
return NewtonCreateConvexHull(nWorld, nVertices, &vertices[0], sizeof(f32 * 3), NULL);

bloodbao 2008-05-04 12:20 发表评论

bloodbao — Sun, 04 May 2008 04:17:00 GMT

IRRLICHT的实玎ͼ�
1.波浪是如何实现的�Q?br>先对每个点计��高度，

void addWave(vector3df& dest, const vector3df source, f32 time)
{
dest.Y = source.Y +
(sinf(((source.X/WaveLength) + time)) * WaveHeight) +
(cosf(((source.Z/WaveLength) + time)) * WaveHeight);
}

然后再计��法�U�，
recalculateNormals(Mesh);
2.ATMOSphere
太阳嘛，��是个跟随时间移动的BILLBOARD,边缘最好加上雾化效果�?br>3.地�Ş�~�辑器代�?br>

if( Terrain && !RightMouseDown && Terrain->getTriangleSelector() )
{
LastMousePosition.set( Device->getCursorControl()->getPosition().X, Device->   getCursorControl()->getPosition().Y );
//计算从鼠标位�|�到观察点的��线
core::line3df line = CollisionMgr->getRayFromScreenCoordinates(
core::position2d<s32>( LastMousePosition.X, LastMousePosition.Y ) );
//计算以交点�ؓ中心�Q�一定半径范围内的点
core::vector3df spherePosition;
if( CollisionMgr->getClosestVertex( line, Terrain->getTriangleSelector(),
spherePosition, CurrentVertexIndex ) )
      {
       LeftMouseDown = true;

       // Get all vertices with the circle
       SelectedTerrainVertices.clear();
       core::vector3df intersection;
       scene::SCollisionTriangle tri;
       if( CollisionMgr->getCollisionPoint( line, Terrain->getTriangleSelector(), intersection, tri ) )
       {
        u32 count = 0;
        SelectedTerrainVertices.reallocate( Terrain->getTriangleSelector()->getTriangleCount() );
        Terrain->getTriangleSelector()->getVerticesInRadius( SelectedTerrainVertices.pointer(), Terrain->getTriangleSelector()->getTriangleCount(), count, intersection, RedCircleRadius );
        SelectedTerrainVertices.set_used( count );
       }

       return true;
      }
     }

bloodbao 2008-05-04 12:17 发表评论

ATMOSphere----日夜循环

bloodbao — Thu, 01 May 2008 08:40:00 GMT

bloodbao 2008-05-01 16:40 发表评论

VolumeLightSceneNode

bloodbao — Thu, 01 May 2008 03:16:00 GMT

bloodbao 2008-05-01 11:16 发表评论

bloodbao — Wed, 30 Apr 2008 11:22:00 GMT

现将场景�~�辑器测试版上传�Q�望�q�大朋友��试�Q�多谢！
�l�过一周的改写�Q�完成部分功能，�q�个版本非完全版�?br>下蝲地址�Q?a >http://pickup.mofile.com/7877768148587694
�׃�n提取码：7877768148587694
囄��在本博客都有�Q?br>VISTA下测试通过�Q?br>嗯，昑֍�臛_��要DX9吧，下一阶段把草圎ͼ�水面�Q�碰撞补齐！

bloodbao 2008-04-30 19:22 发表评论