C++ DirectX 11访问冲突

我从旧的DirectX 11.0项目中学习了一个CSprite类，该项目是我用VisualStudio2010构建的。我只是稍微修改了一下，提取了一些变量，getter和setter，并将其放入一个名为CObject的新类中。现在我想使用Visual Studio 2012进行构建

但现在，每当我尝试创建CSprite对象时，我都会从Visual Studio中收到一个“访问冲突”错误：

Engine.exe中0x010A74A8处未处理的异常：0xC0000005:访问冲突读取位置0x00000000

似乎我无法创建任何DirectX 11接口对象，如果我想读取Visual Studio的对象，只需说“无法读取内存”

源代码：

对象.h

#ifndef __OBJECT_H__
#define __OBJECT_H__

#include "../DX11Core/DX11Util.h"

class CObject
{
public:
    CObject();
    ~CObject(){}

    void SetStatus( STRING _status )    { m_status = _status; }
    void SetTag( STRING _tag )          { m_tag = _tag; }
    void SetPosition( float _x, float _y, float _z ) { SetPosition( XMFLOAT3( _x, _y, _z ) ); }
    void SetPosition( XMFLOAT3 _pos )   { m_position = _pos; }
    void SetRotation( float _rot )      { m_fRotation = _rot; }
    void SetScale( float _x, float _y ) { SetScale( XMFLOAT3( _x, _y, 1 ) ); }
    void SetScale( XMFLOAT3 _scale )    { m_scale = _scale; }
    void SetAlpha( float _alpha )       { m_fAlpha = Clamp( _alpha, 0.0f, 1.0f ); }
    void SetActive( bool _active )      { m_bActive = _active; }

    XMFLOAT3&   GetPosition()           { return m_position; }
    STRING      GetStatus()             { return m_status; }
    STRING      GetTag()                { return m_tag; }
    float       GetXPosition()          { return m_position.x; }
    float       GetYPosition()          { return m_position.y; }
    float       GetZPosition()          { return m_position.z; }
    float       GetRotation()           { return m_fRotation; }
    XMFLOAT3&   GetScale()              { return m_scale; }
    float       GetXScale()             { return m_scale.x; }
    float       GetYScale()             { return m_scale.y; }
    bool        IsActive()              { return m_bActive; }

protected:
    XMFLOAT3    m_position;
    STRING      m_tag;
    STRING      m_status;
    float       m_fRotation;
    XMFLOAT3    m_scale;
    float       m_fAlpha;
    bool        m_bActive;
};

#endif // __OBJECT_H__

雪碧

#ifndef __SPRITE_H__
#define __SPRITE_H__

#include "Object.h"
#include "../DX11Core/DX11Core.h"
#include "../DX11Core/GraphicHelper.h"

struct Vertex
{
    XMFLOAT3 Pos;
    XMFLOAT2 Tex;
};

class CSprite : public CObject
{
public:
    CSprite( STRING _filename );
    ~CSprite()
    {
        RELEASE_COM( m_pVertices );
        RELEASE_COM( m_pTextureSampler );
        RELEASE_COM( m_pTextureSRV );
    }

    int Initialize();
    int Update( const float _dt );
    void Render();

#pragma region Getter & Setter

    void SetTexture( STRING _filename );
    void SetFrameCount( int _framecount ) { m_nFrameCount = _framecount; }
    void SetFrame( int _frameidx )
    {
        if( _frameidx >= 0 && _frameidx < m_nFrameCount )
        {
            m_nActualFrame = _frameidx;
        }
        BuildVertices();
    }
    void SetPosition( XMFLOAT3& _pos )
    {
        m_position = _pos;
        m_position.x -= ( theDXCore->GetClientWidth() / 2 );
        m_position.y *= -1.0f;
        m_position.y += ( theDXCore->GetClientHeight() / 2 );
    }

    float       GetLeftBounding() const { return ( m_position.x + m_fBoundingLeft ); }
    float       GetRightBounding() const    { return ( m_position.x + m_fBoundingRight ); }
    float       GetTopBounding() const  { return ( m_position.y + m_fBoundingTop ); }
    float       GetBottomBounding() const { return ( m_position.y + m_fBoundingBottom ); }
    int         GetFrameIdx() const { return m_nActualFrame; }
    XMMATRIX    GetWorldMatrix() const;
    Vertex      GetVertex( int _i) const { return tempVertex[_i]; }

#pragma endregion

private:
    void BuildVertices();

    int         m_nFrameCount;
    int         m_nActualFrame;
    float       m_fFrameDT;
    float       m_fActualFrameDT;

