Ошибка на стадии выполнения ptr = ptr;

#pragma once
#pragma comment( lib, "shlwapi.lib" )
 
#include <Windows.h>
#include <Shlwapi.h>
#include <io.h>
#include <iostream>
#include <fstream>
#include <stdio.h>
#include <vector>
#include <string>
#include "userfn.h"
#include "usertypes.h"
#include "engine/Object.h"
 
class CParser
{
    CObject * object_;
    static std::wstring type_parsing[7];
public:
    void LoadFromEcad(CObject * object, const std::wstring & path);
private:
    bool IsFileExist(const std::wstring & file_path);
    void IndexParse(std::ifstream & file_stream, std::string & tmp);
    void VertexParse(std::ifstream & file_stream, std::string & tmp);
    void DiffuseParse(std::ifstream & file_stream, std::string & tmp);
    void AmbientParse(std::ifstream & file_stream, std::string & tmp);
    
};
void CParser::LoadFromEcad(CObject * object, const std::wstring & path )
{
    if (IsFileExist(path))
    {
        object_ = object; // ВОТ ОНА ОШИБКА
        std::ifstream file_stream( path.c_str() );
        std::string tmp;
        file_stream >> tmp;
        if ( tmp == "START" )
            while (tmp != "END")
            {
                file_stream >> tmp;
                VertexParse(file_stream,tmp);
                IndexParse(file_stream,tmp);
                DiffuseParse(file_stream,tmp);
                AmbientParse(file_stream,tmp);
            }
        file_stream.close();
    }
    else
    {
        // InitEmptyObject();
    }
}

#include "Parser.h"
void CParser::LoadFromEcad(CObject * object, const std::wstring & path )
{
    if (IsFileExist(path))
    {
        object_ = object;
        std::ifstream file_stream( path.c_str() );
        std::string tmp;
        file_stream >> tmp;
        if ( tmp == "START" )
            while (tmp != "END")
            {
                file_stream >> tmp;
                VertexParse(file_stream,tmp);
                IndexParse(file_stream,tmp);
                DiffuseParse(file_stream,tmp);
                AmbientParse(file_stream,tmp);
            }
        file_stream.close();
        /*
        inputFile.close();
        object.CalculateNormalVector();
        //device->SetMaterial( &object.material);
        object.RotationAXis(object.pitch,object.yaw,object.roll);
        */
    }
    else
    {
        // InitEmptyObject();
    }
}
 
inline bool CParser::IsFileExist(const std::wstring & file_path)
{
    return PathFileExistsW( file_path.c_str() ) == TRUE;
}
 
void CParser::VertexParse( std::ifstream & file_stream, std::string & tmp )
{
    if (tmp == "<vertex>")
        file_stream >> tmp;
        while(tmp != "</vertex>")
        {
            float x,y,z;
            x = to_float(tmp);
            file_stream >> tmp;
            y = to_float(tmp);
            file_stream >> tmp;
            z = to_float(tmp);
            object_->vertex_database.push_back(CUSTOMVERTEX(x,y,z));
            file_stream >> tmp;
        }
        file_stream >> tmp;
}
 
void CParser::IndexParse( std::ifstream & file_stream, std::string & tmp )
{
    if (tmp == "<index>")
        file_stream >> tmp;
        while(tmp != "</index>")
        {
            object_->index_database.push_back(to_int(tmp));
            file_stream >> tmp;
        }
        file_stream >> tmp;
}
 
void CParser::DiffuseParse( std::ifstream & file_stream, std::string & tmp )
{
    if (tmp == "<diffuse_rgba>")
        file_stream >> tmp;
        while(tmp != "</diffuse_rgba>")
        {   
            object_->material.Diffuse.r = to_float(tmp);
            file_stream >> tmp;
            object_->material.Diffuse.g = to_float(tmp);
            file_stream >> tmp;
            object_->material.Diffuse.b = to_float(tmp);
            file_stream >> tmp;
            object_->material.Diffuse.a = to_float(tmp);
            file_stream >> tmp;
        }
        file_stream >> tmp;
}
 
void CParser::AmbientParse( std::ifstream & file_stream, std::string & tmp )
{
    if (tmp == "<diffuse_rgba>")
        file_stream >> tmp;
        while(tmp != "</diffuse_rgba>")
        {   
            object_->material.Diffuse.r = to_float(tmp);
            file_stream >> tmp;
            object_->material.Diffuse.g = to_float(tmp);
            file_stream >> tmp;
            object_->material.Diffuse.b = to_float(tmp);
            file_stream >> tmp;
            object_->material.Diffuse.a = to_float(tmp);
            file_stream >> tmp;
    }
    file_stream >> tmp;
}

#include "Object.h"
CObject::CObject()
{
    D3DXMatrixIdentity(&matrix_transform);
    CalculateNormalVector();
    ZeroMemory( &material, sizeof(material) );
    material.Ambient.a = material.Ambient.b = material.Ambient.g = material.Ambient.r = 1;
    material.Diffuse.a = material.Diffuse.b = material.Diffuse.g = material.Diffuse.r = 1;
    text.Initialize();
    pitch = yaw = roll = 1.f;
    b_picked = false;
}
 
