void GEMesh::loadFromFile(const char* Filename, const char* TexturesPath)
{
LPD3DXBUFFER pD3DXMtrlBuffer;
D3DXMATERIAL* d3dxMaterials;
char sTextureFilename[256];
// load mesh
D3DXLoadMeshFromXA(Filename, D3DXMESH_SYSTEMMEM, d3ddev, NULL, &pD3DXMtrlBuffer, NULL, &iNumMaterials, &mMesh);
// load materials and textures
d3dxMaterials = (D3DXMATERIAL*)pD3DXMtrlBuffer->GetBufferPointer();
mMaterials = new D3DMATERIAL9[iNumMaterials];
mTextures = new LPDIRECT3DTEXTURE9[iNumMaterials];
for(DWORD i = 0; i < iNumMaterials; i++)
{
mMaterials[i] = d3dxMaterials[i].MatD3D;
mMaterials[i].Ambient = mMaterials[i].Diffuse;
mMaterials[i].Specular.a = 0.5f;
mMaterials[i].Specular.r = 0.5f;
mMaterials[i].Specular.g = 0.5f;
mMaterials[i].Specular.b = 0.5f;
mTextures[i] = NULL;
if(d3dxMaterials[i].pTextureFilename != NULL && lstrlenA(d3dxMaterials[i].pTextureFilename) > 0)
{
sprintf(sTextureFilename, "%s%s", TexturesPath, d3dxMaterials[i].pTextureFilename);
D3DXCreateTextureFromFileA(d3ddev, sTextureFilename, &mTextures[i]);
}
}
pD3DXMtrlBuffer->Release();
}
Model Model::createFromFile(const GraphicsDevice& device, const std::string& filename)
{
Model model;
ID3DXBuffer* materialBuffer;
unsigned long numMaterials;
D3DXLoadMeshFromXA(filename.c_str(), D3DXMESH_MANAGED, device, 0, &materialBuffer, 0, &numMaterials, &model.mesh);
model.materials = MaterialCollection(numMaterials);
model.textures = TextureCollection(numMaterials);
D3DXMATERIAL* materials = (D3DXMATERIAL*)materialBuffer->GetBufferPointer();
std::string path = filename.substr(0, filename.find_last_of('/') + 1);
for (unsigned i = 0; i < numMaterials; ++i)
{
if (materials[i].pTextureFilename)
model.textures[i] = Texture::createFromFile(device, path + materials[i].pTextureFilename);
model.materials[i] = materials[i].MatD3D;
}
materialBuffer->Release();
return model;
}
HRESULT InitScene()
{
HRESULT hr;
LPD3DXBUFFER errors = NULL;
D3DVERTEXELEMENT9 decl[] =
{
{ 0, 0, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITIONT, 0 },
{ 0, 16, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0 },
D3DDECL_END()
};
SetWindowText(hwnd, TITLE);
MYVALID(CreateColorTex(device, 0xff77FF70, &texture));
MYVALID(D3DXLoadMeshFromXA("../media/meshes/knot.X", D3DXMESH_MANAGED, device, NULL, NULL, NULL, NULL, &mesh));
MYVALID(D3DXCreateTextureFromFileA(device, "../media/textures/intensity.png", &intensity));
MYVALID(device->CreateTexture(screenwidth, screenheight, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &colortarget, NULL));
MYVALID(device->CreateTexture(screenwidth, screenheight, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &normaltarget, NULL));
MYVALID(device->CreateTexture(screenwidth, screenheight, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &edgetarget, NULL));
MYVALID(device->CreateVertexDeclaration(decl, &vertexdecl));
edgetarget->GetSurfaceLevel(0, &edgesurface);
colortarget->GetSurfaceLevel(0, &colorsurface);
normaltarget->GetSurfaceLevel(0, &normalsurface);
MYVALID(device->CreateTexture(512, 512, 1, 0, D3DFMT_A8R8G8B8, D3DPOOL_MANAGED, &text, NULL));
MYVALID(DXCreateEffect("../media/shaders/celshading.fx", device, &effect));
DXRenderText(HELP_TEXT, text, 512, 512);
D3DXVECTOR3 eye(0.5f, 0.5f, -1.5f);
D3DXVECTOR3 look(0, 0, 0);
D3DXVECTOR3 up(0, 1, 0);
D3DXMatrixPerspectiveFovLH(&proj, D3DX_PI / 3, (float)screenwidth / (float)screenheight, 0.1f, 10);
D3DXMatrixLookAtLH(&view, &eye, &look, &up);
D3DXMatrixIdentity(&world);
return S_OK;
}
bool CAXModel::Load(const char* strFileName)
{
this->Unload();
m_strFile = strFileName;
LPD3DXBUFFER pAdjacencyBuffer = NULL;
LPD3DXBUFFER pMtrlBuffer = NULL;
if (FAILED(D3DXLoadMeshFromXA(m_strFile.c_str(), D3DXMESH_MANAGED, APROJECT_WINDOW->GetD3DDevice(), &pAdjacencyBuffer, &pMtrlBuffer, NULL, &m_dwNumMaterials, &m_pMeshObject)))
return false;
// Optimize the mesh for performance
if (FAILED(m_pMeshObject->OptimizeInplace(D3DXMESHOPT_COMPACT | D3DXMESHOPT_ATTRSORT | D3DXMESHOPT_VERTEXCACHE, (DWORD*)pAdjacencyBuffer->GetBufferPointer(), NULL, NULL, NULL)))
{
SAFE_RELEASE(pAdjacencyBuffer);
SAFE_RELEASE(pMtrlBuffer);
return false;
}
D3DXMATERIAL* d3dxMtrls = (D3DXMATERIAL*)pMtrlBuffer->GetBufferPointer();
do
{
if (d3dxMtrls && m_dwNumMaterials > 0)
{
// Allocate memory for the materials and textures
m_pMaterials = new D3DMATERIAL9[m_dwNumMaterials];
if (m_pMaterials == NULL)
break;
m_pTextures = new LPDIRECT3DBASETEXTURE9[m_dwNumMaterials];
if (m_pTextures == NULL)
break;
m_strMaterials = new CHAR[m_dwNumMaterials][MAX_PATH];
if (m_strMaterials == NULL)
break;
// Copy each material and create its texture
for (DWORD i = 0; i < m_dwNumMaterials; i++)
{
// Copy the material
m_pMaterials[i] = d3dxMtrls[i].MatD3D;
m_pTextures[i] = NULL;
// Create a texture
if (d3dxMtrls[i].pTextureFilename)
{
strcpy_s(m_strMaterials[i], MAX_PATH, d3dxMtrls[i].pTextureFilename);
CHAR strTexture[MAX_PATH];
D3DXIMAGE_INFO ImgInfo;
// First attempt to look for texture in the same folder as the input folder.
int p = 0;
strcpy_s(strTexture, MAX_PATH, m_strFile.c_str());
for (DWORD j = 0; j < strlen(strTexture); j++)
{
if (strTexture[j] == '/')
p = j;
}
strTexture[p + 1] = 0;
strcat_s(strTexture, MAX_PATH, d3dxMtrls[i].pTextureFilename);
// Inspect the texture file to determine the texture type.
if (FAILED(D3DXGetImageInfoFromFileA(strTexture, &ImgInfo)))
continue;
// Call the appropriate loader according to the texture type.
switch (ImgInfo.ResourceType)
{
case D3DRTYPE_TEXTURE:
{
IDirect3DTexture9* pTex;
if (SUCCEEDED(D3DXCreateTextureFromFileA(APROJECT_WINDOW->GetD3DDevice(), strTexture, &pTex)))
{
pTex->QueryInterface(IID_IDirect3DBaseTexture9, (LPVOID*)&m_pTextures[i]);
pTex->Release();
}
break;
}
case D3DRTYPE_CUBETEXTURE:
{
IDirect3DCubeTexture9* pTex;
if (SUCCEEDED(D3DXCreateCubeTextureFromFileA(APROJECT_WINDOW->GetD3DDevice(), strTexture, &pTex)))
{
pTex->QueryInterface(IID_IDirect3DBaseTexture9, (LPVOID*)&m_pTextures[i]);
pTex->Release();
}
break;
}
case D3DRTYPE_VOLUMETEXTURE:
{
IDirect3DVolumeTexture9* pTex;
if (SUCCEEDED(D3DXCreateVolumeTextureFromFileA(APROJECT_WINDOW->GetD3DDevice(), strTexture, &pTex)))
{
pTex->QueryInterface(IID_IDirect3DBaseTexture9, (LPVOID*)&m_pTextures[i]);
pTex->Release();
}
break;
}
}
}
}
}
} while (0);
// Extract data from m_pMesh for easy access
D3DVERTEXELEMENT9 decl[MAX_FVF_DECL_SIZE];
m_dwNumVertices = m_pMeshObject->GetNumVertices();
m_dwNumFaces = m_pMeshObject->GetNumFaces();
m_dwBytesPerVertex = m_pMeshObject->GetNumBytesPerVertex();
m_pMeshObject->GetIndexBuffer(&m_pIB);
m_pMeshObject->GetVertexBuffer(&m_pVB);
m_pMeshObject->GetDeclaration(decl);
APROJECT_WINDOW->GetD3DDevice()->CreateVertexDeclaration(decl, &m_pDecl);
SAFE_RELEASE(pAdjacencyBuffer);
SAFE_RELEASE(pMtrlBuffer);
return true;
}
//------------------------------------------------------------------------------------------
HRESULT CModel::LoadFromFile( const std::string& i_strFilePath )
{
HRESULT hr;
// パスを保持
m_strFilePath = i_strFilePath;
// 作成前に破棄
Destroy();
/// 作成 ///
IDirect3DDevice9* pd3dDevice = CApp::GetInstance()->GetGraphicDevice()->GetD3DDevice();
V_RETURN( D3DXLoadMeshFromXA( m_strFilePath.c_str(), D3DXMESH_MANAGED, pd3dDevice, NULL, NULL, NULL, NULL, &m_pMesh));
// 法線＆接線ベクトルを作成
{
// 法線と接線をもつ頂点宣言を作成
D3DVERTEXELEMENT9 vertDecl[] =
{
{ 0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0 },
{ 0, 12, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_NORMAL, 0 },
{ 0, 24, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0 },
{ 0, 32, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TANGENT, 0 },
{ 0, 44, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BINORMAL, 0 },
D3DDECL_END()
};
// 元のメッシュのコピー用（新頂点宣言を適用したもの）と接線生成後の格納用メッシュ
LPD3DXMESH clonedMesh, newMesh;
// 新しい頂点宣言をもつメッシュへコピー
hr = m_pMesh->CloneMesh(D3DXMESH_VB_MANAGED, vertDecl, pd3dDevice, &clonedMesh); MY_ASSERT( SUCCEEDED(hr) );
// 法線をもつか
bool bHasNormal = (m_pMesh->GetFVF() & D3DFVF_NORMAL) != 0;
// 接線を生成
hr = D3DXComputeTangentFrameEx( clonedMesh, D3DDECLUSAGE_TEXCOORD, 0, D3DDECLUSAGE_TANGENT, 0,
D3DDECLUSAGE_BINORMAL, 0
, bHasNormal ? D3DX_DEFAULT : D3DDECLUSAGE_NORMAL
, 0
, bHasNormal ? 0 : D3DXTANGENT_CALCULATE_NORMALS
, NULL, 0.01f, 0.25f, 0.01f, &newMesh, NULL ); MY_ASSERT( SUCCEEDED(hr) );
// メッシュを解放
m_pMesh->Release();
clonedMesh->Release();
// 接線の生成されたメッシュを保持
m_pMesh = newMesh;
// 各バッファを取得
D3DVERTEXELEMENT9 declaration[MAX_FVF_DECL_SIZE];
hr = m_pMesh->GetDeclaration( declaration ); MY_ASSERT( SUCCEEDED(hr) );
pd3dDevice->CreateVertexDeclaration( declaration, &m_pDeclaration );
hr = m_pMesh->GetVertexBuffer( &m_pVertexBuffer ); MY_ASSERT( SUCCEEDED(hr) );
hr = m_pMesh->GetIndexBuffer( &m_pIndexBuffer ); MY_ASSERT( SUCCEEDED(hr) );
}
return S_OK;
}
//-----------------------------------------------------------------------------
// The mesh class constructor.
//-----------------------------------------------------------------------------
Mesh::Mesh( char *name, char *path ) : Resource< Mesh >( name, path )
{
// Create the list of reference points.
m_frames = new LinkedList< Frame >;
m_refPoints = new LinkedList< Frame >;
// Load the mesh's frame hierarchy.
AllocateHierarchy ah;
D3DXLoadMeshHierarchyFromXA( GetFilename(), D3DXMESH_MANAGED, g_engine->GetDevice(), &ah, NULL, (D3DXFRAME**)&m_firstFrame, &m_animationController );
// Disable all the animation tracks initially.
if( m_animationController != NULL )
for( unsigned long t = 0; t < m_animationController->GetMaxNumTracks(); ++t )
m_animationController->SetTrackEnable( t, false );
// Invalidate the bone transformation matrices array.
m_boneMatrices = NULL;
m_totalBoneMatrices = 0;
// Prepare the frame hierarchy.
PrepareFrame( m_firstFrame );
// Allocate memory for the bone matrices.
m_boneMatrices = new D3DXMATRIX[m_totalBoneMatrices];
// Create a static (non-animated) version of the mesh.
m_staticMesh = new MeshContainer;
ZeroMemory( m_staticMesh, sizeof( MeshContainer ) );
// Load the mesh.
ID3DXBuffer *materialBuffer, *adjacencyBuffer;
D3DXLoadMeshFromXA( GetFilename(), D3DXMESH_MANAGED, g_engine->GetDevice(), &adjacencyBuffer, &materialBuffer, NULL, &m_staticMesh->NumMaterials, &m_staticMesh->originalMesh );
// Optimise the mesh for better rendering performance.
m_staticMesh->originalMesh->OptimizeInplace( D3DXMESHOPT_COMPACT | D3DXMESHOPT_ATTRSORT | D3DXMESHOPT_VERTEXCACHE, (DWORD*)adjacencyBuffer->GetBufferPointer(), NULL, NULL, NULL );
// Finished with the adjacency buffer, so destroy it.
SAFE_RELEASE( adjacencyBuffer );
// Check if the mesh has any materials.
if( m_staticMesh->NumMaterials > 0 )
{
// Create the array of materials.
m_staticMesh->materials = new Material*[m_staticMesh->NumMaterials];
// Get the list of materials from the material buffer.
D3DXMATERIAL *materials = (D3DXMATERIAL*)materialBuffer->GetBufferPointer();
// Load each material into the array via the material manager.
for( unsigned long m = 0; m < m_staticMesh->NumMaterials; m++ )
{
// Ensure the material has a texture.
if( materials[m].pTextureFilename )
{
// Get the name of the material's script and load it.
char *name = new char[strlen( materials[m].pTextureFilename ) + 5];
sprintf( name, "%s.txt", materials[m].pTextureFilename );
m_staticMesh->materials[m] = g_engine->GetMaterialManager()->Add( name, GetPath() );
SAFE_DELETE_ARRAY( name );
}
else
m_staticMesh->materials[m] = NULL;
}
}
// Create the bounding volume around the mesh.
BoundingVolumeFromMesh( m_staticMesh->originalMesh );
// Destroy the material buffer.
SAFE_RELEASE( materialBuffer );
// Create a vertex array and an array of indices into the vertex array.
m_vertices = new Vertex[m_staticMesh->originalMesh->GetNumVertices()];
m_indices = new unsigned short[m_staticMesh->originalMesh->GetNumFaces() * 3];
// Use the arrays to store a local copy of the static mesh's vertices and
// indices so that they can be used by the scene manager on the fly.
Vertex* verticesPtr;
m_staticMesh->originalMesh->LockVertexBuffer( 0, (void**)&verticesPtr );
unsigned short *indicesPtr;
m_staticMesh->originalMesh->LockIndexBuffer( 0, (void**)&indicesPtr );
memcpy( m_vertices, verticesPtr, VERTEX_FVF_SIZE * m_staticMesh->originalMesh->GetNumVertices() );
memcpy( m_indices, indicesPtr, sizeof( unsigned short ) * m_staticMesh->originalMesh->GetNumFaces() * 3 );
m_staticMesh->originalMesh->UnlockVertexBuffer();
m_staticMesh->originalMesh->UnlockIndexBuffer();
}
HRESULT InitScene()
{
HRESULT hr;
LPD3DXBUFFER errors = NULL;
SetWindowText(hwnd, TITLE);
if( FAILED(hr = D3DXLoadMeshFromXA("../media/meshes/sphere.X", D3DXMESH_MANAGED, device, NULL, NULL, NULL, NULL, &mesh)) )
{
MYERROR("Could not load sphere");
return hr;
}
// generate tangent frame
LPD3DXMESH newmesh = NULL;
D3DVERTEXELEMENT9 decl[] =
{
{ 0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0 },
{ 0, 12, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0 },
{ 0, 20, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_NORMAL, 0 },
{ 0, 32, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TANGENT, 0 },
{ 0, 44, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BINORMAL, 0 },
D3DDECL_END()
};
if( FAILED(hr = mesh->CloneMesh(D3DXMESH_MANAGED, decl, device, &newmesh)) )
{
MYERROR("Could not clone mesh");
return hr;
}
mesh->Release();
mesh = NULL;
hr = D3DXComputeTangentFrameEx(newmesh,
D3DDECLUSAGE_TEXCOORD, 0,
D3DDECLUSAGE_TANGENT, 0,
D3DDECLUSAGE_BINORMAL, 0,
D3DDECLUSAGE_NORMAL, 0,
0, NULL, 0.01f, 0.25f, 0.01f, &mesh, NULL);
newmesh->Release();
if( FAILED(hr) )
{
MYERROR("Could not compute tangent frame");
return hr;
}
if( FAILED(hr = CreateChecker(device, 10, 10, 0xff7557a8, 0xffd8d8d8, &tex)) )
{
MYERROR("Could not create texture");
return hr;
}
if( FAILED(hr = D3DXCreateTextureFromFileA(device, "../media/textures/brick_nh.dds", &normalmap)) )
{
MYERROR("Could not load normalmap");
return hr;
}
hr = D3DXCreateEffectFromFileA(device, "../media/shaders/normal.fx", NULL, NULL, D3DXSHADER_DEBUG, NULL, &effect, &errors);
if( FAILED(hr) )
{
if( errors )
{
char* str = (char*)errors->GetBufferPointer();
std::cout << str << "\n\n";
errors->Release();
}
MYERROR("Could not create effect");
return hr;
}
D3DXVECTOR4 uv(3, 1, 0, 1);
effect->SetVector("normuv", &uv);
D3DXVECTOR3 eye(0, 0, -1.5f);
D3DXVECTOR3 look(0, 0, 0);
D3DXVECTOR3 up(0, 1, 0);
D3DXMatrixPerspectiveFovLH(&proj, D3DX_PI / 3, (float)screenwidth / (float)screenheight, 0.1f, 10);
D3DXMatrixLookAtLH(&view, &eye, &look, &up);
D3DXMatrixIdentity(&world);
return S_OK;
}
HRESULT InitScene()
{
HRESULT hr;
D3DCAPS9 caps;
SetWindowText(hwnd, TITLE);
device->GetDeviceCaps(&caps);
if( caps.VertexShaderVersion < D3DVS_VERSION(2, 0) || caps.PixelShaderVersion < D3DPS_VERSION(2, 0) )
{
MYERROR("This demo requires Shader Model 2.0 capable video card");
return E_FAIL;
}
palm = new DXObject(device);
sandplane = new DXObject(device);
waterplane = new DXObject(device);
if( !palm->Load("../media/meshes/palm.qm") )
{
MYERROR("Could not load palm");
return E_FAIL;
}
if( !sandplane->CreatePlane(50, 50, 10, 10) )
{
MYERROR("Could not create sand plane");
return E_FAIL;
}
if( !waterplane->CreatePlane(50, 50, 5, 5) )
{
MYERROR("Could not create water plane");
return E_FAIL;
}
waterplane->GenerateTangentFrame();
MYVALID(D3DXLoadMeshFromXA("../media/meshes/sky.X", D3DXMESH_MANAGED, device, NULL, NULL, NULL, NULL, &skymesh));
MYVALID(D3DXCreateCubeTextureFromFileA(device, "../media/textures/sky7.dds", &skytex));
MYVALID(D3DXCreateTextureFromFileA(device, "../media/textures/bark.jpg", &bark));
MYVALID(D3DXCreateTextureFromFileA(device, "../media/textures/leaf.jpg", &leaves));
MYVALID(D3DXCreateTextureFromFileA(device, "../media/textures/sand.jpg", &sand));
MYVALID(D3DXCreateTextureFromFileA(device, "../media/textures/wave2.png", &waves));
MYVALID(DXCreateEffect("../media/shaders/ambient.fx", device, &ambient));
MYVALID(DXCreateEffect("../media/shaders/blinnphong.fx", device, &specular));
MYVALID(DXCreateEffect("../media/shaders/water.fx", device, &water));
MYVALID(DXCreateEffect("../media/shaders/simplebloom.fx", device, &bloom));
MYVALID(DXCreateEffect("../media/shaders/godray.fx", device, &godray));
MYVALID(DXCreateEffect("../media/shaders/sky.fx", device, &skyeffect));
MYVALID(device->CreateTexture(screenwidth, screenheight, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A16B16G16R16F, D3DPOOL_DEFAULT, &refraction, NULL));
MYVALID(device->CreateTexture(screenwidth, screenheight, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A16B16G16R16F, D3DPOOL_DEFAULT, &reflection, NULL));
MYVALID(device->CreateTexture(screenwidth, screenheight, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8, D3DPOOL_DEFAULT, &occluders, NULL));
MYVALID(device->CreateTexture(screenwidth, screenheight, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8, D3DPOOL_DEFAULT, &blurtex, NULL));
MYVALID(device->CreateTexture(screenwidth, screenheight, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &sceneldr, NULL));
MYVALID(device->CreateTexture(screenwidth / 2, screenheight / 2, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &bloomtex1, NULL));
MYVALID(device->CreateTexture(screenwidth / 2, screenheight / 2, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &bloomtex2, NULL));
refraction->GetSurfaceLevel(0, &refractsurf);
reflection->GetSurfaceLevel(0, &reflectsurf);
occluders->GetSurfaceLevel(0, &occludersurf);
blurtex->GetSurfaceLevel(0, &blursurf);
sceneldr->GetSurfaceLevel(0, &sceneldrsurf);
bloomtex1->GetSurfaceLevel(0, &bloomsurf1);
bloomtex2->GetSurfaceLevel(0, &bloomsurf2);
D3DVERTEXELEMENT9 elem[] =
{
{ 0, 0, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITIONT, 0 },
{ 0, 16, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0 },
D3DDECL_END()
};
MYVALID(device->CreateVertexDeclaration(elem, &quaddecl));
cameraangle = D3DXVECTOR2(-1.13f * D3DX_PI, 0.55f);
return S_OK;
}