    float       m_fBoundingLeft;
    float       m_fBoundingRight;
    float       m_fBoundingTop;
    float       m_fBoundingBottom;

    Vertex tempVertex[6];

    ID3D11Buffer*                           m_pVertices;
    ID3D11ShaderResourceView*               m_pTextureSRV;
    ID3D11SamplerState*                     m_pTextureSampler;
    ID3DX11EffectMatrixVariable*            m_pFXWorld;
    ID3DX11EffectShaderResourceVariable*    m_pFXTexture;
    ID3DX11EffectSamplerVariable*           m_pFXTextureSampler;
};

#endif //__SPRITE_H__

\ifndef\uuu SPRITE\H__
#定义精灵__
#包括“Object.h”
#包括“./dx1core/dx1core.h”
#包括“./DX11Core/graphicshelper.h”
结构顶点
{
xm3位；
xm2tex；
};
类CSprite:公共对象
{
公众：
CSprite（字符串_文件名）；
~CSprite（）
{
发布COM（文件）；
发布COM（m_Ptexture重新采样器）；
发布COM（m_pTextureSRV）；
}
int初始化（）；
int更新（常量浮点_dt）；
void Render（）；
#pragma区域Getter和Setter
void SetTexture（字符串_文件名）；
void SetFrameCount（int _framecount）{m _nFrameCount=_framecount；}
void SetFrame（int\u frameidx）
{
如果（\u frameidx>=0&&u frameidxGetClientWidth（）/2）；
m_位置y*=-1.0f；
m_position.y+=（theDXCore->GetClientHeight（）/2）；
}
float GetLeftBounding（）常量{return（m_position.x+m_fBoundingLeft）；}
float GetRightBounding（）常量{return（m_position.x+m_fBoundingRight）；}
float GetTopBounding（）常量{return（m_position.y+m_fBoundingTop）；}
float GetBottomBounding（）常量{return（m_position.y+m_fBoundingBottom）；}
int GetFrameIdx（）常量{return m_nActualFrame；}
XMMATRIX GetWorldMatrix（）常量；
顶点GetVertex（int _i）常量{return tempVertex[_i]；}
#布拉格端区
私人：
void build顶点（）；
int m_n帧计数；
国际货币联盟框架；
浮动m_fFrameDT；
浮动m_fActualFrameDT；
浮动m_fBoundingLeft；
浮动m_fBoundingRight；
浮动基础顶部；
浮式基础底板；
顶点温度顶点[6]；
ID3D11Buffer*m_pverties；
ID3D11ShaderResourceView*m_pTextureSRV；
ID3D11SamplerState*m_PtextureResampler；
ID3DX11EffectMatrixVariable*m_pFXWorld；
ID3DX11EffectShaderResourceVariable*m_pfxture；
ID3DX11EffectSamplerVariable*m_PFXtextResampler；
};
#endif/\uuu SPRITE\H__

Sprite.cpp |我在问题开始的地方插入了两条注释

#include "Sprite.h"
#include "SpriteManager.h"

CSprite::CSprite( STRING _filename )
    : m_nFrameCount( 1 )
    , m_nActualFrame( 0 )
    , m_pTextureSRV( 00 )
    , m_pTextureSampler( 00 )
    , m_pVertices( 00 )
    , m_pFXWorld( 00 )
    , m_pFXTexture( 00 )
    , m_pFXTextureSampler( 00 )
    , m_fFrameDT( 1000.0f )
    , m_fActualFrameDT( 0.0f )
{
    GraphicHelper::CreateSRV( m_pTextureSRV, _filename ); // can't create ID3D11ShaderResourceView

    this->Initialize();
}

int CSprite::Initialize()
{
    D3D11_SAMPLER_DESC samplerDesc = {};
    samplerDesc.AddressU = samplerDesc.AddressV = samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
    samplerDesc.ComparisonFunc = D3D11_COMPARISON_NEVER;
    samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
    //  samplerDesc.Filter = D3D11_FILTER_ANISOTROPIC;
    //  samplerDesc.MaxAnisotropy = 4;
    samplerDesc.MaxLOD = D3D11_FLOAT32_MAX;
    HR( theDevice->CreateSamplerState( &samplerDesc, &m_pTextureSampler ) );

    BuildVertices( );

    D3D11_SAMPLER_DESC colorMapDesc = {};
    colorMapDesc.AddressU = colorMapDesc.AddressV = colorMapDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
    colorMapDesc.ComparisonFunc = D3D11_COMPARISON_NEVER;
    colorMapDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
    //  colorMapDesc.Filter = D3D11_FILTER_ANISOTROPIC;
    //  colorMapDesc.MaxAnisotropy = 4;
    colorMapDesc.MaxLOD = D3D11_FLOAT32_MAX;
    HR( theDevice->CreateSamplerState( &colorMapDesc, &m_pTextureSampler ) );

    m_pFXWorld          = theSpriteManager->GetFX()->GetVariableByName( "gWorld" )->AsMatrix();
    m_pFXTexture        = theSpriteManager->GetFX()->GetVariableByName( "gTexture" )->AsShaderResource();
    m_pFXTextureSampler = theSpriteManager->GetFX()->GetVariableByName( "gTextureSampler" )->AsSampler();

    return 0;
}