void CObject::TurnOnOffText()
{
    text.TurnOnOff();
}
 
void CObject::CopyToBuffer()
{
    bool bError = false;
    if( FAILED( device->CreateVertexBuffer( vertex_database.size()*sizeof(CUSTOMVERTEX),    0 , D3DFVF_CUSTOMVERTEX, D3DPOOL_DEFAULT, &vertex_buffer, NULL ) ) ) bError = true;
    if( FAILED( device->CreateIndexBuffer(30*sizeof(index_database),0,D3DFMT_INDEX16,D3DPOOL_DEFAULT,&index_buffer,NULL ) ) ) bError = true;
    VOID* pVertices;
    VOID* pIndex;
    if( FAILED( vertex_buffer->Lock( 0, vertex_database.size()*sizeof(CUSTOMVERTEX), (void**)&pVertices, 0 ) ) ) bError = true;
    if( FAILED( index_buffer-> Lock(0, vertex_database.size()*sizeof(USHORT),   (void**) &pIndex,0) ) ) bError = true;
    if (bError)
    {
        MessageBoxW(NULL,L"Ошибка в программе",L"Сообщение об ошибке",NULL);
        PostQuitMessage(0);
    }
    
    memcpy( pVertices, &vertex_database[0], vertex_database.size()*sizeof(CUSTOMVERTEX));
    memcpy( pIndex, &index_database[0], index_database.size()*sizeof(USHORT));
    vertex_buffer->Unlock();
    index_buffer->Unlock();
}
void CObject::Update()
{
    GetObjectCenter();
    TextDraw();
}
void CObject::Draw()
{   
    device->SetStreamSource( 0, vertex_buffer, 0, sizeof(CUSTOMVERTEX) );
    device->SetFVF(D3DFVF_CUSTOMVERTEX);
    device->SetIndices(index_buffer);
    device->SetTransform(D3DTS_WORLD,&matrix_transform);
    device->DrawIndexedPrimitive(D3DPT_TRIANGLELIST,0,0,vertex_database.size(),0,index_database.size()/3);
    text.Write();
}
 
void CObject::CalculateNormalVector()
{
    D3DXVECTOR3 u,v,n;
    D3DXVECTOR3 poli[3];
    for (unsigned int i = 0; i < index_database.size(); i+=3)
    {
        for (unsigned int j = 0;j<3;j++)
        {
            poli[j]=vertex_database.at(index_database.at(i+j)).ToVector();
        }
        u = poli[1]-poli[0];
        v = poli[2]-poli[0];
        D3DXVec3Cross(&n,&v,&u); // v * u, именно в таком порядке !
        D3DXVec3Normalize(&n,&n);
        for (unsigned int j = 0;j<3;j++)
        {
            vertex_database.at(index_database.at(i+j)).SetNormalVector(n);
        }
    }
}
 
 
void CObject::GetObjectCenter() 
{
    D3DXVECTOR3 sum(0,0,0);
    for (unsigned int i = 0; i < index_database.size(); i++)
    {
        unsigned int j = index_database.at(i);
        sum+= D3DXVECTOR3(vertex_database.at(j).x,vertex_database.at(j).y,vertex_database.at(j).z);
    }
    center = D3DXVECTOR3(sum.x/vertex_database.size(),sum.y/vertex_database.size(),sum.y/vertex_database.size());
}
 
 
 
void CObject::TextDraw() // организовать подачу через камеру
{
    GetObjectCenter();
    LONG top,bottom,right,left;
    D3DXVECTOR3 screenspace = camera->WorldToScreen(D3DXVECTOR3(center.x,center.y,0.f),&matrix_transform);
    D3DXVECTOR3 worldspace = camera->ScreenToWorld(D3DXVECTOR3(center.x,center.y,0.f),&matrix_transform);
    int coor = 140;
    top    = (LONG) screenspace.y-coor;
    bottom = (LONG) screenspace.y+coor;
    right  = (LONG) screenspace.x+coor;
    left   = (LONG) screenspace.x-coor;
    text.SetRect(top,bottom,right,left);
    text = L"rect(" + to_wstr((int)screenspace.x) + L";" + to_wstr((int)screenspace.y) + L")";
    text = L"center(" + to_cut_wstr(worldspace.x) + L";" + to_cut_wstr(worldspace.y) + L";" + to_cut_wstr(worldspace.z) + L")";
    text = L"vertices:" + to_wstr(vertex_database.size()) + L"  indexes:" + to_wstr(index_database.size());
    text = L"Pitch:" + to_cut_wstr(pitch);
    text = L"Yaw:" + to_cut_wstr(yaw);
    text = L"Roll:" + to_cut_wstr(roll);
    text = L"Picked:" + to_wstr(b_picked);
}
 
