开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 查看源码
3DENGINE.CPP
资源名称：tc3d.zip　[点击查看]
上传用户：abcdshs
上传日期：2007-01-07
资源大小：1858k
文件大小：9k
源码类别：

游戏

开发平台：

Visual C++

3DENGINE.CPP：源码内容
  1. // (C) Copyright 1996 by Anthony J. Carin.  All Rights Reserved.
  2. #include <stdafx.h>
  3. #include "3dengine.h"
  4. #include <stdlib.h>
  5. #include "scrlsurf.h"
  6. #include "3dtools.h"
  7. #include "command.h"
  9. view camera;
  11. const   short BUFSIZE    = 500;
  12. const   uchar COLORDIFF  = 10;
  14. image::image(LPCTSTR filename, direction ydir)
  15. {
  16.    readfile(filename);
  17.    m_size = 1.0f;
  18.    color = RGB(255,255,255);
  19.    m_yoff = ydir;
  20. }
  22. image::~image()
  23. {
  24.    for (int i = 0; i < numsurfs; i++)
  25.    {
  26.        delete m_surfs[i];
  27.        delete m_mysurfs[i];
  28.    }
  29.    delete [] m_points;
  30.    delete [] m_surfs;
  31.    delete [] m_mysurfs;
  32. }
  34. void  image::setbmpsurf(short index, CString& face)
  35. {
  36.     if (index < 0 ||
  37.         index >= numsurfs ||
  38.         Game->Detail() < 7)
  39.         return;
  40.     delete m_mysurfs[index];
  41.     m_mysurfs[index] = new bmpsurf(face);
  42.     ((bmpsurf *)m_mysurfs[index])->ExemptFromIntersect();
  43. }
  45. void  image::readfile(LPCTSTR filename)
  46. {
  47.    char buf[BUFSIZE];
  48.    fptr = fopen(filename, "r");
  49.    if (fptr > 0)
  50.    {
  51.         getsize(buf);
  52.         getpoints(buf);
  53.         getsurfaces(buf);
  54.         buf[0] = 0;
  55.         fgets(buf, BUFSIZE, fptr);
  56.         if (buf[0] != 0)
  57.             findend(buf);
  58.         m_genstring = buf;
  59.         fclose(fptr);
  60.    }
  61. }
  63. void  image::getsize(char *buf)
  64. {
  65.    char *ptr;
  66.    fgets(buf, BUFSIZE, fptr);
  67.    ptr = findend(buf);
  68.    findend(ptr);
  69.    numpoints  = (short)atoi(buf);
  70.    numsurfs   = (short)atoi(ptr);
  71.    m_points   = new point[numpoints];
  72.    m_surfs    = (surfs **) new char[numsurfs*sizeof(surfs *)];
  73.    m_mysurfs  = (surfs **) new char[numsurfs*sizeof(surfs *)];
  74.    for (short i = 0; i < numsurfs; i++)
  75.    {
  76.        m_surfs[i] = new surfs();
  77.        m_mysurfs[i] = new surfs();
  78.    }
  79. }
  81. void  image::getpoints(char *buf)
  82. {
  83.    char *ptr1, *ptr2;
  84.    for (short i = 0; i < numpoints; i++)
  85.    {
  86.       fgets(buf, BUFSIZE, fptr);
  87.       ptr1 = findend(buf);
  88.       ptr2 = findend(ptr1);
  89.       findend(ptr2);
  90.       m_points[i].setto(convertfloat(buf), -convertfloat(ptr1), convertfloat(ptr2));
  91.    }
  92. }
  94. void  image::getsurfaces(char *buf)
  95. {
  96.    char type;
  97.    char *ptr1, *ptr2, *ptr3, *ptr4, *ptr5;
  98.    short p1,p2,p3,p4 = 0;
  99.    CString p5;
  100.    for (short i = 0; i < numsurfs; i++)
  101.    {
  102.       fgets(buf, BUFSIZE, fptr);
  103.       type = (char)atoi(buf);
  104.       ptr1 = findend(buf);
  105.       p1   = (short)(atoi(ptr1) - 1);
  106.       ptr2 = findend(ptr1);
  107.       p2   = (short)(atoi(ptr2) - 1);
  108.       ptr3 = findend(ptr2);
  109.       p3   = (short)(atoi(ptr3) - 1);
  110.       ptr4 = findend(ptr3);
  111.       if (type >= 4 && type <= 6)
  112.       {
  113.           p4 = (short)(atoi(ptr4) - 1);
  114.           ptr5 = findend(ptr4);
  115.           if (type == 5 || type == 6)
  116.           {
  117.               int numbmps = multiplesurfs(ptr5);
  118.               if (numbmps > 1)
  119.               {
  120.                   delete m_mysurfs[i];
  121.                   scrollsurf *sptr = new scrollsurf();
  122.                   while (numbmps--)
  123.                   {
  124.                       ptr4 = findend(ptr5);
  125.                       p5 = (CString) ptr5;
  126.                       sptr->addsurf(p5);
  127.                       ptr5 = ptr4;
  128.                   }
  129.                   m_mysurfs[i] = sptr;
  130.                   if (type == 6)
  131.                      ((bmpsurf *) m_mysurfs[i])->ExemptFromIntersect();
  132.               }
  133.               else
  134.               {
  135.                   findend(ptr5);
  136.                   p5 = (CString) ptr5;
  137.                   delete m_mysurfs[i];
  138.                   m_mysurfs[i] = new bmpsurf(p5);
  139.                   if (type == 6)
  140.                      ((bmpsurf *) m_mysurfs[i])->ExemptFromIntersect();
  141.               }
  142.           }
  143.       }
  144.       if (type == 3)
  145.           m_surfs[i]->setto(m_points[p1], m_points[p2], m_points[p3]);
  146.       else
  147.           m_surfs[i]->setto(m_points[p1], m_points[p2], m_points[p3], m_points[p4]);
  148.       m_surfs[i]->CalcNormals();
  149.    }
  150. }
  152. char * image::findend(char *ptr)
  153. {
  154.    while (*ptr != ' ' && *ptr != 'n')
  155.       ptr++;
  156.    *ptr++ = 0;
  157.    return ptr;
  158. }
  160. int image::multiplesurfs(char *ptr)
  161. {
  162.    int num = 1;
  163.    char spaces = FALSE;
  164.    while (*ptr != '' && *ptr != 'n')
  165.    {
  166.       if (*ptr == ' ' || *ptr == 't')
  167.           spaces = TRUE;
  168.       if (*ptr != ' ' && *ptr != 't' && spaces == TRUE)
  169.       {
  170.           spaces = FALSE;
  171.           num++;
  172.       }
  173.       ptr++;
  174.    }
  175.    return num;
  176. }
  178. void  image::draw()
  179. {
  180.     if (outofrange())
  181.         return;
  182.     copysurfs();
  184.     Game->Tool3d()->material(color);
  186.     if (Game->Detail() < 10)
  187.     {
  188.         for (short i = 0; i < numsurfs; i++)
  189.             if (m_mysurfs[i]->IsABmp() || random((short)((int)Game->Detail()+2)) != 1)
  190.                 m_mysurfs[i]->draw();
  191.     }
  192.     else
  193.     {
  194.         for (short i = 0; i < numsurfs; i++)
  195.             m_mysurfs[i]->draw();
  196.     }
  197. }
  199. char image::outofrange()
  200. {
  201.     xdirfromcamera = camera.xdirectionto(m_view);
  202.     ydirfromcamera = camera.ydirectionto(m_view);
  203.     direction xdir = xdirfromcamera - camera.xdirection();
  204.     direction ydir = ydirfromcamera - camera.ydirection();
  206.     if (camera.distanceto(m_view) > VIEWRANGE)
  207.         return TRUE;
  208.     if (ydir > (direction) TC_PI && ydir < (direction) -TC_PI)
  209.         return TRUE;
  210.     if (xdir > (direction) TC_PI && xdir < (direction) -TC_PI)
  211.         return TRUE;
  212.     return FALSE;
  213. }
  215. void image::OnlySurfExemptFromIntersect()
  216. {
  217.     if (numsurfs > 0)
  218.     {
  219.         if (m_mysurfs[0]->IsABmp())
  220.             ((bmpsurf *)m_mysurfs[0])->ExemptFromIntersect();
  221.     }
  222. }
  224. surfs * image::OnlySurf()
  225. {
  226.     if (numsurfs > 0)
  227.         return m_mysurfs[0];
  228.     return (surfs *) 0;
  229. }
  231. void image::copysurfs()
  232. {
  233.     for (short i = 0; i < numsurfs; i++)
  234.     {
  235.         *m_mysurfs[i] = *m_surfs[i];
  236.         m_mysurfs[i]->xrotate(m_view.xdirection());
  237.         m_mysurfs[i]->zrotate(m_view.zdirection());
  238.         m_mysurfs[i]->yrotate(m_view.ydirection()+m_yoff);
  239.         *m_mysurfs[i] += m_view;
  240.     }
  241. }
  243. void surfs::operator =(surfs& s)
  244. {
  245.    NormalX      = s.NormalX;
  246.    NormalY      = s.NormalY;
  247.    NormalZ      = s.NormalZ;
  248.    polygon::operator =(s);
  249. }
  251. void surfs::xrotate(direction& d)
  252. {
  253.    if (!d.iszero())
  254.    {
  255.        m_a.xrotate(d);
  256.        m_b.xrotate(d);
  257.        m_c.xrotate(d);
  258.        m_d.xrotate(d);
  259.    }
  260. }
  262. void surfs::yrotate(direction& d)
  263. {
  264.    if (!d.iszero())
  265.    {
  266.        m_a.yrotate(d);
  267.        m_b.yrotate(d);
  268.        m_c.yrotate(d);
  269.        m_d.yrotate(d);
  270.    }
  271. }
  273. void surfs::zrotate(direction& d)
  274. {
  275.    if (!d.iszero())
  276.    {
  277.        m_a.zrotate(d);
  278.        m_b.zrotate(d);
  279.        m_c.zrotate(d);
  280.        m_d.zrotate(d);
  281.    }
  282. }
  284. void surfs::operator +=(coordinate& c)
  285. {
  286.    m_a += c;
  287.    m_b += c;
  288.    m_c += c;
  289.    m_d += c;
  290. }
  292. void surfs::draw()
  293. {
  294.     if (m_linenum == 3)
  295.     {
  296.         Game->Tool3d()->begintriangle();
  297.         Game->Tool3d()->normals(NormalX, NormalY, NormalZ);
  298.         Game->Tool3d()->vertex(m_a.x(), m_a.y(), m_a.z());
  299.         Game->Tool3d()->vertex(m_b.x(), m_b.y(), m_b.z());
  300.         Game->Tool3d()->vertex(m_c.x(), m_c.y(), m_c.z());
  301.         Game->Tool3d()->end();
  302.     }
  303.     else
  304.     {
  305.         Game->Tool3d()->beginquad();
  306.         Game->Tool3d()->normals(NormalX, NormalY, NormalZ);
  307.         Game->Tool3d()->vertex(m_a.x(), m_a.y(), m_a.z());
  308.         Game->Tool3d()->vertex(m_b.x(), m_b.y(), m_b.z());
  309.         Game->Tool3d()->vertex(m_c.x(), m_c.y(), m_c.z());
  310.         Game->Tool3d()->vertex(m_d.x(), m_d.y(), m_d.z());
  311.         Game->Tool3d()->end();
  312.     }
  313. }
  316. void surfs::CalcNormals()
  317. {
  318.     coordinate a,b;
  319.     a = m_b - m_a;
  320.     b = m_c - m_a;
  321.     NormalX = a.y() * b.z() - a.z() * b.y();
  322.     NormalY = a.z() * b.x() - a.x() * b.z();
  323.     NormalZ = a.x() * b.y() - a.y() * b.x();
  324.     float length = (float)sqrt(NormalX*NormalX+NormalY*NormalY+NormalZ*NormalZ);
  325.     if (length != 0)
  326.     {
  327.         NormalX /= length;
  328.         NormalY /= length;
  329.         NormalZ /= length;
  330.     }
  331. }
  333. char surfs::iswithin(coordinate& c)
  334. {
  335.     if (m_linenum == 0)
  336.         return FALSE;
  337.     if (m_c.x() == m_b.x())
  338.     {
  339.         if (m_c.z() < m_b.z())
  340.         {
  341.             if (c.z() < m_c.z() ||  c.z() > m_b.z())
  342.                 return FALSE;
  343.         }
  344.         else
  345.         {
  346.             if (c.z() < m_b.z() ||  c.z() > m_c.z())
  347.                 return FALSE;
  348.         }
  349.         if (m_c.x() < m_d.x())
  350.         {
  351.             if (c.x() < m_c.x() ||  c.x() > m_d.x())
  352.                 return FALSE;
  353.         }
  354.         else
  355.         {
  356.             if (c.x() < m_d.x() ||  c.x() > m_c.x())
  357.                 return FALSE;
  358.         }
  359.     }
  360.     else
  361.     {
  362.         if (m_c.z() < m_d.z())
  363.         {
  364.             if (c.z() < m_c.z() ||  c.z() > m_d.z())
  365.                 return FALSE;
  366.         }
  367.         else
  368.         {
  369.             if (c.z() < m_d.z() ||  c.z() > m_c.z())
  370.                 return FALSE;
  371.         }
  372.         if (m_c.x() < m_b.x())
  373.         {
  374.             if (c.x() < m_c.x() ||  c.x() > m_b.x())
  375.                 return FALSE;
  376.         }
  377.         else
  378.         {
  379.             if (c.x() < m_b.x() ||  c.x() > m_c.x())
  380.                 return FALSE;
  381.         }
  382.     }
  383.     return TRUE;
  384. }