Ogre 相关老代码-- 第一部分

// CattonShading.cg
void vs_main(
 
 in float4 pos : POSITION,
 in float4 norm : NORMAL,
 in float2 uv   : TEXCOORD0,
 uniform   float4x4 worldMat,
 uniform   float4x4 viewProjMat,
 uniform   float4   eyePos,
 
 out float4 oPos : POSITION,
 out float4 oColor : COLOR0,
 out float2 oUv    : TEXCOORD0
)
{
 float4 wPos = mul(worldMat, pos);
 oPos = mul(viewProjMat, wPos);
 oUv = uv;
 norm = mul( worldMat, norm );
 float4 dir = eyePos - wPos;
 dir = normalize(dir); 
 float d = dot(norm, dir);
 if (d > 0.66) d = 0.66;
 else if (d > 0.33) d = 0.33;
 else d = 0;
 
 d += 0.2;
 
 oColor = float4(d, d, d, 1); 
 
}

void ps_main(
 in float2 uv : TEXCOORD0,
 in float4 color : COLOR0,
 uniform sampler2D tex : TEXUNIT0,
 out float4 oColor : COLOR0
 ) 
{
 oColor = tex2D( tex, uv ) * color;
}

 

//######################################################################

// CattonShading.material
 
vertex_program CatoonShading_vs cg
{
 source CatoonShading.cg
 profiles vs_3_0
 entry_point vs_main
 default_params
 {
  param_named_auto   worldMat            world_matrix
  param_named_auto   viewProjMat         viewproj_matrix
  param_named_auto   eyePos              camera_position
 } 
}

fragment_program CatoonShading_ps cg
{
 source CatoonShading.cg
 profiles ps_3_0
 entry_point ps_main
 default_params
 {
 }
}

material Ogre/Earring_Catoon
{
 technique
 {
  pass
  {
   ambient 0.7 0.7 0
   diffuse 0.7 0.7 0
   
   vertex_program_ref CatoonShading_vs{}
   fragment_program_ref CatoonShading_ps{}

   texture_unit
   {
    texture spheremap.png
    colour_op_ex add src_texture src_current
    colour_op_multipass_fallback one one
    env_map spherical
   }
  }
 }
}

material Ogre/Skin_Catoon
{
 technique
 {
  pass
  {
   ambient 0.3 0.8 0.3
   vertex_program_ref CatoonShading_vs{}
   fragment_program_ref CatoonShading_ps{}

   texture_unit
   {
    texture GreenSkin.jpg
    tex_address_mode mirror
   }
  }
 }
}

material Ogre/Tusks_Catoon
{
 technique
 {
  pass
  {
   ambient 0.7 0.7 0.6
   vertex_program_ref CatoonShading_vs{}
   fragment_program_ref CatoonShading_ps{}

   texture_unit
   {
    texture tusk.jpg
    scale 0.2 0.2
   }
  }
 }
}

material Ogre/Eyes_Catoon
{
 technique
 {
  pass
  {
   ambient 1 0.4 0.4
   diffuse 1 0.7 0
   emissive 0.3 0.1 0
  }
 }
}

 

//##################################################################

//ssao.material

    ///

    vertex_program Mix_AmbientOcclusion_vs cg
    {
        source 1_Mix_AmbientOcclusion.cg
        profiles vs_2_x vp40 arbvp1
        entry_point Mix_AmbientOcclusion_vs

        default_params
        {
            param_named_auto   wvpMat            worldviewproj_matrix
        }
    }

    fragment_program Mix_AmbientOcclusion_ps cg
    {
        source 1_Mix_AmbientOcclusion.cg
        profiles ps_2_x fp40 arbfp1
        entry_point Mix_AmbientOcclusion_ps

        default_params
        {
             param_named_auto TexSize texture_size 0
        }
    }

    ///

    material Mix_AmbientOcclusion
    {
       technique
       {
           pass
           {
                      //scene_blend add

                ambient  0 0 0
                diffuse  0 0 0
                specular 0 0 0 0
                emissive 0 0 0

                vertex_program_ref Mix_AmbientOcclusion_vs
                {
                }

                fragment_program_ref Mix_AmbientOcclusion_ps
                {
                }

                      texture_unit
                      {
                         texture RttTex_DfShNormal
                         filtering none
                         tex_address_mode clamp
                      }

                      texture_unit
                      {
                         texture RttTex_DfShPosition
                         filtering none
                         tex_address_mode clamp
                      }

                      texture_unit
                      {
                         texture randomnormals.png
                      }

                     
           }
       }

    }
//###############################################################