void CSprite::SetTexture( STRING _filename )
{
    GraphicHelper::CreateSRV( m_pTextureSRV, _filename );
}

XMMATRIX CSprite::GetWorldMatrix() const
{
    XMMATRIX translation = XMMatrixTranslation( m_position.x, m_position.y, m_position.z );
    XMMATRIX rotationZ = XMMatrixRotationZ( m_fRotation );
    XMMATRIX scale = XMMatrixScaling( m_scale.x, m_scale.y, 1.0f );

    return scale * rotationZ * translation;
}

void CSprite::BuildVertices()
{
    RELEASE_COM( m_pVertices );

    ID3D11Resource* pcolorTex = 00;
    m_pTextureSRV->GetResource( &pcolorTex ); //throw access violation

    D3D11_TEXTURE2D_DESC colorTexDesc = {};
    ( reinterpret_cast<ID3D11Texture2D*>( pcolorTex ) )->GetDesc( &colorTexDesc );
    pcolorTex->Release();

    colorTexDesc.Width /= m_nFrameCount;
    // Calculate corners for uneven boundings
    float left = -(float)(int)( colorTexDesc.Width * 0.5f );
    float right = (float)((int)( colorTexDesc.Width * 0.5f ) );
    if( colorTexDesc.Width % 2 == 1 ) right += 1.0f;
    m_fBoundingLeft = left;
    m_fBoundingRight = right;

    float top = (float)(int)( colorTexDesc.Height * 0.5f );
    float bottom = -(float)(int)( colorTexDesc.Height * 0.5f );
    if( colorTexDesc.Height % 2 == 1 ) bottom -= 1.0f;
    m_fBoundingTop = top;
    m_fBoundingBottom = bottom;

    float FrameWidth = 1.0f / m_nFrameCount;
    // Create Vertexbuffer

    Vertex vertices[] =
    {
        { XMFLOAT3( right, top, 1.0f ),    XMFLOAT2( FrameWidth * ( m_nActualFrame + 1 ), 0.0f ) },
        { XMFLOAT3( right, bottom, 1.0f ), XMFLOAT2( FrameWidth * ( m_nActualFrame + 1 ), 1.0f ) },
        { XMFLOAT3( left, bottom, 1.0f ),  XMFLOAT2( FrameWidth * ( m_nActualFrame     ), 1.0f ) },

        { XMFLOAT3( left, bottom, 1.0f ),  XMFLOAT2( FrameWidth * ( m_nActualFrame     ), 1.0f ) },
        { XMFLOAT3( left, top, 1.0f ),     XMFLOAT2( FrameWidth * ( m_nActualFrame     ), 0.0f ) },
        { XMFLOAT3( right, top, 1.0f ),    XMFLOAT2( FrameWidth * ( m_nActualFrame + 1 ), 0.0f ) },
    };

    D3D11_BUFFER_DESC vdesc = {};
    vdesc.Usage = D3D11_USAGE_IMMUTABLE;
    vdesc.ByteWidth = sizeof( Vertex ) * ARRAYSIZE( vertices );
    vdesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
    D3D11_SUBRESOURCE_DATA vdata = {};
    vdata.pSysMem = vertices;
    HR( theDevice->CreateBuffer( &vdesc, &vdata, &m_pVertices ) );

    memcpy( &tempVertex, vertices, sizeof( vertices ) );
}

int CSprite::Update( const float _dt )
{
    m_fActualFrameDT -= _dt;
    if( m_fActualFrameDT < 0.0f )
    {
        m_fActualFrameDT = m_fFrameDT;

        int i = m_nActualFrame + 1;
        if( i >= m_nFrameCount ) i = 0;

        SetFrame( i );
    }

    return ERROR_SUCCESS;
}

