home *** CD-ROM | disk | FTP | other *** search
/ PC World 2006 July & August / PCWorld_2006-07-08_cd.bin / temacd / planearcade / planearcade.exe / Tank3.bmp / bsp.cpp < prev    next >
C/C++ Source or Header  |  2004-10-03  |  19KB  |  888 lines
  1.  
  2. #include "main.h"
  3.  
  4. //------------------------------------------------------------------
  5. // Name: BSP()
  6. // Desc: konstruktor
  7. //------------------------------------------------------------------
  8. BSP::BSP()
  9. {
  10.  
  11.     g_pVB = NULL;
  12.  
  13.     Face = NULL;
  14.     Group = NULL;
  15.     Plane = NULL;
  16.     Node = NULL;
  17.     Leaf = NULL;
  18.     Light = NULL;
  19.     g_pLightMap = NULL;
  20.  
  21.     FileBsp = NULL;
  22.  
  23.     NumFaces = 0;
  24.     NumGroups = 0;
  25.     NumPlanes = 0;
  26.     NumNodes = 0;
  27.     NumLeafs = 0;
  28.     NumLights = 0;
  29.     NumLightMaps = 0;
  30.  
  31. }
  32.  
  33.  
  34. //------------------------------------------------------------------
  35. // Name: CleanUp()
  36. // Desc: destruktor
  37. //------------------------------------------------------------------
  38. void BSP::CleanUp()
  39. {
  40.  
  41.     //
  42.     //vertex buffer
  43.     //
  44.     if (g_pVB != NULL)
  45.         g_pVB->Release();
  46.     g_pVB = NULL;
  47.  
  48.     //
  49.     //group
  50.     //
  51.     if (Group != NULL)
  52.     {
  53.         //znic textury
  54.         for (int i=0;i<NumGroups;i++)
  55.         {
  56.             ClearGroupTextures(i);
  57.         }
  58.  
  59.         delete [] Group;
  60.     }
  61.     Group = NULL;
  62.  
  63.     //
  64.     //face
  65.     //
  66.     if (Face != NULL)
  67.         delete [] Face;
  68.     Face = NULL;
  69.  
  70.     //
  71.     //plane
  72.     //
  73.     if (Plane != NULL)
  74.         delete [] Plane;
  75.     Plane = NULL;
  76.  
  77.     //
  78.     //Node
  79.     //
  80.     if (Node != NULL)
  81.         delete [] Node;
  82.     Node = NULL;
  83.  
  84.     //
  85.     //Leaf
  86.     //
  87.     if (Leaf != NULL)
  88.         delete [] Leaf;
  89.     Leaf = NULL;
  90.  
  91.     //
  92.     //Lights
  93.     //
  94.     if (Light != NULL)
  95.         delete [] Light;
  96.     Light = NULL;
  97.  
  98.     //
  99.     //LightMap
  100.     //
  101.     if (g_pLightMap != NULL)
  102.     {
  103.         for (int i=0;i<NumLightMaps;i++)
  104.         {
  105.             if (g_pLightMap[i] != NULL)
  106.                 g_pLightMap[i]->Release();
  107.             g_pLightMap[i] = NULL;
  108.         }
  109.         delete [] g_pLightMap;
  110.         g_pLightMap = NULL;
  111.     }
  112.  
  113. }
  114.  
  115. //------------------------------------------------------------------
  116. // Name: InitializeGroupTextures()
  117. // Desc: Inicializuje textury skupiny
  118. //------------------------------------------------------------------
  119. void BSP::InitializeGroupTextures(int Index)
  120. {
  121.     Group[Index].g_pTexture = NULL;
  122. }
  123.  
  124.  
  125. //------------------------------------------------------------------
  126. // Name: ClearGroupTextures()
  127. // Desc: zmaze textury skupiny
  128. //------------------------------------------------------------------
  129. void BSP::ClearGroupTextures(int Index)
  130. {
  131.     if(Group[Index].g_pTexture != NULL)
  132.         Group[Index].g_pTexture->Release();
  133.     Group[Index].g_pTexture  = NULL;
  134.     
  135. }
  136.  
  137.  
  138. //------------------------------------------------------------------
  139. // Name: Load()
  140. // Desc: loadne BSP strom
  141. //------------------------------------------------------------------
  142. void BSP::Load(char *FileName)
  143. {
  144.  
  145.     char cBuf[80];
  146.     int i;
  147.  
  148.     ///////
  149.     //LOG//
  150.     ///////
  151.     LogPrint("Loading BSP tree...");
  152.     sprintf(cBuf,"  File: %s",FileName);
  153.     LogPrint(cBuf);
  154.  
  155.  
  156.     ////////
  157.     //FILE//
  158.     ////////
  159.     FileBsp = fopen(FileName,"rb");
  160.     if (FileBsp == NULL)
  161.     {
  162.         sprintf(cBuf,"  Missing File: %s",FileName);
  163.         LogPrint(cBuf);        
  164.     }
  165.  
  166.     /////////
  167.     //Group//
  168.     /////////
  169.     fread(&NumGroups,sizeof(int),1,FileBsp);
  170.     sprintf(cBuf,"  NumGroups: %d",NumGroups);
  171.     LogPrint(cBuf);
  172.     Group = new BSPGROUP[NumGroups];
  173.     for (i=0;i<NumGroups;i++)
  174.     {
  175.         ReadGroup();
  176.     }
  177.  
  178.     ////////
  179.     //Face//
  180.     ////////
  181.     fread(&NumFaces,sizeof(int),1,FileBsp);
  182.     sprintf(cBuf,"  NumFaces: %d",NumFaces);
  183.     LogPrint(cBuf);
  184.     Face = new BSPFACE[NumFaces];
  185.     for (i=0;i<NumFaces;i++)
  186.     {
  187.         ReadFace();
  188.     }
  189.  
  190.     /////////
  191.     //Plane//
  192.     /////////
  193.     fread(&NumPlanes,sizeof(int),1,FileBsp);
  194.     sprintf(cBuf,"  NumPlanes: %d",NumPlanes);
  195.     LogPrint(cBuf);
  196.     Plane = new PLANE[NumPlanes];
  197.     for (i=0;i<NumPlanes;i++)
  198.     {
  199.         ReadPlane();
  200.     }
  201.  
  202.     /////////
  203.     //Node //
  204.     /////////
  205.     fread(&NumNodes,sizeof(int),1,FileBsp);
  206.     sprintf(cBuf,"  NumNodes: %d",NumNodes);
  207.     LogPrint(cBuf);
  208.     Node = new BSPNODE[NumNodes];
  209.     for (i=0;i<NumNodes;i++)
  210.     {
  211.         ReadNode();
  212.     }
  213.  
  214.     /////////
  215.     //Leaf //
  216.     /////////
  217.     fread(&NumLeafs,sizeof(int),1,FileBsp);
  218.     sprintf(cBuf,"  NumLeaf: %d",NumLeafs);
  219.     LogPrint(cBuf);
  220.     Leaf = new BSPLEAF[NumNodes];
  221.     for (i=0;i<NumLeafs;i++)
  222.     {
  223.         ReadLeaf();
  224.     }
  225.  
  226.     /////////
  227.     //Light//
  228.     /////////
  229.     fread(&NumLights,sizeof(int),1,FileBsp);
  230.     sprintf(cBuf,"  NumLights: %d",NumLights);
  231.     LogPrint(cBuf);
  232.     Light = new BSPLIGHT[NumLights];
  233.     for (i=0;i<NumLights;i++)
  234.     {
  235.         ReadLight();
  236.     }
  237.  
  238.     ///////////
  239.     //LighMap//
  240.     ///////////
  241.     fread(&NumLightMaps,sizeof(int),1,FileBsp);
  242.     sprintf(cBuf,"  NumLightMaps: %d",NumLightMaps);
  243.     LogPrint(cBuf);
  244.     g_pLightMap =  new LPDIRECT3DTEXTURE9[NumLightMaps];
  245.     for (i=0;i<NumLightMaps;i++)
  246.     {
  247.         ReadLightMap();
  248.     }
  249.  
  250.  
  251.     ////////////////
  252.     //VertexBuffer//
  253.     ////////////////
  254.     CreateVertexBuffer();
  255.  
  256.  
  257.     fclose(FileBsp);
  258.  
  259.  
  260. }
  261.  
  262.  
  263. //------------------------------------------------------------------
  264. // Name: ReadFace()
  265. // Desc: precita face
  266. //------------------------------------------------------------------
  267. void BSP::ReadFace()
  268. {
  269.  
  270.     RBSPFACE F;
  271.     int Index;
  272.  
  273.     fread(&F,sizeof(RBSPFACE),1,FileBsp);    
  274.     Index = F.Index ;
  275.  
  276.     Face[Index].Group = F.Group;
  277.     Face[Index].Plane = F.Plane;
  278.  
  279.     for(int i=0;i<3;i++)
  280.     {
  281.         Face[Index].P[i] = F.P[i];
  282.         Face[Index].T1[i] = F.T1[i];
  283.         Face[Index].T2[i] = F.T2[i];
  284.     }
  285.  
  286. }
  287.  
  288.  
  289. //------------------------------------------------------------------
  290. // Name: ReadGroup()
  291. // Desc: nacita skupinu
  292. //------------------------------------------------------------------
  293. void BSP::ReadGroup()
  294. {
  295.  
  296.     RBSPGROUP G;
  297.     char cBuf[80];
  298.     int Index;
  299.  
  300.     fread(&G,sizeof(RBSPGROUP),1,FileBsp);
  301.  
  302.     Index = G.Index ;
  303.  
  304.     LogPrint("  Creating GROUP");
  305.     sprintf(cBuf,"    Texture: %s",G.Texture);
  306.     LogPrint(cBuf);
  307.  
  308.     Group[Index].BlendType = G.BlendType;
  309.     Group[Index].CollisionType = G.CollisionType;
  310.     Group[Index].Type = G.Type ;
  311.  
  312.     //loadne texturu
  313.     if (FAILED(D3DXCreateTextureFromFileEx(g_pd3dDevice, 
  314.                                   G.Texture ,    
  315.                                   D3DX_DEFAULT, 
  316.                                   D3DX_DEFAULT, 
  317.                                   Engine.MipMapLevels,   //MipLevels
  318.                                   0,            
  319.                                   Engine.TextureFormat, 
  320.                                   Engine.TextureCreatingFlag,
  321.                                   D3DX_DEFAULT, //Filter
  322.                                   D3DX_DEFAULT, //MipFilter
  323.                                   0xffff00ff,    //ColorKey
  324.                                   NULL,         
  325.                                   NULL,         
  326.                                   &Group[Index].g_pTexture)))  
  327.         {
  328.             LogPrint("    FAILED");
  329.         }
  330.  
  331.  
  332. }
  333.  
  334. //------------------------------------------------------------------
  335. // Name: ReadPlane()
  336. // Desc: nacita roviny
  337. //------------------------------------------------------------------
  338. void BSP::ReadPlane()
  339. {
  340.     int Index;
  341.     RBSPPLANE P;
  342.  
  343.     fread(&P,sizeof(RBSPPLANE),1,FileBsp);
  344.  
  345.     Index = P.Index ;
  346.  
  347.     Plane[Index].D = P.D;
  348.     Plane[Index].Normal = P.Normal;
  349.  
  350. }
  351.  
  352. //------------------------------------------------------------------
  353. // Name: ReadLight()
  354. // Desc: nacita svetlo
  355. //------------------------------------------------------------------
  356. void BSP::ReadLight()
  357. {
  358.     int Index;
  359.     RBSPLIGHT L;
  360.  
  361.     fread(&L,sizeof(RBSPLIGHT),1,FileBsp);
  362.  
  363.     Index = L.Index ;
  364.  
  365.     Light[Index].Color = L.Color;
  366.     Light[Index].Intensity = L.Intensity;
  367.     Light[Index].Pos = L.Pos;
  368.     Light[Index].Range = L.Range;
  369.  
  370. }
  371.  
  372. //------------------------------------------------------------------
  373. // Name: ReadLight()
  374. // Desc: nacita lightmapu
  375. //------------------------------------------------------------------
  376. void BSP::ReadLightMap()
  377. {
  378.     int Index;
  379.     RBSPLIGHTMAP L;
  380.  
  381.     fread(&L,sizeof(RBSPLIGHTMAP),1,FileBsp);
  382.  
  383.     Index = L.Index;
  384.  
  385.     //log
  386.     char cBuf[80];
  387.     sprintf(cBuf,"  Vytvaram LightMapu ID: %d",Index);
  388.     LogPrint(cBuf);
  389.  
  390.     //vynuluje
  391.     g_pLightMap[Index] = NULL;
  392.  
  393.     //vytvori lightmapu
  394.     if (FAILED(D3DXCreateTexture(g_pd3dDevice,
  395.                                  256,
  396.                                  256,0,0,
  397.                                  D3DFMT_A8R8G8B8,
  398.                                  Engine.TextureCreatingFlag,
  399.                                  &g_pLightMap[Index])))
  400.     {
  401.         LogPrint("    chyba");
  402.     }
  403.     else
  404.     {
  405.         LogPrint("    OK");
  406.     }
  407.  
  408.     //skopiruj do lightmapy
  409.     D3DSURFACE_DESC pDesc;
  410.     D3DLOCKED_RECT d3dlr;
  411.     g_pLightMap[Index]->GetLevelDesc(0, &pDesc );
  412.  
  413.     LogPrint("    Otvaram lightmapu");
  414.     g_pLightMap[Index]->LockRect( 0, &d3dlr, 0, 0 );
  415.     DWORD *pDst = (DWORD *)d3dlr.pBits;
  416.  
  417.     for (int x=0;x<256;x++)
  418.     {
  419.         for (int y=0;y<256;y++)
  420.         {
  421.             pDst[x*256+y] = (255 << 24 | L.Texel[y][x][0] << 16 | 
  422.                                          L.Texel[y][x][1] << 8  | 
  423.                                          L.Texel[y][x][2]  );
  424.         
  425.         }
  426.     }
  427.  
  428.     LogPrint("    Zatvaram lightmapu");
  429.     g_pLightMap[Index]->UnlockRect (0);
  430.  
  431.     sprintf(cBuf,"media/light%d.bmp",Index);
  432.     D3DXSaveTextureToFile(cBuf,D3DXIFF_BMP,g_pLightMap[Index],NULL);
  433.  
  434.     
  435.  
  436. }
  437.  
  438. //------------------------------------------------------------------
  439. // Name: CreateVertexBuffer()
  440. // Desc: Vytvori Vertex Buffer
  441. //------------------------------------------------------------------
  442. void BSP::CreateVertexBuffer()
  443. {
  444.  
  445.     if (FAILED(g_pd3dDevice->CreateVertexBuffer(NumFaces*3*sizeof(CUSTOMVERTEXBSP),
  446.                                    D3DUSAGE_WRITEONLY, D3DFVF_CUSTOMVERTEXBSP,
  447.                                    D3DPOOL_DEFAULT, &g_pVB, NULL )))
  448.       {
  449.         LogPrint(" VertexBuffer: FAILED");
  450.     }
  451.     else
  452.     {
  453.         LogPrint(" VertexBuffer: OK");
  454.     }
  455.  
  456. }
  457.  
  458. //------------------------------------------------------------------
  459. // Name: FillVertexBuffer()
  460. // Desc: naplni vertex buffer
  461. //------------------------------------------------------------------
  462. void BSP::FillVertexBuffer()
  463. {
  464.     //pomocne premenne
  465.     int ActVertex = 0;
  466.     int NumF = 0;
  467.     int i,u,j;
  468.  
  469.     //reset pocitadla
  470.     NumVisibleFaces = 0;
  471.  
  472.     //Vertex do ktoreho sa uklada
  473.     CUSTOMVERTEXBSP *Vertex;
  474.  
  475.     //Otvor VB
  476.     g_pVB->Lock(0, 0, (void**)&Vertex, 0 ) ;
  477.  
  478.     /////////
  479.     //GROUP//
  480.     /////////
  481.     for (i=0;i<NumGroups;i++)
  482.     {
  483.         //nastavi pociatocnu hodnotu
  484.         Group[i].StartVertex = ActVertex;
  485.         NumF = 0;
  486.         
  487.         for (u=0;u<NumFaces;u++)
  488.         {
  489.             if (Face[u].Visible == true)
  490.             {
  491.                 if (Face[u].Group == i)
  492.                 {
  493.  
  494.                     //pocitadlo
  495.                     NumVisibleFaces++;
  496.                     
  497.                     for (j=0;j<3;j++)
  498.                     {
  499.                         //prida vertex do VB
  500.                         Vertex[ActVertex].pos  = D3DXVECTOR3(Face[u].P[j].X,
  501.                                                              Face[u].P[j].Y,
  502.                                                              Face[u].P[j].Z);
  503.  
  504.                         Vertex[ActVertex].tu1 = Face[u].T1[j].X;
  505.                         Vertex[ActVertex].tv1 = Face[u].T1[j].Y;
  506.  
  507.                         Vertex[ActVertex].tu2 = Face[u].T2[j].X;
  508.                         Vertex[ActVertex].tv2 = Face[u].T2[j].Y;
  509.  
  510.                         Vertex[ActVertex].color = 0xffffffff;
  511.  
  512.                         ActVertex++;
  513.                     }
  514.  
  515.                     NumF++;
  516.                 }
  517.                     
  518.             }
  519.  
  520.         }
  521.  
  522.         Group[i].NumVisibleFaces = NumF;
  523.     
  524.         
  525.     }
  526.  
  527.     //zatvor VB
  528.     g_pVB->Unlock();
  529.  
  530. }
  531.  
  532. //------------------------------------------------------------------
  533. // Name: Render()
  534. // Desc: vyrenderuje
  535. //------------------------------------------------------------------
  536. void BSP::Render()
  537. {
  538.  
  539.     int i;
  540.  
  541.     //
  542.     //Optimalizacia
  543.     //
  544.     Optimalize();
  545.  
  546.     //
  547.     //vynuluje world maticu
  548.     //
  549.     D3DXMATRIXA16 NullMatrix;        
  550.     D3DXMatrixIdentity(&NullMatrix);
  551.     g_pd3dDevice->SetTransform( D3DTS_WORLD, &NullMatrix);
  552.  
  553.     //
  554.     //Napσnie VB
  555.     //
  556.     FillVertexBuffer();
  557.     g_pd3dDevice->SetStreamSource( 0, g_pVB, 0, sizeof(CUSTOMVERTEXBSP));
  558.     g_pd3dDevice->SetFVF(D3DFVF_CUSTOMVERTEXBSP);
  559.  
  560.     //
  561.     //redenruje podla materialov
  562.     //
  563.  
  564.     //0
  565.     for (i = 0;i<NumGroups;i++)
  566.     {
  567.         if (Group[i].BlendType == 0)
  568.             RenderGroup(i);
  569.     }
  570.  
  571.     //1
  572.     for (i = 0;i<NumGroups;i++)
  573.     {
  574.         if (Group[i].BlendType == 1)
  575.             RenderGroup(i);
  576.     }
  577.  
  578.     //2
  579.     for (i = 0;i<NumGroups;i++)
  580.     {
  581.         if (Group[i].BlendType == 2)
  582.             RenderGroup(i);
  583.     }
  584.  
  585.     //
  586.     //Render debug BSP NODES
  587.     //
  588.     /*
  589.     for (i=0;i<NumNodes;i++)
  590.     {
  591.         if (Node[i].Leaf == true)
  592.         DebugDrawBox(Node[i].Min,Node[i].Max);
  593.     }*/
  594.  
  595.     //
  596.     //Render debug BSP LEAFS
  597.     /*
  598.     for (i=0;i<NumLeafs;i++)
  599.     {
  600.         DebugDrawBox(Leaf[i].Min,Leaf[i].Max);
  601.     }*/
  602.  
  603.     //
  604.     //Reset
  605.     //
  606.     Engine.ResetToDefault();
  607.  
  608. }
  609.  
  610. //------------------------------------------------------------------
  611. // Name: RenderGroup()
  612. // Desc: Vybrederuje skupinu
  613. //------------------------------------------------------------------
  614. void BSP::RenderGroup(int Index)
  615. {
  616.     //nastavi priesvitnos¥
  617.     SetBlendMode(Group[Index].BlendType);
  618.  
  619.     //vyber textury
  620.     g_pd3dDevice->SetTexture( 0, Group[Index].g_pTexture);
  621.  
  622.     //vyber LightMapy
  623.     g_pd3dDevice->SetTexture( 1, g_pLightMap[Index]);
  624.  
  625.     g_pd3dDevice->SetTextureStageState(0, D3DTSS_TEXCOORDINDEX, 0);
  626.     g_pd3dDevice->SetTextureStageState(0, D3DTSS_COLOROP,   D3DTOP_SELECTARG1);
  627.     g_pd3dDevice->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
  628.     g_pd3dDevice->SetTextureStageState(0, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
  629.  
  630.     g_pd3dDevice->SetTextureStageState(1, D3DTSS_TEXCOORDINDEX,1);
  631.     g_pd3dDevice->SetTextureStageState(1, D3DTSS_COLOROP, D3DTOP_ADDSIGNED );
  632.     g_pd3dDevice->SetTextureStageState(1, D3DTSS_COLORARG1, D3DTA_TEXTURE);
  633.     g_pd3dDevice->SetTextureStageState(1, D3DTSS_COLORARG2, D3DTA_CURRENT);
  634.  
  635.     //render
  636.     g_pd3dDevice->DrawPrimitive( D3DPT_TRIANGLELIST, Group[Index].StartVertex , Group[Index].NumVisibleFaces );
  637.  
  638. }
  639. //------------------------------------------------------------------
  640. // Name: OptimalizePVS()
  641. // Desc: Vyberie viditelne faces
  642. //------------------------------------------------------------------
  643. void BSP::OptimalizePVS()
  644. {
  645.     int i,u;
  646.  
  647.     //oznaci vsetky ako neviditelne
  648.     for( i=0;i<NumFaces;i++)
  649.         Face[i].Visible = false;
  650.  
  651.     //zisti v ktorom liste sa nachadza kamera
  652.     int LeafIndex = GetLeafIndex(Camera.Pos);
  653.  
  654.     //ak je kamera v solid vyjdi z funckie
  655.     if (LeafIndex == -1)
  656.         return;
  657.  
  658.     //kde sa nachadza kamera vsetko vidno
  659.     for(u=0;u<Leaf[LeafIndex].NumFaces ;u++)
  660.         Face[Leaf[LeafIndex].FaceList[u]].Visible = true;
  661.  
  662.     //pre vsetky vidite╛ne leafy
  663.     ///////
  664.     //PVS//
  665.     ///////
  666.     for (i=0;i<Leaf[LeafIndex].NumVisibleLeafs;i++)
  667.     {
  668.         int LIndex = Leaf[LeafIndex].VisibleLeafs[i];
  669.  
  670.         ////////////////////
  671.         //Frustrum culling//
  672.         ////////////////////
  673.         if (Camera.FrustrumSphere(Leaf[LIndex].Centre,Leaf[LIndex].Radius) == true)
  674.         {
  675.             for(u=0;u<Leaf[LIndex].NumFaces ;u++)
  676.                 Face[Leaf[LIndex].FaceList[u]].Visible = true;
  677.         }
  678.     }
  679.  
  680.     ///////////////////
  681.     //backface culing//
  682.     ///////////////////
  683.     for(i=0;i<NumFaces;i++)
  684.     {
  685.         if (Face[i].Visible == true)
  686.         {
  687.             if (PointPlane(Plane[Face[i].Plane ],Camera.Pos) < 0.0f)
  688.                 Face[i].Visible = false;
  689.         }
  690.     }
  691.  
  692. }
  693.  
  694.  
  695. //------------------------------------------------------------------
  696. // Name: Optimalize()
  697. // Desc: Vyberie viditelne faces
  698. //------------------------------------------------------------------
  699. void BSP::Optimalize()
  700. {
  701.     int i,u;
  702.  
  703.     //oznaci vsetky ako neviditelne
  704.     for( i=0;i<NumFaces;i++)
  705.         Face[i].Visible = false;
  706.  
  707.     ///////
  708.     for (i=0;i<NumLeafs;i++)
  709.     {
  710.         ////////////////////
  711.         //Frustrum culling//
  712.         ////////////////////
  713.         if (Camera.FrustrumSphere(Leaf[i].Centre,Leaf[i].Radius) == true)
  714.         {
  715.             for(u=0;u<Leaf[i].NumFaces ;u++)
  716.                 Face[Leaf[i].FaceList[u]].Visible = true;
  717.         }
  718.     }
  719.  
  720.     ///////////////////
  721.     //backface culing//
  722.     ///////////////////
  723.     for(i=0;i<NumFaces;i++)
  724.     {
  725.         if (Face[i].Visible == true)
  726.         {
  727.             if (PointPlane(Plane[Face[i].Plane ],Camera.Pos) < 0.0f)
  728.                 Face[i].Visible = false;
  729.         }
  730.     }
  731.  
  732. }
  733.  
  734. //------------------------------------------------------------------
  735. // Name: NoOptimalize()
  736. // Desc: neoptimalizuje
  737. //------------------------------------------------------------------
  738. void BSP::NoOptimalize()
  739. {
  740.     //oznaci vsetky ako neviditelne
  741.     for(int i=0;i<NumFaces;i++)
  742.         Face[i].Visible = true;
  743.  
  744. }
  745.  
  746.  
  747. //------------------------------------------------------------------
  748. // Name: SetBlendMode()
  749. // Desc: Nastavi priesvitnos¥ podla Indexu
  750. //------------------------------------------------------------------
  751. void BSP::SetBlendMode(int BlendType)
  752. {
  753.     switch (BlendType)
  754.     { 
  755.     
  756.         case 0: //bez priesvitnosti
  757.             Engine.SetBlendNone();
  758.             break;
  759.         case 1: //transparent
  760.             Engine.SetBlendTrans();
  761.             break;
  762.         case 2: //one
  763.             Engine.SetBlendOne();
  764.             break;
  765.     }
  766.  
  767. }
  768.  
  769. //------------------------------------------------------------------
  770. // Name: ReadNode()
  771. // Desc: precita nodu
  772. //------------------------------------------------------------------
  773. void BSP::ReadNode()
  774. {
  775.     RBSPNODE N;
  776.     int Index;
  777.  
  778.     fread(&N,sizeof(RBSPNODE),1,FileBsp);
  779.  
  780.     Index = N.Index;
  781.  
  782.     Node[Index].BackIndex  = N.BackIndex ;
  783.     Node[Index].FrontIndex  = N.FrontIndex ;
  784.     Node[Index].Leaf  = N.Leaf ;
  785.     Node[Index].LeafIndex  = N.LeafIndex ;
  786.     Node[Index].Solid  = N.Solid;
  787.     Node[Index].Radius  = N.Radius ;
  788.     Node[Index].Min  = N.Min ;
  789.     Node[Index].Max = N.Max ;
  790.     Node[Index].Centre = N.Centre ;
  791.     Node[Index].Root  = N.Root ;
  792.  
  793. }
  794.  
  795. //------------------------------------------------------------------
  796. // Name: ReadLeaf()
  797. // Desc: precita list
  798. //------------------------------------------------------------------
  799. void BSP::ReadLeaf()
  800. {
  801.     RBSPLEAF L;
  802.     int Index;
  803.  
  804.     //nacita leaf
  805.     fread(&L,sizeof(RBSPLEAF),1,FileBsp);
  806.  
  807.     Index = L.Index;
  808.  
  809.     Leaf[Index].FaceList  = L.FaceList ;
  810.     Leaf[Index].NumFaces = L.NumFaces ;
  811.     Leaf[Index].VisibleLeafs  = L.VisibleLeafs ;
  812.     Leaf[Index].NumVisibleLeafs  = L.NumVisibleLeafs ;
  813.     Leaf[Index].Centre  = L.Centre ;
  814.     Leaf[Index].Max  = L.Max ;
  815.     Leaf[Index].Min  = L.Min ;
  816.     Leaf[Index].Radius = L.Radius ;
  817.  
  818.     //nacita face list leafu
  819.     Leaf[Index].FaceList = new int [Leaf[Index].NumFaces];
  820.     fread(&Leaf[Index].FaceList[0],sizeof(int),Leaf[Index].NumFaces,FileBsp);
  821.  
  822.     //nacita PVS
  823.     Leaf[Index].VisibleLeafs  = new int [Leaf[Index].NumVisibleLeafs ];
  824.     fread(&Leaf[Index].VisibleLeafs[0],sizeof(int),Leaf[Index].NumVisibleLeafs,FileBsp);
  825. }
  826.  
  827. //------------------------------------------------------------------
  828. // Name: GetLeafIndex()
  829. // Desc: zisti v akom liste sa nachadza bod
  830. //------------------------------------------------------------------
  831. int BSP::GetLeafIndex(VECTOR3D P)
  832. {
  833.  
  834.     int NIndex = 0;  //index nody
  835.     int PlaneIndex;
  836.     float D;  //vzdialenos¥ od roviny
  837.  
  838.     while(1==1)
  839.     {
  840.  
  841.         PlaneIndex = Node[NIndex].Root;
  842.  
  843.         //solid
  844.         if (Node[NIndex].Solid == true)
  845.             return -1;
  846.     
  847.         //leaf
  848.         if (Node[NIndex].Leaf == true)
  849.             return Node[NIndex].LeafIndex ;
  850.  
  851.         D = PointPlane(Plane[PlaneIndex],P);
  852.  
  853.         //posle do front nody
  854.  
  855.         if (D>0.0f)
  856.         {            
  857.             NIndex = Node[NIndex].FrontIndex ;
  858.             continue;
  859.         }
  860.  
  861.           //posle do back nody
  862.         if (D<0.0f)
  863.         {
  864.             NIndex = Node[NIndex].BackIndex ;
  865.             continue;
  866.         }
  867.  
  868.         if (D == 0.0f)
  869.             break ;
  870.  
  871.     }
  872.  
  873.     return -1;
  874.  
  875. }
  876.  
  877. //------------------------------------------------------------------
  878. // Name: SetTexture()
  879. // Desc: nastavi texturu
  880. //------------------------------------------------------------------
  881. void BSP::SetTexture(int ToGroup,LPDIRECT3DTEXTURE9 Tex)
  882. {
  883.     Group[ToGroup].g_pTexture = Tex;
  884. }
  885.  
  886.  
  887.  
  888.