// 1_Mix_AmbientOcclusion.cg

    /
    // Expand a range-compressed vector

    float3 expand(float3 v)
    {
       return (v - 0.5) * 2;
    }

    // compress a normalized vector
    float3 compress(float3 v)
    {
       return (v * 0.5) + 0.5 ;
    }

 

   
    // connector structures

    struct VIn {
        float4 p    : POSITION;
        float2 uv   : TEXCOORD0;
    };

    struct  VOut {
        float4 p    : POSITION;
        float2 uv   : TEXCOORD0;
    };

 

    /
    // vertex program

    VOut Mix_AmbientOcclusion_vs(     
          VIn IN,
        uniform float4x4 wvpMat
          )
    {
        VOut OUT;
      
          OUT.p = mul(wvpMat, IN.p);
        OUT.uv.xy = IN.uv;

        return OUT;
    }

    //
    // SSAO based on http://www.gamedev.net/reference/programming/features/simpleSSAO/ by José María Méndez, MIT license

 

 

    float3 getPosition(sampler2D g_buffer_pos, in float2 uv)
    {
    return tex2D(g_buffer_pos,uv).xyz;
    }

    float3 getNormal(sampler2D g_buffer_norm, in float2 uv)
    {
       return=tex2D(g_buffer_norm, uv).xyz ;
    }

 

 

    float doAmbientOcclusion(sampler2D g_buffer_pos, float2 tcoord,in float2 uv, in float3 p, in float3 cnorm)
    {
       float g_intensity=128;
       float g_scale=1.0;
       float g_bias=0.0;

    float3 diff = getPosition(g_buffer_pos, tcoord + uv) - p;
    const float3 v = normalize(diff);
    const float d = length(diff)*g_scale;
       return max(0.0,dot(cnorm,v)-g_bias)*(1.0/(1.0+d))*g_intensity;

      
    }

    void Mix_AmbientOcclusion_ps(   VOut IN,
                            uniform float4 TexSize,
                            out float4 colour : COLOR,
                            uniform sampler2D Tex_Norm   : TEXUNIT0,
                            uniform sampler2D Tex_Pos         : TEXUNIT1,
                            uniform sampler2D Tex_Rand      : TEXUNIT2
    )
    {

    const float2 vec[4] = {
                                           float2(1,0),
                                           float2(-1,0),
                                           float2(0,1),
                                           float2(0,-1)
                                        };

       float4 Pos= tex2D(Tex_Pos, IN.uv);
    float3 p = Pos.xyz;
    float3 n = getNormal(Tex_Norm, IN.uv);

    float2 rand = normalize(tex2D(Tex_Rand, TexSize * IN.uv / 64.0).xy * 2.0f - 1.0f) ;

    float ao = 0.0f;
       float g_sample_rad=32.0 ;
    float rad = g_sample_rad/p.z;

 

    int iterations = 4;
    for (int j = 0; j < iterations; ++j)
    {
      float2 coord1 = reflect(vec[j],rand)*rad;
      float2 coord2 = float2(coord1.x*0.707 - coord1.y*0.707, coord1.x*0.707 + coord1.y*0.707);
    
      ao += doAmbientOcclusion(Tex_Pos, IN.uv,coord1*0.25, p, n);
      ao += doAmbientOcclusion(Tex_Pos, IN.uv,coord2*0.5, p, n);
      ao += doAmbientOcclusion(Tex_Pos, IN.uv,coord1*0.75, p, n);
      ao += doAmbientOcclusion(Tex_Pos, IN.uv,coord2, p, n);
    }
    ao/=(float)iterations*4.0;

      
       ao=1-ao ;

    //Do stuff here with your occlusion value “ao”: modulate ambient lighting, write it to a buffer for later //use, etc.
       colour=float4(ao,ao,ao, 1) ;
    }

 