void CSprite::Render()
{
    UINT stride = sizeof( Vertex );
    UINT offset = 0;
    theContext->IASetVertexBuffers( 0, 1, &m_pVertices, &stride, &offset );
    XMMATRIX world = GetWorldMatrix();
    m_pFXWorld->SetMatrix( reinterpret_cast<float*>( &world ) );
    m_pFXTexture->SetResource( m_pTextureSRV );
    m_pFXTextureSampler->SetSampler( 0, m_pTextureSampler );

    D3DX11_TECHNIQUE_DESC techDesc = {};
    theSpriteManager->GetFXTech()->GetDesc( &techDesc );

    for( UINT p = 0; p < techDesc.Passes; ++p )
    {
        theSpriteManager->GetFXTech()->GetPassByIndex( p )->Apply( 0, theContext );

        theContext->Draw( 6, 0 );
    }
}

#包括“Sprite.h”
#包括“SpriteManager.h”
CSprite:：CSprite（字符串_文件名）
：m_n帧计数（1）
，m_n实际帧（0）
，m_pTextureSRV（00）
，m_Ptexture重采样器（00）
，m_pverties（00）
，m_pFXWorld（00）
，m_pFXTexture（00）
，m_pfxtextexterresampler（00）
，m_fFrameDT（1000.0f）
，m_fActualFrameDT（0.0f）
{
GraphicHelper:：CreateSRV（m_pTextureSRV，_filename）；//无法创建ID3D11ShaderResourceView
这个->初始化（）；
}
int CSprite:：Initialize（）
{
D3D11_SAMPLER_DESC SAMPLER DESC={}；
sampledesc.AddressU=sampledesc.AddressV=sampledesc.AddressW=D3D11\u纹理\u地址\u包裹；
samplerDesc.ComparisonFunc=D3D11\u比较\u从不；
samplerDesc.Filter=D3D11_Filter_MIN_MAG_MIP_LINEAR；
//samplerDesc.Filter=D3D11_Filter_；
//sampledesc.max各向异性=4；
samplerDesc.MaxLOD=D3D11_FLOAT32_MAX；
HR（设备->创建采样器状态（&samplerDesc，&m_pTextResampler））；
构建顶点（）；
D3D11_采样器_DESC colorMapDesc={}；
colorMapDesc.AddressU=colorMapDesc.AddressV=colorMapDesc.AddressW=D3D11\u纹理\u地址\u包裹；
colorMapDesc.ComparisonFunc=D3D11\u比较\u从不；
colorMapDesc.Filter=D3D11\u Filter\u MIN\u MAG\u MIP\u LINEAR；
//colorMapDesc.Filter=D3D11\u Filter\u各向异性；
//colorMapDesc.max各向异性=4；
colorMapDesc.MaxLOD=D3D11_FLOAT32_MAX；
HR（设备->创建采样器状态（&colorMapDesc，&m_ptextresampler））；
m_pFXWorld=pritemanager->GetFX（）->GetVariableByName（“gWorld”）->AsMatrix（）；
m_pfxture=pritemanager->GetFX（）->GetVariableByName（“gTexture”）->AsShaderResource（）；
m_pfxturesampler=pritemanager->GetFX（）->GetVariableByName（“gTextureSampler”）->AsSampler（）；
返回0；
}
void CSprite:：SetTexture（字符串_文件名）
{
graphicshelper:：CreateSRV（m_pTextureSRV，_文件名）；
}
XMMATRIX CSprite:：GetWorldMatrix（）常量
{
XMMATRIX translation=XMMATRIX-xtransation（m_-position.x，m_-position.y，m_-position.z）；
XMMATRIX rotationZ=XMMATRIX rotationZ（m_fRotation）；
XMMATRIX scale=XMMATRIX scaling（m_scale.x，m_scale.y，1.0f）；
返回刻度*旋转Z*平移；
}
void CSprite:：BuildVertices（）
{
发布COM（文件）；
ID3D11Resource*pcolorTex=00；
m_pTextureSRV->GetResource（&pcolorTex）；//抛出访问冲突
D3D11_TEXTURE2D_DESC colortextdesc={}；
（重新解释投影（pcolorTex））->GetDesc（&colorTexDesc）；
pcolorTex->Release（）；
colortextdesc.Width/=m_n帧计数；
//计算不均匀边界的角点
左浮动=-（浮动）（整数）（颜色描述宽度*0.5f）；
右浮动=（浮动）（（int）（彩色描述宽度*0.5f））；
如果（colorTexDesc.WITH%2==1）右+=1.0f；
m_fBoundingLeft=左；
m_fBoundingRight=右侧；
飘向
if (m_pTextureSRV != NULL)
{
    ID3D11Resource* pcolorTex = 00;
    m_pTextureSRV->GetResource( &pcolorTex ); // put a break point here
}