polyobj.cpp

Go to the documentation of this file.

#include "polyobj.h" 

#include <WinSock2.h>
#include <WS2tcpip.h>
#include <Windows.h>
#include "DXUT.h"

#include <fcntl.h>              // For _O_RDWR, _O_BINARY, _O_RDONLY, O_TEXT
#include <io.h>                 // For _open, _read, _close, _lseek, eof, _write
#include <sys/stat.h>   // For _S_IWRITE, _S_IREAD

#include "GameClass.h"
#include "Viewscreen/globals.h"

PolyObj::PolyObj(GameClass* prmGame)
{
        logger = prmGame->logger;
        game = prmGame;
}

s_polygon_object PolyObj::LoadDAW(const char* filename) const
{
        s_polygon_object polyobject = s_polygon_object();

        char msg[99];
        HRESULT hr;

        int handle = -1;
        _sopen_s(&handle, filename, _O_RDONLY | _O_BINARY | _O_SEQUENTIAL, _SH_DENYWR, _S_IWRITE);
        if (handle == -1)
        {
                char strerr[99];
                strerror_s(strerr, 99, errno);
                sprintf_s(msg, sizeof(msg), "LoadDAW() could not load file \"%s\": %s", filename, strerr);

                logger->Log(msg, Logger::Level::Fatal);
                return polyobject;
        }

        // Vertices -----------------------------------------------------------------------------
        _lseek(handle, 0L, SEEK_SET);
        _read(handle, &polyobject.vertices, 2);
        sprintf_s(msg, sizeof(msg), "LoadDAW() loading \"%s\"...", filename);
        logger->Log(msg);
        polyobject.polygons = polyobject.vertices / 3;

        // Create the vertex buffer
        sprintf_s(msg, sizeof(msg), "LoadDAW() creating memory for %i vertices...", polyobject.vertices);
        logger->Log(msg);

        if (FAILED(hr = DXUTGetD3D9Device()->CreateVertexBuffer(static_cast<long>(polyobject.vertices) * sizeof(D3DVERTEX),
                D3DUSAGE_WRITEONLY, D3DFVF_VERTEX,
                D3DPOOL_MANAGED, &polyobject.VB, NULL)))
        {
                sprintf_s(msg, sizeof(msg), "LoadDAW() could not create memory for %i vertices! %x", polyobject.vertices, hr);
                logger->Log(msg, Logger::Level::Warn);
                return polyobject;
        }

        D3DVERTEX* vtx;
        V(polyobject.VB->Lock(0, 0, reinterpret_cast<void**>(&vtx), 0));

        D3DXVECTOR3 tempnormal;
        for (long s = 0; s < polyobject.vertices; s++)
        {
                _lseek(handle, 2L + s * 32L + 0L, SEEK_SET);
                _read(handle, &tempnormal, 12);
                (*vtx).x = tempnormal.x;
                (*vtx).y = tempnormal.y;
                (*vtx).z = tempnormal.z;
                _lseek(handle, 2L + s * 32L + 12L, SEEK_SET);
                _read(handle, &tempnormal, 12);
                (*vtx).nx = tempnormal.x;
                (*vtx).ny = tempnormal.y;
                (*vtx).nz = tempnormal.z;
                _lseek(handle, 2L + s * 32L + 24L, SEEK_SET);
                _read(handle, &tempnormal.x, 4);
                _read(handle, &tempnormal.y, 4);
                (*vtx).tu = tempnormal.x;
                (*vtx).tv = tempnormal.y;
                vtx++;
        }

        V(polyobject.VB->Unlock());

        _close(handle);

        return polyobject;
}