//#######################################################################

    // WARNING: modified by Jacob 'jacmoe' Moen
    // Ported to Ogre3D
    /* * * * * * * * * * * * * Author's note * * * * * * * * * * * */
    *   _       _   _       _   _       _   _       _     _ _ _ _   *
    *  |_|     |_| |_|     |_| |_|_   _|_| |_|     |_|  _|_|_|_|_|  *
    *  |_|_ _ _|_| |_|     |_| |_|_|_|_|_| |_|     |_| |_|_ _ _     *
    *  |_|_|_|_|_| |_|     |_| |_| |_| |_| |_|     |_|   |_|_|_|_   *
    *  |_|     |_| |_|_ _ _|_| |_|     |_| |_|_ _ _|_|  _ _ _ _|_|  *
    *  |_|     |_|   |_|_|_|   |_|     |_|   |_|_|_|   |_|_|_|_|    *
    *                                                               *
    *                     http://www.humus.name                     *
    *                                                                *
    * This file is a part of the work done by Humus. You are free to   *
    * use the code in any way you like, modified, unmodified or copied   *
    * into your own work. However, I expect you to respect these points:  *
    *  - If you use this file and its contents unmodified, or use a major *
    *    part of this file, please credit the author and leave this note. *
    *  - For use in anything commercial, please request my approval.     *
    *  - Share your work and ideas too as much as you can.             *
    *                                                                *
    /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

    #ifndef _BSP_H_
    #define _BSP_H_

    #include "Ogre.h"

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <float.h>
    #include <stddef.h>

    #if _MSC_VER >= 1400
    // To make MSVC 2005 happy
    #pragma warning (disable: 4996)
    #  define assume(x) __assume(x)
    #  define no_alias __declspec(noalias)
    #else
    #  define assume(x)
    #  define no_alias
    #endif

    // Define some sized types
    typedef unsigned char uint8;
    typedef   signed char  int8;

    typedef unsigned short uint16;
    typedef   signed short  int16;

    typedef unsigned int uint32;
    typedef   signed int  int32;

    #ifdef _WIN32
       typedef   signed __int64  int64;
       typedef unsigned __int64 uint64;
    #else
       typedef   signed long long  int64;
       typedef unsigned long long uint64;
    #endif

    typedef unsigned char ubyte;
    typedef unsigned short ushort;
    typedef unsigned int uint;

    template <class TYPE>
    class Array {
    public:
       Array(){
          count = capacity = 0;
          list = NULL;
       }

       Array(const unsigned int iCapasity){
          count = 0;
          capacity = iCapasity;
          list = (TYPE *) malloc(capacity * sizeof(TYPE));
       }
      
       ~Array(){
          free(list);
       }

       TYPE *getArray() const { return list; }
       TYPE *abandonArray(){
          TYPE *rList = list;
          list = NULL;
          return rList;
       }

       TYPE &operator [] (const unsigned int index) const { return list[index]; }
       unsigned int getCount() const { return count; }

       void setCount(const unsigned int newCount){
          capacity = count = newCount;
          list = (TYPE *) realloc(list, capacity * sizeof(TYPE));
       }

       unsigned int add(const TYPE object){
          if (count >= capacity){
             if (capacity) capacity += capacity; else capacity = 8;
             list = (TYPE *) realloc(list, capacity * sizeof(TYPE));
          }
          list[count] = object;
          return count++;
       }

       void fastRemove(const unsigned int index){
          if (index < count){
             count--;
             list[index] = list[count];
          }
       }

       void orderedRemove(const unsigned int index){
          if (index < count){
             count--;
             memmove(list + index, list + index + 1, (count - index) * sizeof(TYPE));
          }
       }

       void clear(){
          count = 0;
       }

       void reset(){
          free(list);
          list = NULL;
          count = capacity = 0;
       }

    private:
       int partition(int (*compare)(const TYPE &elem0, const TYPE &elem1), int p, int r){
          TYPE tmp, pivot = list[p];
          int left = p;

          for (int i = p + 1; i <= r; i++){
             if (compare(list[i], pivot) < 0){
                left++;
                tmp = list[i];
                list[i] = list[left];
                list[left] = tmp;
             }
          }
          tmp = list[p];
          list[p] = list[left];
          list[left] = tmp;
          return left;
       }

       void quickSort(int (*compare)(const TYPE &elem0, const TYPE &elem1), int p, int r){
          if (p < r){
             int q = partition(compare, p, r);
             quickSort(compare, p, q - 1);
             quickSort(compare, q + 1, r);
          }
       }
    public:
       void sort(int (*compare)(const TYPE &elem0, const TYPE &elem1)){
          quickSort(compare, 0, count - 1);
       }
    protected:
       unsigned int capacity;
       unsigned int count;
       TYPE *list;
    };

    struct BTri {
       void split(BTri *dest, int &nPos, int &nNeg, const Ogre::Vector4 &plane, const float epsilon) const;
       void finalize();

       bool intersects(const Ogre::Vector3 &v0, const Ogre::Vector3 &v1) const;

       bool isAbove(const Ogre::Vector3 &pos) const;
 
       float getDistance(const Ogre::Vector3 &pos) const;

       Ogre::Vector4 plane;
       Ogre::Vector4 edgePlanes[3];

       Ogre::Vector3 v[3];
    /*
       Ogre::Vector3 edgeNormals[3];
       float edgeOffsets[3];
       Ogre::Vector3 normal;
       float offset;
    */
       void *data;
    };

    struct BNode {
       ~BNode();

       bool intersects(const Ogre::Vector3 &v0, const Ogre::Vector3 &v1, const Ogre::Vector3 &dir, Ogre::Vector3 *point, const BTri **triangle) const;
       BTri *intersectsCached(const Ogre::Vector3 &v0, const Ogre::Vector3 &v1, const Ogre::Vector3 &dir) const;
 

    bool pushSphere(Ogre::Vector3 &pos, const float radius) const;
       void getDistance(const Ogre::Vector3 &pos, float &minDist) const;

       void build(Array <BTri> &tris, const int splitCost, const int balCost, const float epsilon);
       //void build(Array <BTri> &tris);

       void read(FILE *file);
       void write(FILE *file) const;

      
       BNode *back;
       BNode *front;

       BTri tri;
    };

 

    class BSP {
    public:
       BSP(){
          top = NULL;
 
          cache = NULL;
       }
       ~BSP(){
 
          delete top;
       }

       void addTriangle(const Ogre::Vector3 &v0, const Ogre::Vector3 &v1, const Ogre::Vector3 &v2, void *data = NULL);
       void build(const int splitCost = 3, const int balCost = 1, const float epsilon = 0.001f);

       bool intersects(const Ogre::Vector3 &v0, const Ogre::Vector3 &v1, Ogre::Vector3 *point = NULL, const BTri **triangle = NULL) const;
       bool intersectsCached(const Ogre::Vector3 &v0, const Ogre::Vector3 &v1);
 

       bool pushSphere(Ogre::Vector3 &pos, const float radius) const;
       float getDistance(const Ogre::Vector3 &pos) const;

       bool isInOpenSpace(const Ogre::Vector3 &pos) const;
   
       bool loadFile(const char *fileName);
       bool saveFile(const char *fileName) const;

    protected:
       Array <BTri> tris;
       BNode *top;
       BTri *cache;
    };

    #endif // _BSP_H_

 