void CObject::RotationAXis(float & _x,float & _y,float _z = 0.f)
{
    const float strenght = 0.005f;
 
    yaw += _x * strenght;
    pitch += _y * strenght;
    roll += _z  * strenght;
    D3DXMatrixRotationYawPitchRoll(&matrix_transform,pitch,yaw,roll);
    b_changed = true;
}
 
void CObject::RotationAxis(D3DXVECTOR3& Axis,float angle)
{
    D3DXMatrixRotationAxis(&matrix_transform,&Axis,D3DXToRadian(angle));
    b_changed = true;
}
 
void CObject::MoveOnX(float value)
{
    D3DXMatrixTranslation(&matrix_transform,value,0.f,0.f);
    b_changed = true;
}
void CObject::MoveOnY(float value)
{
    D3DXMatrixTranslation(&matrix_transform,0.f,value,0.f);
    b_changed = true;
}
 
void CObject::MoveOnZ(float value)
{
    D3DXMatrixTranslation(&matrix_transform,0.f,0.f,value);
    b_changed = true;
}
 
void CObject::MoveOnVector(D3DXVECTOR3 &vec)
{
    D3DXMatrixTranslation(&matrix_transform,vec.x,vec.y,vec.z);
    b_changed = true;
}
 
void CObject::LoadObjectFromECAD(const std::string & szFileName)
{
    std::ifstream inputFile( szFileName.c_str() ); // Передаем имя файла из которого нужно читать
    std::string tmp;
    inputFile >> tmp;
    if (tmp == "vertex:")
    {
        inputFile >> tmp;
        while (tmp != "index:")
        {
            float x,y,z;
            x = to_float(tmp);
            inputFile >> tmp;
            y = to_float(tmp);
            inputFile >> tmp;
            z = to_float(tmp);
            vertex_database.push_back(CUSTOMVERTEX(x,y,z));
            inputFile >> tmp;
        }
    }
    if (tmp == "index:")
    {
        inputFile >> tmp;
        while (tmp != "END.")
        {
            index_database.push_back(to_int(tmp));
            inputFile >> tmp;
        }
    }
    inputFile.close();
    CalculateNormalVector();
    device->SetMaterial( &material);
    RotationAXis(pitch,yaw,roll);
};
 
void CObject::LoadMaterial(const std::string & szFileName)
{
    std::ifstream inputFile( szFileName.c_str() ); // Передаем имя файла из которого нужно читать
    std::string tmp;
    inputFile >> tmp;
    if (tmp == "DiffuseRGBA:")
    {
        inputFile >> tmp;
        material.Diffuse.r = to_float(tmp);
        inputFile >> tmp;
        material.Diffuse.g = to_float(tmp);
        inputFile >> tmp;
        material.Diffuse.b = to_float(tmp);
        inputFile >> tmp;
        material.Diffuse.a = to_float(tmp);
        inputFile >> tmp;
    }
    if (tmp == "AmbientRGBA:")
    {
        inputFile >> tmp;
        material.Ambient.r = to_float(tmp);
        inputFile >> tmp;
        material.Ambient.g = to_float(tmp);
        inputFile >> tmp;
        material.Ambient.b = to_float(tmp);
        inputFile >> tmp;
        material.Ambient.a = to_float(tmp);
        inputFile >> tmp;
    }
    inputFile.close();
}
 
void CObject::CheakHit(const POINT2D & ptMouseHit)
{
    D3DXVECTOR3 vecCamPos; // Первая точка в векторе это позиция камеры
    D3DXVECTOR3 vecRayEnd; // Эта точка куда стреляет камера, условно она находися в 0 позиции по оси Z, т.к. объекты с нее не уедут
    D3DXVECTOR3 vecLineDirection; // я очень надеюсь что это будет луч стреляющий в объект
    D3DXVECTOR3 vecNormal; // Нормаль для плоскости (читай полигона)
    D3DXVECTOR3 vecFromCamPosToPoly = vecCamPos; // Вектор до плоскости
    float fDistanceToPlane; // Расстояние до плоскости
 
    vecCamPos = camera->GetCameraPosition();
    vecRayEnd = camera->ScreenToWorld(D3DXVECTOR3(ptMouseHit.x,ptMouseHit.y,0.f),&matrix_transform);
    vecLineDirection = vecRayEnd - vecCamPos; // Получаем лучь стреляющий из позиции камеры в сторону которую счелкает мышь
 
    // Тут находятся нормали для каждого полигона
    for (unsigned int i = 0; i < index_database.size(); i+=3)
    {
        D3DXVECTOR3 point3dOnPoly = vertex_database.at(index_database.at(i)).ToVector();
        vecNormal = vertex_database.at(index_database.at(i)).GetNormalVector();
        vecFromCamPosToPoly = point3dOnPoly - vecCamPos;
        
                
        // for (unsigned int j = 0;j<3;j++){} //vecNormal = vertex.at(index.at(i+j)).GetNormalVector();
        
 
 
    }
    
 
}