void PolyObj::LoadDIX(const char* prmFilename)
{
        strcpy_s(filename, sizeof filename, prmFilename);

        int handle = -1;
        short i_temp;
        char msg[99];

        _sopen_s(&handle, filename, _O_RDONLY | _O_BINARY | _O_SEQUENTIAL, _SH_DENYWR, _S_IWRITE);
        if (handle == -1)
        {
                sprintf_s(msg, sizeof(msg), "LoadDIX() could not open \"%s\"!", filename);
                logger->Log(msg, Logger::Level::Error);
        }

        _lseek(handle, 0, SEEK_SET);
        _read(handle, &componentTotal, 2);

        float version;
        _read(handle, &version, 4);

        sprintf_s(msg, sizeof msg, "PolyObj %s CA", filename);
        if (componentarray)
        {
                SAFE_DELETE(componentarray);
                game->UpdateTrackedResource(msg, 3);
        }
        componentarray = new s_mesh_component[componentTotal];
        if (componentarray == nullptr)
        {
                sprintf_s(msg, sizeof(msg), "LoadDIX() could not open \"%s\"!", filename);
                logger->Log(msg, Logger::Level::Error);
                return;
        }
        game->AddTrackedResource(msg); // managed, it is just memory


        sprintf_s(msg, sizeof(msg), "LoadDIX() initialized %i component(s)...", componentTotal);
        logger->Log(msg);

        for (short s = 0; s < componentTotal; s++)
        {
                _lseek(handle, (long)s * 100L + 99L, SEEK_SET); // To 0
                _read(handle, &i_temp, 2); // 0
                componentarray[s].startvertex = (UINT)i_temp;
                _read(handle, &i_temp, 2); // 2
                componentarray[s].primitives = (UINT)i_temp;
                _read(handle, &componentarray[s].nominalxyz, 12); // 4
                _read(handle, &componentarray[s].nominalypr, 12); // 16
                _read(handle, &componentarray[s].boundsphere, 4); // 28
//                              char msg[99];
//                              sprintf_s(msg, sizeof(msg), "Type %i Component %i Bound %f", t, s, componentarray[s].boundsphere );
//                              _write(logfile, msg, strlen(msg));
                _read(handle, &componentarray[s].extendby, 12); // 32
                _read(handle, &componentarray[s].texture, 2); // 44
/*                      if (componentarray[s].texture>=shiptextureC)
                        {
                                        char msg[99];
                                        sprintf_s(msg, sizeof(msg), "Type %i Component %i Texture %i out-of-bounds", t, s, componentarray[s].texture );
                                        _write(logfile, msg, strlen(msg));
                        }
*/                      _read(handle, &componentarray[s].nominalCG, 12); // 46
                _read(handle, &componentarray[s].type, 1); // 58
                _read(handle, &componentarray[s].speedExtend, 4); // 59
                _read(handle, &componentarray[s].hingeaxis, 12); // 63
                _read(handle, &componentarray[s].hingeCG, 12); // 75
                _read(handle, &componentarray[s].hingeextent, 4); // 87
                _read(handle, &componentarray[s].attachto, 2); // 91

                if (version == 2.44f)
                {
                        _read(handle, &componentarray[s].useLightMap, 1); // 93
                        _read(handle, &componentarray[s].speedRetract, 4); // 59
                }
                else
                {
                        componentarray[s].speedRetract = componentarray[s].speedExtend;
                        componentarray[s].useLightMap = true;
                }

                //              sprintf_s(msg, sizeof(msg), "YPR for %i is %f %f %f", s, componentarray[s].nominalypr.x,componentarray[s].nominalypr.y,componentarray[s].nominalypr.z);
                //              _write(logfile, msg, strlen(msg));

                                // Dynamic
                componentarray[s].extended = 0.0f;
        }
        _close(handle);

        sprintf_s(msg, sizeof(msg), "LoadDIX() finished component list");
        logger->Log(msg);

}

unsigned short PolyObj::GetComponents() const
{
        return componentTotal;
}

s_mesh_component PolyObj::GetComponent(short i) const
{
        if (i >= componentTotal || i < 0)
                logger->Log("PolyObj::GetComponent out-of-bound array value!", Logger::Level::Fatal);

        return componentarray[i];
}

void PolyObj::ReleaseComponents()
{
        if (componentarray)
        {
                char msg[99];
                sprintf_s(msg, sizeof msg, "PolyObj %s CA", filename);
                SAFE_DELETE(componentarray);
                game->UpdateTrackedResource(msg, 3);
        }
}

PolyObj::~PolyObj()
{
        ReleaseComponents();
}