//###########################################################################

    // WARNING: modified by Jacob 'jacmoe' Moen
    // Ported to Ogre3D
    /* * * * * * * * * * * * * Author's note * * * * * * * * * * * */
    *   _       _   _       _   _       _   _       _     _ _ _ _   *
    *  |_|     |_| |_|     |_| |_|_   _|_| |_|     |_|  _|_|_|_|_|  *
    *  |_|_ _ _|_| |_|     |_| |_|_|_|_|_| |_|     |_| |_|_ _ _     *
    *  |_|_|_|_|_| |_|     |_| |_| |_| |_| |_|     |_|   |_|_|_|_   *
    *  |_|     |_| |_|_ _ _|_| |_|     |_| |_|_ _ _|_|  _ _ _ _|_|  *
    *  |_|     |_|   |_|_|_|   |_|     |_|   |_|_|_|   |_|_|_|_|    *
    *                                                               *
    *                     http://www.humus.name                     *
    *                                                                *
    * This file is a part of the work done by Humus. You are free to   *
    * use the code in any way you like, modified, unmodified or copied   *
    * into your own work. However, I expect you to respect these points:  *
    *  - If you use this file and its contents unmodified, or use a major *
    *    part of this file, please credit the author and leave this note. *
    *  - For use in anything commercial, please request my approval.     *
    *  - Share your work and ideas too as much as you can.             *
    *                                                                *
    /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

    #include "BSP.h"

    #ifdef _WIN32
    #pragma warning(push, 1)
    #pragma warning(disable: 4799)
    #endif

    float planeDistance(const Ogre::Vector3 &normal, const float offset, const Ogre::Vector3 &point){
        return point.x * normal.x + point.y * normal.y + point.z * normal.z + offset;
    }

    float planeDistance(const Ogre::Vector4 &plane, const Ogre::Vector3 &point){
        return point.x * plane.x + point.y * plane.y + point.z * plane.z + plane.w;
    }

    float dot(const Ogre::Vector3 &u, const Ogre::Vector3 &v){
       return u.x * v.x + u.y * v.y + u.z * v.z;
    }

    float dot(const Ogre::Vector4 &u, const Ogre::Vector4 &v){
       return u.x * v.x + u.y * v.y + u.z * v.z + u.w * v.w;
    }
    //#  define no_alias

    no_alias Ogre::Vector3 planeHit(const Ogre::Vector3 &v0, const Ogre::Vector3 &v1, const Ogre::Vector4 &plane){
       Ogre::Vector3 dir = v1 - v0;
       float d = planeDistance(plane, v0);
       Ogre::Vector3 pos = v0 - (d / dot((Ogre::Vector3 &) plane, dir)) * dir;

       return pos;
    }

    void BTri::split(BTri *dest, int &nPos, int &nNeg, const Ogre::Vector4 &plane, const float epsilon) const {
       float d[3];
       for (int i = 0; i < 3; i++){
          d[i] = planeDistance(plane, v[i]);
       }

       int first  = 2;
       int second = 0;
       while (!(d[second] > epsilon && d[first] <= epsilon)){
          first = second;
          second++;
       }

       // Positive triangles
       nPos = 0;
       Ogre::Vector3 h = planeHit(v[first], v[second], plane);
       do {
          first = second;
          second++;
          if (second >= 3) second = 0;

          dest->v[0] = h;
          dest->v[1] = v[first];
          if (d[second] > epsilon){
             dest->v[2] = v[second];
          } else {
             dest->v[2] = h = planeHit(v[first], v[second], plane);
          }

          dest->data = data;
          dest->finalize();
          dest++;
          nPos++;
       } while (d[second] > epsilon);

       // Skip zero area triangle
       if (fabsf(d[second]) <= epsilon){
          first = second;
          second++;
          if (second >= 3) second = 0;
       }

       // Negative triangles
       nNeg = 0;
       do {
          first = second;
          second++;
          if (second >= 3) second = 0;

          dest->v[0] = h;
          dest->v[1] = v[first];
          if (d[second] < -epsilon){
             dest->v[2] = v[second];
          } else {
             dest->v[2] = planeHit(v[first], v[second], plane);
          }

          dest->data = data;
          dest->finalize();
          dest++;
          nNeg++;
       } while (d[second] < -epsilon);
    }

    Ogre::Vector3 normalize(const Ogre::Vector3 &v){
       float invLen = 1.0f / sqrtf(v.x * v.x + v.y * v.y + v.z * v.z);
       return v * invLen;
    }

    Ogre::Vector4 normalize(const Ogre::Vector4 &v){
       float invLen = 1.0f / sqrtf(v.x * v.x + v.y * v.y + v.z * v.z + v.w * v.w);
       return v * invLen;
    }

    Ogre::Vector3 cross(const Ogre::Vector3 &u, const Ogre::Vector3 &v){
       return Ogre::Vector3(u.y * v.z - v.y * u.z, u.z * v.x - u.x * v.z, u.x * v.y - u.y * v.x);
    }

    void BTri::finalize(){
       Ogre::Vector3 normal = normalize(cross(v[1] - v[0], v[2] - v[0]));
       float offset = -dot(v[0], normal);

        Ogre::Vector3 edgeNormals[3];
       edgeNormals[0] = cross(normal, v[0] - v[2]);
       edgeNormals[1] = cross(normal, v[1] - v[0]);
       edgeNormals[2] = cross(normal, v[2] - v[1]);

       float edgeOffsets[3];
       edgeOffsets[0] = dot(edgeNormals[0], v[0]);
       edgeOffsets[1] = dot(edgeNormals[1], v[1]);
       edgeOffsets[2] = dot(edgeNormals[2], v[2]);

       plane = Ogre::Vector4(normal.x, normal.y, normal.z, offset);
       edgePlanes[0] = Ogre::Vector4(edgeNormals[0].x, edgeNormals[0].y, edgeNormals[0].z, -edgeOffsets[0]);
       edgePlanes[1] = Ogre::Vector4(edgeNormals[1].x, edgeNormals[1].y, edgeNormals[1].z, -edgeOffsets[1]);
       edgePlanes[2] = Ogre::Vector4(edgeNormals[2].x, edgeNormals[2].y, edgeNormals[2].z, -edgeOffsets[2]);
    }

    no_alias bool BTri::intersects(const Ogre::Vector3 &v0, const Ogre::Vector3 &v1) const {
       Ogre::Vector3 dir = v0 - v1;
    //   float k = (dot(normal, v0) + offset) / dot(normal, dir);
       float k = planeDistance(plane, v0) / dot(Ogre::Vector3(plane.x, plane.y, plane.z), dir);

       if (k < 0 || k > 1) return false;

       Ogre::Vector3 pos = v0 - k * dir;

       for (unsigned int i = 0; i < 3; i++){
          if (planeDistance(edgePlanes[i], pos) < 0){
    //      if (dot(edgeNormals[i], pos) < edgeOffsets[i]){
             return false;
          }
       }
       return true;
    }

    no_alias bool BTri::isAbove(const Ogre::Vector3 &pos) const {
    /*
       return (edgeNormals[0].x * pos.x + edgeNormals[0].y * pos.y + edgeNormals[0].z * pos.z >= edgeOffsets[0] &&
             edgeNormals[1].x * pos.x + edgeNormals[1].y * pos.y + edgeNormals[1].z * pos.z >= edgeOffsets[1] &&
             edgeNormals[2].x * pos.x + edgeNormals[2].y * pos.y + edgeNormals[2].z * pos.z >= edgeOffsets[2]);
    */
    /*
       return (edgePlanes[0].x * pos.x + edgePlanes[0].y * pos.y + edgePlanes[0].z * pos.z >= -edgePlanes[0].w &&
             edgePlanes[1].x * pos.x + edgePlanes[1].y * pos.y + edgePlanes[1].z * pos.z >= -edgePlanes[1].w &&
             edgePlanes[2].x * pos.x + edgePlanes[2].y * pos.y + edgePlanes[2].z * pos.z >= -edgePlanes[2].w);
    */
       return (planeDistance(edgePlanes[0], pos) >= 0 && planeDistance(edgePlanes[1], pos) >= 0 && planeDistance(edgePlanes[2], pos) >= 0);
    }

    no_alias float BTri::getDistance(const Ogre::Vector3 &pos) const {
       int k = 2;
       for (int i = 0; i < 3; i++){
          float d = planeDistance(edgePlanes[i], pos);
          if (d < 0){
             // Project onto the line between the points
             Ogre::Vector3 dir = v[i] - v[k];
             float c = dot(dir, pos - v[k]) / dot(dir, dir);

             Ogre::Vector3 d;
             if (c >= 1){
                d = v[i];
             } else {
                d = v[k];
                if (c > 0) d += c * dir;
             }

                return Ogre::Vector3(pos - d).length();
          }

          k = i;
       }

       return fabsf(planeDistance(plane, pos));
    }

    #ifdef USE_SIMD
    bool BTri::isAbove3DNow(v2sf v0XY, v2sf v0Z1) const {
       for (int i = 0; i < 3; i++){
          v2sf planeXY = ((v2sf *) &edgePlanes[i])[0];
          v2sf planeZD = ((v2sf *) &edgePlanes[i])[1];

          v2sf dotXY = pfmul(planeXY, v0XY);
          v2sf dotZD = pfmul(planeZD, v0Z1);
          v2sf dot = pfacc(dotXY, dotZD);
          dot = pfacc(dot, dot);

          int d = _m_to_int(dot);
          if (d < 0) return false;
       }

       return true;
    }
    #endif

    BNode::~BNode(){
        delete back;
       delete front;
    }

    no_alias bool BNode::intersects(const Ogre::Vector3 &v0, const Ogre::Vector3 &v1,
        const Ogre::Vector3 &dir, Ogre::Vector3 *point, const BTri **triangle) const {
    #if 0
       float d0 = planeDistance(tri.plane, v0);
       float d1 = planeDistance(tri.plane, v1);

       vec3 pos;
       if (d0 > 0){
          if (d1 <= 0){
             pos = v0 - (d0 / dot(tri.plane.xyz(), dir)) * dir;
          }

          if (front != NULL && front->intersects(v0, (d1 <= 0)? pos : v1, dir, point, triangle)) return true;

          if (d1 <= 0){
             if (tri.isAbove(pos)){
                if (point) *point = pos;
                if (triangle) *triangle = &tri;
                return true;
             }
             if (back != NULL && back->intersects(pos, v1, dir, point, triangle)) return true;
          }
       } else {
          if (d1 > 0){
             pos = v0 - (d0 / dot(tri.plane.xyz(), dir)) * dir;
          }

          if (back != NULL && back->intersects(v0, (d1 > 0)? pos : v1, dir, point, triangle)) return true;

          if (d1 > 0){
             if (tri.isAbove(pos)){
                if (point) *point = pos;
                if (triangle) *triangle = &tri;
                return true;
             }
             if (front != NULL && front->intersects(pos, v1, dir, point, triangle)) return true;
          }
       }

    #else
       float d = planeDistance(tri.plane, v0);

       if (d > 0){
          if (front != NULL && front->intersects(v0, v1, dir, point, triangle)) return true;
          if (planeDistance(tri.plane, v1) < 0){
             Ogre::Vector3 pos = v0 - (d / dot(Ogre::Vector3(tri.plane.x,tri.plane.y,tri.plane.z), dir)) * dir;
             if (tri.isAbove(pos)){
                if (point) *point = pos;
                if (triangle) *triangle = &tri;
                return true;
             }
             if (back != NULL && back->intersects(v0, v1, dir, point, triangle)) return true;
          }
       } else {
          if (back != NULL && back->intersects(v0, v1, dir, point, triangle)) return true;
          if (planeDistance(tri.plane, v1) > 0){
             Ogre::Vector3 pos = v0 - (d / dot(Ogre::Vector3(tri.plane.x,tri.plane.y,tri.plane.z), dir)) * dir;
             if (tri.isAbove(pos)){
                if (point) *point = pos;
                if (triangle) *triangle = &tri;
                return true;
             }
             if (front != NULL && front->intersects(v0, v1, dir, point, triangle)) return true;
          }
       }
    #endif

       return false;
    }

    no_alias BTri *BNode::intersectsCached(const Ogre::Vector3 &v0, const Ogre::Vector3 &v1, const Ogre::Vector3 &dir) const {
    #if 0
       float d0 = planeDistance(tri.plane, v0);
       float d1 = planeDistance(tri.plane, v1);

       vec3 pos;

       if (d0 > 0){
          if (d1 <= 0){
             pos = v0 - (d0 / dot((vec3 &) tri.plane, dir)) * dir;
          }

          if (front != NULL){
             BTri *tri;
             if (d1 <= 0){
                tri = front->intersectsCached(v0, pos, dir);
             } else {
                tri = front->intersectsCached(v0, v1, dir);
             }
             if (tri) return tri;
          }

          if (d1 <= 0){
             if (tri.isAbove(pos)) return (BTri *) &tri;
             if (back != NULL){
                BTri *tri = back->intersectsCached(pos, v1, dir);
                if (tri) return tri;
             }
          }
       } else {
          if (d1 > 0){
             pos = v0 - (d0 / dot((vec3 &) tri.plane, dir)) * dir;
          }
          if (back != NULL){
             BTri *tri;
             if (d1 > 0){
                tri = back->intersectsCached(v0, pos, dir);
             } else {
                tri = back->intersectsCached(v0, v1, dir);
             }
             if (tri) return tri;
          }
          if (d1 > 0){
             if (tri.isAbove(pos)) return (BTri *) &tri;
             if (front != NULL){
                BTri *tri = front->intersectsCached(pos, v1, dir);
                if (tri) return tri;
             }
          }
       }

    #else

       float d = planeDistance(tri.plane, v0);

       if (d > 0){
          if (front != NULL){
             BTri *tri = front->intersectsCached(v0, v1, dir);
             if (tri) return tri;
          }
          if (planeDistance(tri.plane, v1) < 0){
             Ogre::Vector3 pos = v0 - (d / dot(Ogre::Vector3(tri.plane.x,tri.plane.y,tri.plane.z), dir)) * dir;
             if (tri.isAbove(pos)) return (BTri *) &tri;
             if (back != NULL){
                BTri *tri = back->intersectsCached(v0, v1, dir);
                if (tri) return tri;
             }
          }
       } else {
          if (back != NULL){
             BTri *tri = back->intersectsCached(v0, v1, dir);
             if (tri) return tri;
          }
          if (planeDistance(tri.plane, v1) > 0){
             Ogre::Vector3 pos = v0 - (d / dot(Ogre::Vector3(tri.plane.x,tri.plane.y,tri.plane.z), dir)) * dir;
             if (tri.isAbove(pos)) return (BTri *) &tri;
             if (front != NULL){
                BTri *tri = front->intersectsCached(v0, v1, dir);
                if (tri) return tri;
             }
          }
       }
    #endif

       return NULL;
    }

 

    no_alias bool BNode::pushSphere(Ogre::Vector3 &pos, const float radius) const {
       float d = planeDistance(tri.plane, pos);

       bool pushed = false;
       if (fabsf(d) < radius){
          if (tri.isAbove(pos)){
    //         pos += (radius - d) * tri.normal;
             pos += (radius - d) * Ogre::Vector3(tri.plane.x,tri.plane.y,tri.plane.z);
             pushed = true;
          }
       }

       if (front != NULL && d > -radius) pushed |= front->pushSphere(pos, radius);
       if (back  != NULL && d <  radius) pushed |= back ->pushSphere(pos, radius);

       return pushed;
    }

    no_alias void BNode::getDistance(const Ogre::Vector3 &pos, float &minDist) const {
       float d = planeDistance(tri.plane, pos);

       float dist = tri.getDistance(pos);
       if (dist < minDist){
          minDist = dist;
       }
      
       if (back && d < minDist){
          back->getDistance(pos, minDist);     
       }

       if (front && -d < minDist){
          front->getDistance(pos, minDist);
       }
    }

    void BNode::read(FILE *file){
       fread(&tri.v, sizeof(tri.v), 1, file);
       tri.finalize();

       int flags = 0;
       fread(&flags, sizeof(int), 1, file);
       if (flags & 1){
          back = new BNode;
          back->read(file);
       } else back = NULL;
       if (flags & 2){
          front = new BNode;
          front->read(file);
       } else front = NULL;
    }

    void BNode::write(FILE *file) const {
       fwrite(&tri.v, sizeof(tri.v), 1, file);
       int flags = 0;
       if (back) flags |= 1;
       if (front) flags |= 2;
       fwrite(&flags, sizeof(int), 1, file);
       if (back) back->write(file);
       if (front) front->write(file);
    }
    /*
    void BNode::build(Array <BTri> &tris){
       uint index = 0;
       int minScore = 0x7FFFFFFF;
       for (uint i = 0; i < tris.getCount(); i++){
          int score = 0;
          int diff = 0;
          for (uint k = 0; k < tris.getCount(); k++){
             uint neg = 0, pos = 0;
             for (uint j = 0; j < 3; j++){
    //            float dist = dot(tris[k].v[j], tris[i].normal) + tris[i].offset;
                float dist = planeDistance(tris[i].plane, tris[k].v[j]);
                if (dist < 0) neg++; else pos++;
             }
             if (pos){
                if (neg) score += 3; else diff++;
             } else diff--;
          }
          score += abs(diff);
          if (score < minScore){
             minScore = score;
             index = i;
          }
       }
       tri = tris[index];
       tris.fastRemove(index);

       Array <BTri> backTris;
       Array <BTri> frontTris;
       for (uint i = 0; i < tris.getCount(); i++){
          uint neg = 0, pos = 0;
          for (uint j = 0; j < 3; j++){
    //         float dist = dot(tris[i].v[j], tri.normal) + tri.offset;
             float dist = planeDistance(tri.plane, tris[i].v[j]);
                if (dist < 0) neg++; else pos++;
          }
          if (neg) backTris.add(tris[i]);
          if (pos) frontTris.add(tris[i]);
       }
       //tris.clear();

       if (backTris.getCount() > 0){
          back = new BNode;
          back->build(backTris);
       } else back = NULL;

       if (frontTris.getCount() > 0){
          front = new BNode;
          front->build(frontTris);
       } else front = NULL;
    }
    */

    void BNode::build(Array <BTri> &tris, const int splitCost, const int balCost, const float epsilon){
       uint index = 0;
       int minScore = 0x7FFFFFFF;

       for (uint i = 0; i < tris.getCount(); i++){
          int score = 0;
          int diff = 0;
          for (uint k = 0; k < tris.getCount(); k++){
             uint neg = 0, pos = 0;
             for (uint j = 0; j < 3; j++){
                float dist = planeDistance(tris[i].plane, tris[k].v[j]);
                if (dist < -epsilon) neg++; else
                if (dist >  epsilon) pos++;
             }
             if (pos){
                if (neg) score += splitCost; else diff++;
             } else {
                if (neg) diff--; else diff++;
             }
          }
          score += balCost * abs(diff);
          if (score < minScore){
             minScore = score;
             index = i;
          }
       }

       tri = tris[index];
       tris.fastRemove(index);

       Array <BTri> backTris;
       Array <BTri> frontTris;
       for (uint i = 0; i < tris.getCount(); i++){

          uint neg = 0, pos = 0;
          for (uint j = 0; j < 3; j++){
             float dist = planeDistance(tri.plane, tris[i].v[j]);
                if (dist < -epsilon) neg++; else
             if (dist >  epsilon) pos++;
          }

          if (neg){
             if (pos){
                BTri newTris[3];
                int nPos, nNeg;
                tris[i].split(newTris, nPos, nNeg, tri.plane, epsilon);
                for (int i = 0; i < nPos; i++){
                   frontTris.add(newTris[i]);
                }
                for (int i = 0; i < nNeg; i++){
                   backTris.add(newTris[nPos + i]);
                }
             } else {
                backTris.add(tris[i]);
             }
          } else {
             frontTris.add(tris[i]);
          }
       }
       tris.reset();

       if (backTris.getCount() > 0){
          back = new BNode;
          back->build(backTris, splitCost, balCost, epsilon);
       } else back = NULL;

       if (frontTris.getCount() > 0){
          front = new BNode;
          front->build(frontTris, splitCost, balCost, epsilon);
       } else front = NULL;
    }
 
    void BSP::addTriangle(const Ogre::Vector3 &v0, const Ogre::Vector3 &v1, const Ogre::Vector3 &v2, void *data){
       BTri tri;

       tri.v[0] = v0;
       tri.v[1] = v1;
       tri.v[2] = v2;
       tri.data = data;

       tri.finalize();

       tris.add(tri);
    }

    void BSP::build(const int splitCost, const int balCost, const float epsilon){
    //   int nTris = tris.getCount();

       top = new BNode;
    //   top->build(tris);
       top->build(tris, splitCost, balCost, epsilon);
    /*
       SSENode *mem = new SSENode[nTris * 4];

       sseTop = (SSENode *) ((intptr(mem) + 15) & ~intptr(0xF));
       sseDest = sseTop + 1;
       sseTop->build(top, sseDest);

       sseDest = mem;
    */
    }

    no_alias bool BSP::intersects(const Ogre::Vector3 &v0, const Ogre::Vector3 &v1,
        Ogre::Vector3 *point, const BTri **triangle) const {
       if (top != NULL) return top->intersects(v0, v1, v1 - v0, point, triangle);

       return false;
    }

    bool BSP::intersectsCached(const Ogre::Vector3 &v0, const Ogre::Vector3 &v1){
       if (top != NULL){
          if (cache){
             if (cache->intersects(v0, v1)) return true;
          }
          cache = top->intersectsCached(v0, v1, v1 - v0);
          return (cache != NULL);
       }

       return false;
    }
 

    bool BSP::pushSphere(Ogre::Vector3 &pos, const float radius) const {
       if (top != NULL) return top->pushSphere(pos, radius);

       return false;
    }

    no_alias float BSP::getDistance(const Ogre::Vector3 &pos) const {
       float dist = FLT_MAX;

       if (top != NULL) top->getDistance(pos, dist);

       return dist;
    }

    no_alias bool BSP::isInOpenSpace(const Ogre::Vector3 &pos) const {
       if (top != NULL){

          BNode *node = top;
          while (true){
             float d = planeDistance(node->tri.plane, pos);

             if (d > 0){
                if (node->front){
                   node = node->front;
                } else return true;
             } else {
                if (node->back){
                   node = node->back;
                } else return false;
             }
          }
       }

       return false;
    }

 
    bool BSP::loadFile(const char *fileName){
       FILE *file = fopen(fileName, "rb");
       if (file == NULL) return false;

       delete top;

       top = new BNode;
       top->read(file);
       fclose(file);

       return true;
    }

    bool BSP::saveFile(const char *fileName) const {
       if (top == NULL) return false;

       FILE *file = fopen(fileName, "wb");
       if (file == NULL) return false;

       top->write(file);
       fclose(file);

       return true;
    }

    #ifdef _WIN32
    #pragma warning(pop)
    #endif