void RaceScene::Exit()
{
mSceneManager->destroy();
ITextureManager* textureManager = ITextureManager::getInstance();
textureManager->destroy(mTireTrailDepthSurface->getTexture());
textureManager->destroy(mTireTrailTexture);
}
void IRenderer::mFunction_GraphicObj_RenderTriangle2DInList(std::vector<IGraphicObject*>* pList)
{
//prepare to draw , various settings.....
ID3D11Buffer* tmp_pVB = NULL;
ITextureManager* pTexMgr = GetScene()->GetTextureMgr();
mFunction_SetRasterState(NOISE_FILLMODE_SOLID, NOISE_CULLMODE_NONE);
for (UINT i = 0;i < pList->size();i++)
{
//----------------------1,draw common triangle----------------------
tmp_pVB = pList->at(i)->m_pVB_GPU[NOISE_GRAPHIC_OBJECT_TYPE_TRIANGLE_2D];
g_pImmediateContext->IASetInputLayout(g_pVertexLayout_Simple);
g_pImmediateContext->IASetVertexBuffers(0, 1, &tmp_pVB, &c_VBstride_Simple, &c_VBoffset);
g_pImmediateContext->IASetIndexBuffer(NULL, DXGI_FORMAT_R32_UINT, 0);
g_pImmediateContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
UINT j = 0, vCount = 0;
//traverse all region list , to decide use which tech to draw (textured or not)
m_pFX_Tech_Solid2D->GetPassByIndex(0)->Apply(0, g_pImmediateContext);
vCount = pList->at(i)->GetTriangle2DCount() * 3;
if (vCount>0)g_pImmediateContext->Draw(pList->at(i)->GetTriangle2DCount() * 3, 0);
//---------------------2,draw rectangles---------------------
tmp_pVB = pList->at(i)->m_pVB_GPU[NOISE_GRAPHIC_OBJECT_TYPE_RECT_2D];
g_pImmediateContext->IASetInputLayout(g_pVertexLayout_Simple);
g_pImmediateContext->IASetVertexBuffers(0, 1, &tmp_pVB, &c_VBstride_Simple, &c_VBoffset);
g_pImmediateContext->IASetIndexBuffer(NULL, DXGI_FORMAT_R32_UINT, 0);
g_pImmediateContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
for (auto tmpRegion : *(pList->at(i)->m_pRectSubsetInfoList))
{
//if current Rectangle disable Texture ,then draw in a solid way
//thus validate the UID first
if (pTexMgr->FindUid(tmpRegion.texName)==FALSE)
{
//draw with solid texture
m_pFX_Tech_Solid2D->GetPassByIndex(0)->Apply(0, g_pImmediateContext);
}
else
{
//------Draw 2D Common Texture-----
mFunction_GraphicObj_Update_RenderTextured2D(tmpRegion.texName);
m_pFX_Tech_Textured2D->GetPassByIndex(0)->Apply(0, g_pImmediateContext);
}
//draw
vCount = tmpRegion.vertexCount;
if (vCount>0)g_pImmediateContext->Draw(tmpRegion.vertexCount, tmpRegion.startID);
}
}
//清空渲染列表
pList->clear();
}
void RaceScene::Enter()
{
mFollowCamera = mSceneManager->addFpsCameraNode(2, nullptr, XMFLOAT3(0, 100.0f, -100.0f), XMFLOAT3(0, 1.0f, 0.0f), XMFLOAT3(0, 1.0f, 0), true);
mFollowCamera->setNearZ(1.0f);
mFollowCamera->setFarZ(1000.0f);
mFollowCamera->setShadowRange(300.0f);
mSideCamera = mSceneManager->addFpsCameraNode(3, nullptr);
mSideCamera->setNearZ(1.0f);
mSideCamera->setFarZ(1000.0f);
mSideCamera->setShadowRange(300.0f);
mPlayerVehicle = new Vehicle(mSceneManager, mTerrainNode, "carA");
mSceneManager->setActiveCamera(2);
XMFLOAT3 camPos = mFreeCamera->getPosition();
mPlayerVehicle->setPosition(camPos);
mFreeCamera->update(0);
XMFLOAT3 look = mFreeCamera->getLookVector();
XMVECTOR look_v = XMVector3Normalize(XMVectorSet(look.x, 0, look.z, 0));
XMVECTOR neg_x_v = XMVectorSet(-1.0f, 0, 0, 0);
XMVECTOR axis = XMVector3Normalize(XMVector3Cross(neg_x_v, look_v));
XMVECTOR angle = XMVector3AngleBetweenNormals(neg_x_v, look_v);
XMVECTOR quat_v = XMQuaternionRotationAxis(axis, XMVectorGetX(angle));
XMFLOAT4 quat;
XMStoreFloat4(&quat, quat_v);
mPlayerVehicle->setRotation(quat);
mVideoDriver->setDeferredAntiAliasing(true);
IMeshNode* skyNode = mSceneManager->getSkyNode();
if (skyNode)
skyNode->setMaterialName("skydome_material");
u32 textureWidth = mVideoDriver->getBackBufferWidth() / 2;
u32 textureHeight = mVideoDriver->getBackBufferHeight() / 2;
ITextureManager* textureManager = ITextureManager::getInstance();
mTireTrailTexture = textureManager->createTexture2D("tire_trail",
textureWidth,
textureHeight,
ETBT_SHADER_RESOURCE | ETBT_RENDER_TARGET,
nullptr, 1, EGF_R16_FLOAT);
mTireTrailDepthSurface = textureManager->createDepthStencilSurface("tire_trail_depth",
textureWidth,
textureHeight,
16, 0, false, 1, 0, false, false);
}
void Material::initialize()
{
ITextureManager *pTextureManager = getRenderEngine()->getRenderSystem()->getTextureManager();
size_t size = m_vLayers.size();
for(size_t i = 0;i < size;i++)
{
MaterialLayer& layer = m_vLayers[i];
if(!layer.m_szTexture.empty())
{
layer.m_pTexture = pTextureManager->createTextureFromFile(layer.m_szTexture,FO_LINEAR,FO_LINEAR,FO_LINEAR);
}
}
}
//invoked by RenderTriangle(when needed)
void IRenderer::mFunction_GraphicObj_Update_RenderTextured2D(N_UID texName)
{
//Get Shader Resource View
ID3D11ShaderResourceView* tmp_pSRV = NULL;
ITextureManager* pTexMgr = GetScene()->GetTextureMgr();
//......
BOOL IsUidValid = pTexMgr->ValidateUID(texName, NOISE_TEXTURE_TYPE_COMMON);
if (IsUidValid)
{
tmp_pSRV = pTexMgr->GetObjectPtr(texName)->m_pSRV;
m_pFX2D_Texture_Diffuse->SetResource(tmp_pSRV);
}
}
void testCreateTexture1D()
{
ITextureManager* textureManager = ITextureManager::getInstance();
u32 width = 256;
std::vector<f32> data;
data.resize(width);
for (u32 i = 0; i < width; i++)
{
data[i] = i * 1.0f / width;
}
ITexture* texture = textureManager->createTexture1D("test_texture_1d", width,
ETBT_SHADER_RESOURCE, &data[0], 1, EGF_R32_FLOAT);
IMaterial* material = IMaterialManager::getInstance()->get("ground_material");
material->setTexture(0, texture);
}
void CBlurCompositor::gaussBlur(ISceneManager* smgr, bool lastCompositor)
{
IVideoDriver* driver = smgr->getVideoDriver();
ITextureManager* tmgr = ITextureManager::getInstance();
IRenderTarget* input = driver->getRenderTarget();
IRenderTarget* output = tmgr->getTempRenderTarget(input->getWidth(), input->getHeight(), input->getFormat());
IMeshNode* quad = smgr->getQuadNode();
quad->setMaterial(&mMaterial);
IPipelineManager* pipelineManager = IPipelineManager::getInstance();
IPipeline* vblurPipeline = pipelineManager->get("gf/gauss_vertical_blur");
IPipeline* hblurPipeline = pipelineManager->get("gf/gauss_horizontal_blur");
// render pass - 1
for (u32 i = 0; i < mPassCount - 1; i++)
{
// vertical blur
mMaterial.setPipeline(vblurPipeline);
renderQuad(driver, smgr, quad, input, output);
// horizontal blur
mMaterial.setPipeline(hblurPipeline);
renderQuad(driver, smgr, quad, output, input);
}
// render last pass
mMaterial.setPipeline(vblurPipeline);
renderQuad(driver, smgr, quad, input, output);
mMaterial.setPipeline(hblurPipeline);
if (lastCompositor)
{
renderQuad(driver, smgr, quad, output, nullptr);
tmgr->releaseTempRenderTarget(output);
}
else
{
renderQuad(driver, smgr, quad, output, input);
}
tmgr->releaseTempRenderTarget(input);
}
bool CD3D11Driver::setupGBuffer()
{
if (mGBuffers[0])
return false;
ITextureManager* textureManager = ITextureManager::getInstance();
std::string textureNames[] = { "gbuffer0", "gbuffer1", "gbuffer2", "gbuffer3" };
E_GI_FORMAT formats[] = { EGF_R32G32B32A32_FLOAT, EGF_R8G8B8A8_UNORM, EGF_R8G8B8A8_UNORM, EGF_R8G8B8A8_UNORM };
for (u32 i = 0; i < EGT_GBUFFER_COUNT; i++)
{
IRenderTarget* pTarget = textureManager->createRenderTarget(textureNames[i], 0, 0, formats[i]);
assert("set up gbuffer failed!");
mGBuffers[i] = pTarget;
}
return true;
}
void SubModelInstance::setTexture(int layer,const char* szName)
{
Assert(layer >= 0 && layer < m_mtlOrigin.numLayers());
MaterialLayer *pLayer = m_mtl.getLayer(layer);
const std::string& textureName = pLayer->m_szTexture;
if(StringHelper::casecmp(textureName,szName) == 0)return;
safeRelease(pLayer->m_pTexture);
pLayer->m_szTexture = "";
if(!szName)return;
IRenderEngine *pRenderEngine = getRenderEngine();
IRenderSystem *pRenderSystem = pRenderEngine->getRenderSystem();
ITextureManager *pTextureManager = pRenderSystem->getTextureManager();
pLayer->m_pTexture = pTextureManager->createTextureFromFile(szName,FO_LINEAR,FO_LINEAR,FO_LINEAR);
if(pLayer->m_pTexture)
{
pLayer->m_szTexture = szName;
}
}
void LoadingScene::setupScene()
{
math::SAxisAlignedBox aabb;
aabb.Center = XMFLOAT3(0, 0.0f, 0);
aabb.Extents = XMFLOAT3(3000.0f, 1000.0f, 3000.0f);
ISceneManager* smgr = mDevice->createSceneManager(aabb);
mSceneManager = smgr;
IMeshManager* meshManager = IMeshManager::getInstance();
ISimpleMesh* cubeMesh = meshManager->createCubeMesh("debug_loading", 3.0f, 3.0f, 3.0f);
IMeshNode* meshNode = smgr->addMeshNode(cubeMesh, nullptr, nullptr, false);
meshNode->setMaterialName("picking_cube_material");
ICameraNode* camera = smgr->addFpsCameraNode(1, nullptr, XMFLOAT3(0, 0.0f, -15.0f),
XMFLOAT3(0, 0, 0.0f), XMFLOAT3(0, 1.0f, 0), true);
mVideoDriver->setDeferredShading(false);
ITextureManager* textureManager = ITextureManager::getInstance();
mLoadingImage = textureManager->get("loading_image.jpg");
}
void CBlurCompositor::squareBlur(ISceneManager* smgr, bool lastCompositor)
{
IVideoDriver* driver = smgr->getVideoDriver();
ITextureManager* tmgr = ITextureManager::getInstance();
IRenderTarget* input = driver->getRenderTarget();
IRenderTarget* output = nullptr;
IMeshNode* quad = smgr->getQuadNode();
quad->setMaterial(&mMaterial);
if (mPassCount == 1)
{
if (!lastCompositor)
output = tmgr->getTempRenderTarget(input->getWidth(), input->getHeight(), input->getFormat());
renderQuad(driver, smgr, quad, input, output);
tmgr->releaseTempRenderTarget(input);
}
else
{
output = tmgr->getTempRenderTarget(input->getWidth(), input->getHeight(), input->getFormat());
// render pass - 1
for (u32 i = 0; i < mPassCount - 1; i++)
{
renderQuad(driver, smgr, quad, input, output);
std::swap(input, output);
}
// render the last pass
if (!lastCompositor)
{
renderQuad(driver, smgr, quad, input, output);
}
else
{
renderQuad(driver, smgr, quad, input, nullptr);
tmgr->releaseTempRenderTarget(output);
}
tmgr->releaseTempRenderTarget(input);
}
}
void CPointLightNode::generateShadowMap(ICameraNode* viewCamera)
{
ITextureManager* tmgr = ITextureManager::getInstance();
if (mCastShadow)
{
if (!mShadowMapTexture)
{
std::string name = "_point_shadow_map_";
name += getId();
mShadowMapTexture = tmgr->createTextureCube(name, mShadowMapWidth,
ETBT_SHADER_RESOURCE | ETBT_RENDER_TARGET, nullptr, 1, EGF_R32_FLOAT);
}
ICameraNode* camera = mSceneManager->getActiveCameraNode();
camera->setPerspectiveProjection(true);
XMFLOAT3 pos = getAbsolutePosition();
camera->setPosition(pos);
camera->setFovAngle(XM_PIDIV2);
camera->setNearZ(0.1f);
camera->setFarZ(mLightData.Range);
camera->setAspectRatio(1.0f);
//const
const static XMFLOAT3 looks[] = {
XMFLOAT3(1.0f, 0, 0), //+x
XMFLOAT3(-1.0f, 0, 0), //-x
XMFLOAT3(0, 1.0f, 0), //+y
XMFLOAT3(0, -1.0f, 0), //-y
XMFLOAT3(0, 0, 1.0f), //+z
XMFLOAT3(0, 0, -1.0f) //-z
};
const static XMFLOAT3 ups[] = {
XMFLOAT3(0.0f, 1.0f, 0.0f), // +X
XMFLOAT3(0.0f, 1.0f, 0.0f), // -X
XMFLOAT3(0.0f, 0.0f, -1.0f), // +Y
XMFLOAT3(0.0f, 0.0f, +1.0f), // -Y
XMFLOAT3(0.0f, 1.0f, 0.0f), // +Z
XMFLOAT3(0.0f, 1.0f, 0.0f) // -Z
};
IVideoDriver* driver = mSceneManager->getVideoDriver();
IDepthStencilSurface* pDepthStencilSurface = tmgr->getTempDepthStencilSurface(
mShadowMapWidth, mShadowMapWidth, 32, 0);
driver->setPipelineUsage(EPU_POINT_SHADOW_MAP);
for (u32 i = 0; i < 6; i++)
{
camera->look(looks[i], ups[i]);
camera->updateAbsoluteTransformation();
IRenderTarget* pRenderTarget = mShadowMapTexture->getRenderTarget(i);
driver->setRenderTargetAndDepthStencil(pRenderTarget, pDepthStencilSurface);
const f32 clearColor[] = { 1000.0f, 1000.0f, 1000.0f, 1000.0f };
pRenderTarget->clear(clearColor);
driver->clearDepthStencil(1.0f, 0);
mSceneManager->drawShadowMap(this);
}
tmgr->releaseTempDepthStencilSurface(pDepthStencilSurface);
}
}
int main()
{
SDeviceContextSettings settings;
settings.MultiSamplingCount = 4;
settings.MultiSamplingQuality = 32;
IApplication* device = gf::createDevice(EDT_DIRECT3D11, SCREEN_WIDTH, SCREEN_HEIGHT, EWS_NONE, true, settings);
IVideoDriver* driver = device->getVideoDriver();
ISceneManager* smgr = device->createSceneManager();
IMeshManager* meshManager = driver->getMeshManager();
IMaterialManager* materialManager = driver->getMaterialManager();
ITextureManager* textureManager = driver->getTextureManager();
IResourceGroupManager* resourceGroupManager = driver->getResourceGroupManager();
resourceGroupManager->init("Resources.cfg");
// resourceGroupManager->loadResourceGroup("General");
ILightNode* light = smgr->addDirectionalLight(1, nullptr, XMFLOAT3(3.0f, -2.0f, 1.5f));
light->setSpecular(XMFLOAT4(1.0f, 1.0f, 1.0f, 32.0f));
light->setDiffuse(XMFLOAT4(0.4f, 0.4f, 0.4f, 1.0f));
ILightNode* light2 = smgr->addDirectionalLight(2, nullptr, XMFLOAT3(-2.0f, -3.0f, -2.0f));
light2->setSpecular(XMFLOAT4(1.0f, 1.0f, 1.0f, 32.0f));
light2->setDiffuse(XMFLOAT4(0.5f, 0.5f, 0.5f, 1.0f));
ICameraNode* camera = smgr->addFpsCameraNode(1, nullptr, XMFLOAT3(0, 30.0f, -4.0f), XMFLOAT3(0, 30.0f, 0.0f), XMFLOAT3(0, 1.0f, 0), true);
camera->setViewWidth(300);
camera->setViewHeight(200);
char caption[200];
std::string rawFileName("heightmap.raw");
ITerrainMesh* mesh = meshManager->createTerrainMesh("terrain", rawFileName,
3.0f, 0.4f, false, true, 1.0f);
ITerrainNode* terrainNode = smgr->addTerrainNode(mesh);
//terrainNode->setMaterialName("terrain/tessellation_material");
terrainNode->setMaterialName("terrain/terrain_material");
ITextureCube* skyTexture = textureManager->loadCubeTexture("Snow.dds");
smgr->setSkyDome(skyTexture);
IRenderTarget* pRenderTarget = textureManager->getRenderTarget("target1");
ITimer* timer = device->getTimer();
timer->reset();
while (device->run())
{
const float clearColor[] = { 0.0f, 0.0f, 0.0f, 1.0f };
driver->beginScene(true, true, clearColor);
u32 ms = timer->tick();
float dt = ms * 0.001f;
updateCamera(camera, dt);
XMFLOAT3 camPos = camera->getPosition();
float terrainHeight = terrainNode->getHeight(camPos.x, camPos.z, true);
camPos.y = terrainHeight + 3.0f;
//camera->setPosition(camPos);
smgr->update(ms);
smgr->drawAll();
driver->endScene();
u32 num = smgr->getRenderedMeshNum();
sprintf(caption, "FPS:%f num:%d", getFps(dt), num);
device->setWindowCaption(caption);
}
smgr->destroy();
device->drop();
return 0;
}
int _tmain(int argc, _TCHAR* argv[])
{
SDeviceContextSettings settings;
settings.MultiSamplingCount = 4;
settings.MultiSamplingQuality = 32;
IDevice* device = gf::createDevice(EDT_DIRECT3D11, SCREEN_WIDTH, SCREEN_HEIGHT, EWS_NONE, true, settings);
IVideoDriver* driver = device->getVideoDriver();
math::SAxisAlignedBox aabb;
aabb.Center = XMFLOAT3(0, 0.0f, 0);
aabb.Extents = XMFLOAT3(3000.0f, 1000.0f, 3000.0f);
ISceneManager* smgr = device->createSceneManager(aabb);
IMeshManager* meshManager = driver->getMeshManager();
IMaterialManager* materialManager = driver->getMaterialManager();
ITextureManager* textureManager = driver->getTextureManager();
IResourceGroupManager* resourceGroupManager = driver->getResourceGroupManager();
resourceGroupManager->init("Resources.cfg");
ILightNode* light = smgr->addDirectionalLight(1, nullptr, XMFLOAT3(3.0f, -2.0f, 1.5f));
light->setSpecular(XMFLOAT4(1.0f, 1.0f, 1.0f, 32.0f));
light->setDiffuse(XMFLOAT4(0.4f, 0.4f, 0.4f, 1.0f));
light->enableShadow(true);
ICameraNode* camera = smgr->addFpsCameraNode(1, nullptr, XMFLOAT3(0, 30.0f, -4.0f),
XMFLOAT3(0, 30.0f, 0.0f), XMFLOAT3(0, 1.0f, 0), true);
camera->setShadowRange(200.0f);
buildGrassLand(smgr);
ISimpleMesh* groundMesh = meshManager->createPlaneMesh("ground", GROUND_SIZE, GROUND_SIZE, 50, 50, 10.0f, 10.0f);
IMeshNode* groundNode = smgr->addMeshNode(groundMesh, nullptr, nullptr, false);
groundNode->setMaterialName("ground_material");
ITextureCube* skyTexture = textureManager->loadCubeTexture("skybox1.dds");
smgr->setSkyDome(skyTexture);
ITimer* timer = device->getTimer();
timer->reset();
char caption[200];
while (device->run())
{
const float clearColor[] = { 0.0f, 0.0f, 0.0f, 1.0f };
driver->beginScene(true, true, clearColor);
f32 dt = timer->tick();
updateCamera(camera, dt);
g_grassLand->update(dt);
smgr->update(dt);
smgr->drawAll();
driver->endScene();
u32 num = smgr->getRenderedMeshNum();
sprintf(caption, "FPS:%f num:%d", getFps(dt), num);
device->setWindowCaption(caption);
}
smgr->destroy();
device->drop();
return 0;
}
BOOL Init3D(HWND hwnd)
{
const UINT bufferWidth = 640;
const UINT bufferHeight = 480;
//初始化失败
if(!IRoot.InitD3D( hwnd, bufferWidth, bufferHeight,TRUE))return FALSE;
IScene.CreateMesh(Mesh1);
IScene.CreateRenderer(Renderer);
IScene.CreateCamera(ICamera);
IScene.CreateLightManager(LightMgr);
IScene.CreateMaterialManager(MatMgr);
IScene.CreateTextureManager(TexMgr);
IScene.CreateAtmosphere(Atmos);
fontMgr.Initialize();
//漫反射贴图
//TexMgr.CreateTextureFromFile(L"Earth.jpg", "Earth", TRUE,0, 0, TRUE);
//TexMgr.CreatePureColorTexture("myText", 300, 100, NVECTOR4(0.0f, 0.0f, 0.0f, 0.0f), TRUE);
TexMgr.CreateTextureFromFile(L"media/button1.png", "GUI_Button1", TRUE, 0, 0, FALSE);
TexMgr.CreateTextureFromFile(L"media/button2.png", "GUI_Button2", TRUE, 0, 0, FALSE);
TexMgr.CreateTextureFromFile(L"media/button3.png", "GUI_Button3", TRUE, 0, 0, FALSE);
TexMgr.CreateTextureFromFile(L"media/button4.png", "GUI_Button4", TRUE, 0, 0, FALSE);
TexMgr.CreateTextureFromFile(L"media/Earth.jpg","Earth", TRUE,0, 0,FALSE);
TexMgr.CreateTextureFromFile(L"media/Earth.jpg", "EarthNormalMap", TRUE, 0, 0, TRUE);
TexMgr.CreateTextureFromFile(L"media/texture2.jpg", "Wood", TRUE, 0, 0, FALSE);
TexMgr.CreateTextureFromFile(L"media/universe2.jpg", "Universe", FALSE, 512, 512, FALSE);
TexMgr.CreateTextureFromFile(L"media/bottom-right-conner-title.jpg", "BottomRightTitle", TRUE, 0, 0, FALSE);
TexMgr.CreateCubeMapFromDDS(L"media/UniverseEnv.dds", "EnvironmentMap",NOISE_CUBEMAP_SIZE_256x256);
TexMgr.ConvertTextureToGreyMap(TexMgr.GetTextureID("EarthNormalMap"));
TexMgr.ConvertHeightMapToNormalMap(TexMgr.GetTextureID("EarthNormalMap"),20.0f);
//create font texture
fontMgr.CreateFontFromFile("media/STXINWEI.ttf", "myFont", 24);
fontMgr.InitStaticTextW(0, L"TextBox的CapsLock和大小写/ GUI system需不需要重构一下啊....很多Event是比较重复的....= =", 300, 100, NVECTOR4(0, 1.0f, 0.5f, 1.0f), 0, 0, myText1);
myText1.SetTextColor(NVECTOR4(1.0f, 0, 0, 0.5f));
myText1.SetCenterPos(300.0f, 100.0f);
fontMgr.InitDynamicTextA(0, "abcdefghijklmnopqrstuvwxyz!@#$%^&*()_<>-+?/+ 1234567890<>?,./{}[]\\", 300, 100, NVECTOR4(0, 1.0f, 0.5f, 1.0f), 0, 0, myText2);
myText2.SetTextColor(NVECTOR4(0.5f, 0.3f, 1.0f, 0.5f));
myText2.SetCenterPos(300.0f,400.0f);
fontMgr.InitDynamicTextA(0, "fps:000", 200, 100, NVECTOR4(0,0,0,1.0f), 0, 0, myText_fps);
myText_fps.SetTextColor(NVECTOR4(0,0.3f,1.0f,0.5f));
myText_fps.SetDiagonal(NVECTOR2(20, 20),NVECTOR2(150, 60));
myText_fps.SetFont(0);
Renderer.SetFillMode(NOISE_FILLMODE_SOLID);
Renderer.SetCullMode(NOISE_CULLMODE_BACK);//NOISE_CULLMODE_BACK
//Mesh1.LoadFile_STL("object.stl");
Mesh1.CreateSphere(5.0f, 30, 30);
//Mesh1.CreatePlane(10.0f, 10.0f, 5, 5);
Mesh1.SetPosition(0,0,0);
ICamera.SetPosition(2.0f,0,0);
ICamera.SetLookAt(0,0,0);
ICamera.SetViewAngle(MATH_PI / 2.5f, 1.333333333f);
ICamera.SetViewFrustumPlane(1.0f, 500.f);
//use bounding box of mesh to init camera pos
NVECTOR3 AABB_MAX = Mesh1.ComputeBoundingBoxMax();
float rotateRadius = sqrtf(AABB_MAX.x*AABB_MAX.x + AABB_MAX.z*AABB_MAX.z)*1.2f;
float rotateY = Mesh1.ComputeBoundingBoxMax().y*1.3f;
ICamera.SetPosition(rotateRadius*0.7f, rotateY, rotateRadius*0.7f);
ICamera.SetLookAt(0, rotateY / 2, 0);
Atmos.SetFogEnabled(FALSE);
Atmos.SetFogParameter(7.0f, 8.0f, NVECTOR3(0, 0, 1.0f));
Atmos.CreateSkyDome(4.0f, 4.0f, TexMgr.GetTextureID("Universe"));
//Atmos.CreateSkyBox(10.0f, 10.0f, 10.0f, TexMgr.GetIndexByName("EnvironmentMap"));
//——————灯光————————
DirLight1.mAmbientColor = NVECTOR3(1.0f,1.0f,1.0f);
DirLight1.mDiffuseColor = NVECTOR3(1.0f,1.0f,1.0f);
DirLight1.mSpecularColor =NVECTOR3(1.0f,1.0f,1.0f);
DirLight1.mDirection = NVECTOR3(0.0f, -0.5f, 1.0f);
DirLight1.mSpecularIntensity =1.5f;
DirLight1.mDiffuseIntensity = 1.0f;
LightMgr.CreateDynamicDirLight(DirLight1);
N_Material Mat1;
Mat1.baseMaterial.mBaseAmbientColor = NVECTOR3(0.1f, 0.1f,0.1f);
Mat1.baseMaterial.mBaseDiffuseColor = NVECTOR3(1.0f, 1.0f, 1.0f);
Mat1.baseMaterial.mBaseSpecularColor = NVECTOR3(1.0f, 1.0f,1.0f);
Mat1.baseMaterial.mSpecularSmoothLevel = 40;
Mat1.baseMaterial.mNormalMapBumpIntensity = 0.3f;
Mat1.baseMaterial.mEnvironmentMapTransparency = 0.05f;
Mat1.diffuseMapID = TexMgr.GetTextureID("Wood");//"Earth");
Mat1.normalMapID = TexMgr.GetTextureID("EarthNormalMap");
Mat1.cubeMap_environmentMapID = NOISE_MACRO_INVALID_TEXTURE_ID;//TexMgr.GetTextureID("EnvironmentMap");
UINT Mat1_ID = MatMgr.CreateMaterial(Mat1);
//set material
Mesh1.SetMaterial(Mat1_ID);
GraphicObjBuffer.AddRectangle(NVECTOR2(340.0f, 430.0f), NVECTOR2(640.0f, 480.0f), NVECTOR4(0.3f, 0.3f, 1.0f, 1.0f),TexMgr.GetTextureID("BottomRightTitle"));
//GUI System
GUIMgr.Initialize(bufferWidth, bufferHeight, Renderer, inputE, fontMgr, hwnd);
GUIMgr.SetWindowHWND(hwnd);
GUIMgr.SetFontManager(fontMgr);
GUIMgr.InitButton(GUIButton1);
GUIMgr.InitScrollBar(GUIScrollBar1);
GUIMgr.InitTextBox(GUITextBox1,0);
GUIButton1.SetCenterPos(150.0f, 50.0f);
GUIButton1.SetWidth(300.0f);
GUIButton1.SetHeight(100.0f);
GUIButton1.SetDragableX(TRUE);
GUIButton1.SetDragableY(TRUE);
GUIButton1.SetTexture(NOISE_GUI_BUTTON_STATE_COMMON,TexMgr.GetTextureID("GUI_Button2"));
GUIButton1.SetTexture(NOISE_GUI_BUTTON_STATE_MOUSEON,TexMgr.GetTextureID("GUI_Button3"));
GUIButton1.SetTexture(NOISE_GUI_BUTTON_STATE_MOUSEBUTTONDOWN,TexMgr.GetTextureID("GUI_Button4"));
GUIButton1.SetEventProcessCallbackFunction(Button1MsgProc);
GUIScrollBar1.SetCenterPos(300.0f, 300.0f);
GUIScrollBar1.SetWidth(30.0f);
GUIScrollBar1.SetHeight(300.0f);
GUIScrollBar1.SetTexture_ScrollButton(NOISE_GUI_BUTTON_STATE_COMMON, TexMgr.GetTextureID("GUI_Button1"));
GUIScrollBar1.SetTexture_ScrollButton(NOISE_GUI_BUTTON_STATE_MOUSEON, TexMgr.GetTextureID("GUI_Button2"));
GUIScrollBar1.SetTexture_ScrollButton(NOISE_GUI_BUTTON_STATE_MOUSEBUTTONDOWN, TexMgr.GetTextureID("GUI_Button3"));
GUIScrollBar1.SetTexture_ScrollGroove(TexMgr.GetTextureID("GUI_Button4"));
GUIScrollBar1.SetAlignment(FALSE);
GUIScrollBar1.SetValue(0.5f);
GUITextBox1.SetTextColor({ 1.0f,0,0,1.0f });
GUITextBox1.SetCenterPos(470.0f, 400.0f);
GUITextBox1.SetWidth(300.0f);
GUITextBox1.SetHeight(80.0f);
GUITextBox1.SetFont(0);
GUITextBox1.SetMaxWordCount(20);
GUITextBox1.SetTexture_BackGround( TexMgr.GetTextureID("GUI_Button3"));
GUITextBox1.SetTexture_Cursor( TexMgr.GetTextureID("GUI_Button2"));
GUIMgr.Update();
/*Slicer.Step1_LoadPrimitiveMeshFromSTLFile("object.stl");
Slicer.Step2_Intersection(5);
Slicer.Step3_GenerateLineStrip();// extremely neccessary for optimization
Slicer.Step4_SaveLayerDataToFile("object.LayerOutput");*/
//Slicer.Step3_LoadLineStripsFrom_NOISELAYER_File("object.LayerOutput");
/*NVECTOR3 v1, v2, n;
for (UINT i = 0;i < Slicer.GetLineStripCount();i++)
{
Slicer.GetLineStrip(lineStrip, i);
for (UINT j = 0;j < lineStrip.at(i).pointList.size() - 1;j++)
{
v1 = lineStrip.at(i).pointList.at(j);
v2 = lineStrip.at(i).pointList.at(j + 1);
n = lineStrip.at(i).normalList.at(j);
//vertex
GraphicObjBuffer.AddLine3D(v1, v2);
//normal
GraphicObjBuffer.AddLine3D((v1 + v2) / 2, ((v1 + v2) / 2) + n / 4, NVECTOR4(1.0f, 1.0f, 1.0f, 1.0f), NVECTOR4(1.0f, 0.2f, 0.2f, 1.0f));
}
}*/
return TRUE;
};
int main()
{
IDevice* device = gf::createDevice(EDT_DIRECT3D11, 800, 600);
IVideoDriver* driver = device->getVideoDriver();
ISceneManager* smgr = device->createSceneManager();
IResourceGroupManager* resourceGroupManager = driver->getResourceGroupManager();
resourceGroupManager->init("Resources.cfg");
ITimer* timer = device->getTimer();
timer->reset();
ITextureManager* textureManager = ITextureManager::getInstance();
IShaderManager* shaderMgr = driver->getShaderManager();
IShader* shader = shaderMgr->load(EST_COMPUTE_SHADER, "matmul.hlsl", "cs_main");
const u32 dimension = 512;
const u32 sq_dimension = dimension * dimension;
std::vector<f32> A(sq_dimension);
std::vector<f32> B(sq_dimension);
std::vector<f32> C(sq_dimension);
std::vector<f32> D(sq_dimension);
// init data
for (u32 i = 0; i < sq_dimension; i++)
{
A[i] = math::RandomFloat(0, 10.0f);
B[i] = math::RandomFloat(0, 10.0f);
}
f32 start_time, end_time;
start_time = timer->getTime();
// store the right answers to D
for (u32 i = 0; i < dimension; i++)
{
for (u32 j = 0; j < dimension; j++)
{
f32 sum = 0;
for (u32 k = 0; k < dimension; k++)
{
sum += A[i * dimension + k] * B[k * dimension + j];
}
D[i * dimension + j] = sum;
}
}
end_time = timer->getTime();
printf("The computation time by CPU: %fs\n", end_time - start_time);
start_time = timer->getTime();
ITexture* inputTexture1 = textureManager->createTexture2D("input1", dimension, dimension,
ETBT_SHADER_RESOURCE, &A[0], 1, EGF_R32_FLOAT, 0);
ITexture* inputTexture2 = textureManager->createTexture2D("input2", dimension, dimension,
ETBT_SHADER_RESOURCE, &B[0], 1, EGF_R32_FLOAT, 0);
ITexture* outputTexture = textureManager->createTexture2D("output", dimension, dimension,
ETBT_UNORDERED_ACCESS, nullptr, 1, EGF_R32_FLOAT, 0);
ITexture* copyTexture = textureManager->createTexture2D("copy", dimension, dimension,
ETBT_CPU_ACCESS_READ, nullptr, 1, EGF_R32_FLOAT, 0);
shader->setTexture("gInputA", inputTexture1);
shader->setTexture("gInputB", inputTexture2);
shader->setTexture("gOutput", outputTexture);
u32 blockNum = dimension / 8;
if (blockNum * 8 != dimension)
blockNum++;
driver->runComputeShader(shader, blockNum, blockNum, 1);
//driver->resetRWTextures();
//driver->resetTextures();
outputTexture->copyDataToAnotherTexture(copyTexture);
STextureData outputData;
copyTexture->lock(ETLT_READ, &outputData);
u8* data = (u8*)outputData.Data;
for (u32 i = 0; i < dimension; i++)
{
// copy each row.
memcpy(&C[i * dimension], data + outputData.RowPitch * i, dimension * sizeof(f32));
}
copyTexture->unlock();
end_time = timer->getTime();
printf("The computation time by GPU: %fs\n", end_time - start_time);
for (u32 i = 0; i < sq_dimension; i++)
{
assert(math::FloatEqual(C[i], D[i]));
}
// destory textures.
if (!textureManager->destroy(inputTexture1))
printf("Destory texture failed!");
if (!textureManager->destroy(inputTexture2))
printf("Destory texture failed!");
if (!textureManager->destroy(outputTexture))
printf("Destory texture failed!");
if (!textureManager->destroy(copyTexture))
printf("Destory texture failed!");
//sphereMaterial.drop();
smgr->destroy();
device->drop();
system("pause");
return 0;
}
