void InitLightExam()
{
ZFXCOLOR color(0, 0, 1, 1);
g_pDevice->SetShadeMode(RS_SHADE_SOLID, 1.0f, &color);
ZFXVector vU(0, 1, 0);
ZFXVIEWPORT vp = { 0, 0, 800, 600 };
g_pDevice->InitStage(60, &vp, 0);
g_pDevice->SetClippingPlanes(0.1f, 1000.0f);
g_pDevice->SetMode(EMD_PERSPECTIVE, 0);
IShaderManager* sm = g_pDevice->GetShaderManager();
if (g_vshader)
sm->BindShader(g_vshader);
if (g_fshader)
sm->BindShader(g_fshader);
if (g_vshader || g_fshader)
sm->EnableShader(true);
light.Type = LGT_SPOT;
light.cAmbient.rgba(0.2, 0.2, 0.2, 1);
light.cDiffuse.rgba(0, 0, 1, 1);
light.cSpecular.rgba(1, 0, 0, 1);
light.fAttenuation0 = 1.0f;
light.fAttenuation1 = 0.0f;
light.fTheta = 30;
light.fPhi = 60;
light.fRange = 50;
light.vcDirection = ZFXVector(0, 0, 0);
}
void DrawString(const char* str)
{
IShaderManager* sm = g_pDevice->GetShaderManager();
sm->EnableShader(false);
g_pDevice->BeginRendering(true, true, true);
ZFXMatrix mWorld;
mWorld.Identity();
g_pDevice->SetWorldTransform(&mWorld);
g_pDevice->DrawText(g_fontID, 0, 0, 0xffff0000, str);
g_pDevice->EndRendering();
}
void InitTriangleExam()
{
ZFXCOLOR color(0, 0, 1, 1);
g_pDevice->SetShadeMode(RS_SHADE_SOLID, 1.0f, &color);
ZFXVector vU(0, 1, 0);
ZFXVIEWPORT vp = { 0, 0, 800, 600 };
g_pDevice->InitStage(60, &vp, 0);
g_pDevice->SetClippingPlanes(0.1f, 1000.0f);
g_pDevice->SetMode(EMD_ORTHOGONAL, 0);
IShaderManager* sm = g_pDevice->GetShaderManager();
if (g_vshader)
sm->BindShader(g_vshader);
if (g_fshader)
sm->BindShader(g_fshader);
if (g_vshader || g_fshader)
sm->EnableShader(true);
sm->EnableShader(false);
}
void EditorScene::setupInitialScene()
{
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;
ITextureCube* skyTexture = mTextureManager->loadCubeTexture("skybox1.dds");
smgr->setSkyDome(skyTexture);
IMeshNode* skyNode = mSceneManager->getSkyNode();
if (skyNode)
skyNode->setMaterialName("skydome_material");
mTimer = mDevice->getTimer();
ISimpleMesh* cubeMesh = mMeshManager->createCubeMesh("cube1");
mSelectedCubeNode = smgr->addMeshNode(cubeMesh, nullptr, nullptr, false);
mSelectedCubeNode->setMaterialName("selected_cube_material");
mSelectedCubeNode->setVisible(false);
mSelectedCubeNode->setTag(WIRE_NODE_TAG);
mPickingCubeNode = smgr->addMeshNode(cubeMesh, nullptr, nullptr, false);
mPickingCubeNode->setMaterialName("picking_cube_material");
mPickingCubeNode->setVisible(false);
mPickingCubeNode->setTag(WIRE_NODE_TAG);
ISimpleMesh* sphereMesh = mMeshManager->createSphereMesh("pointlight_mesh", 1.0f, 10, 10);
mPointLightCollectionNode = smgr->addInstanceCollectionNode(sphereMesh,
nullptr, 4000, sizeof(XMFLOAT4));
mPointLightCollectionNode->setMaterialName("multi_wire_material");
mPointLightCollectionNode->setTag(WIRE_NODE_TAG);
mPointLightCollectionNode->setVisible(false);
mSceneManager->update(0);
IVideoDriver* driver = IVideoDriver::getInstance();
mVideoDriver->setDeferredShading(true);
driver->setDeferredShadingAlgorithm(EDSA_CS_TILE_BASED_DEFERRED_SHADING);
IShaderManager* shaderManager = IShaderManager::getInstance();
mTileBasedDSShader = shaderManager->load(EST_COMPUTE_SHADER, "defer_shader_cs.hlsl", "cs_main");
smgr->setTileBasedDeferredShadingCS(mTileBasedDSShader);
if (!CFileParser::ReadScene("main.scene"))
{
setupTerrain();
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.8f, 0.8f, 0.8f, 1.0f));
light->enableShadow(true);
mDirectionalLightNode = light;
smgr->setAmbient(XMFLOAT4(0.5f, 0.5f, 0.5f, 1.0f));
mCamera = smgr->addFpsCameraNode(1, nullptr, XMFLOAT3(0, 30.0f, -4.0f),
XMFLOAT3(0, 30.0f, 0.0f), XMFLOAT3(0, 1.0f, 0), true);
mCamera->setShadowRange(300.0f);
mVideoDriver->setDeferredShading(true);
mDeferredShading = true;
}
UpdateGlobalLighting();
smgr->update();
}
/**
* Do one frame.
*/
HRESULT ProgramTick(void)
{
HRESULT hr = ZFX_FAIL;
ZFXMatrix mWorld;
mWorld.Identity();
static float fT = 0.0f;
static float fA = 0.0f;
// this is just fancy fadein/fadeout eyecandy ////////
if (fT <= 1.0f)
{
fA = fT;
fT += 0.01f;
}
else if (fT <= 2.0f)
{
fA = 1 - (fT - 1);
fT += 0.01f;
}
else fT = 0.0f;
// end of fancy fadein/fadeout eyecandy //////////////
// set first viewport (whole window)
g_pDevice->SetMode(EMD_PERSPECTIVE, 0);
IShaderManager* sm = g_pDevice->GetShaderManager();
if (g_vshader)
sm->BindShader(g_vshader);
if (g_fshader)
sm->BindShader(g_fshader);
if(g_vshader || g_fshader)
sm->EnableShader(true);
GLfloat f[16] = { 0.0 };
glGetFloatv(GL_MODELVIEW_MATRIX, f);
glGetFloatv(GL_PROJECTION_MATRIX, f);
g_pDevice->SetClearColor(0.7f, 0.7f, 1.0f);
// clear buffers and start scene
g_pDevice->BeginRendering(true, true, true);
mWorld.Translate(-1.0f, 1.0f, 3.0f);
g_pDevice->SetWorldTransform(&mWorld);
hr = g_pMarder->Render(true, false);
mWorld.Translate(-1.0f, -5.0f, 2.0f);
g_pDevice->SetWorldTransform(&mWorld);
hr = g_pLeopard2->Render(true, false);
mWorld.Identity();
//mWorld.Translate(1.1f, -0.6f, 1.0f);
g_pDevice->SetWorldTransform(&mWorld);
hr = g_pG3->Render(true, false);
g_pDevice->FadeScreen(0.0f, 0.0f, 0.0f, fA);
// render into second viewport
g_pDevice->SetMode(EMD_PERSPECTIVE, 1);
if (g_vshader || g_fshader)
sm->EnableShader(true);
glGetFloatv(GL_MODELVIEW_MATRIX, f);
glGetFloatv(GL_PROJECTION_MATRIX, f);
g_pDevice->SetClearColor(1.0f, 0.2f, 0.2f);
g_pDevice->Clear(true, true, true);
mWorld.Translate(-2.0f, 1.0f, 3.0f);
g_pDevice->SetWorldTransform(&mWorld);
g_pMarder->Render(true, true);
mWorld.Translate(-1.0f, -5.0f, 2.0f);
g_pDevice->SetWorldTransform(&mWorld);
g_pLeopard2->Render(true, true);
mWorld.Translate(1.1f, -0.6f, 1.0f);
g_pDevice->SetWorldTransform(&mWorld);
g_pG3->Render(true, true);
g_pDevice->FadeScreen(0.0f, 0.0f, 0.0f, 1.0f - fA);
g_pDevice->SetMode(EMD_PERSPECTIVE, 0);
/*if (g_pDevice->IsWindowed())
g_pDevice->DrawText(g_nFontID, 10, 10, 255, 255, 0, "ZFXEngine 2.0");
else
{
g_pDevice->GetResolution(&pt);
g_pDevice->DrawText(g_nFontID, 10, 10, 255, 255, 0, "Screen: (%d,%d)", pt.x, pt.y);
}
*/
// flip backbuffer to front
g_pDevice->EndRendering();
return hr;
} // Tick
/**
* Create a render device and stuff.
*/
HRESULT ProgramStartup(const char *chAPI)
{
HWND hWnd3D[4];
RECT rcWnd;
int x = 0, y = 0;
// no opengl render device yet...
//if (strcmp(chAPI, "OpenGL") == 0) return S_OK;
// create a render objekt
g_pRenderer = new ZFXRenderer(g_hInst);
// create a device for the chosen api
if (FAILED(g_pRenderer->CreateDevice(chAPI))) return E_FAIL;
// get a pointer on that device
g_pDevice = g_pRenderer->GetDevice();
if (g_pDevice == NULL) return E_FAIL;
// build for child windows
GetClientRect(g_hWnd, &rcWnd);
g_MAXWND = 0;
for (int i = 0; i < g_MAXWND; i++)
{
if ((i == 0) || (i == 2)) x = 10;
else x = rcWnd.right / 2 + 10;
if ((i == 0) || (i == 1)) y = 10;
else y = rcWnd.bottom / 2 + 10;
hWnd3D[i] = CreateWindowEx(WS_EX_CLIENTEDGE, TEXT("static"),
NULL, WS_CHILD | SS_BLACKRECT | WS_VISIBLE,
x, y, rcWnd.right / 2 - 20, rcWnd.bottom / 2 - 20,
g_hWnd, NULL, g_hInst, NULL);
}
// init render device
if (FAILED(g_pDevice->Init(g_hWnd, hWnd3D, g_MAXWND, 16, 0, false)))
{
GetLogger().Print(LOG_DEBUG,log_file,"Error RenderDevice Init");
return ZFX_FAIL;
}
g_pDevice->UseWindow(0);
POINT ptRes;
g_pDevice->GetResolution(&ptRes);
long lx = 0, ldx = 0, ldy = 0, fs = 0;
ldx = ptRes.x / 2.666666f;
ldy = ldx / 1.333333f;
lx = ptRes.x - ldx - 10;
fs = ptRes.x / 20;
ZFXVIEWPORT rc = { lx, 0, ldx, ldy };
g_pDevice->InitStage(60, NULL, 0);
g_pDevice->InitStage(60, &rc, 1);
if (strcmp(chAPI, "Direct3D") == 0)
{
if (FAILED(g_pDevice->CreateFont("Arial", 0, false, false,
false, fs, &g_nFontID)))
{
GetLogger().Print(LOG_DEBUG,log_file,"error: ZFXRenderDevice::CreateFont failed\n");
return ZFX_FAIL;
}
}
IShaderManager* sm = g_pDevice->GetShaderManager();
std::string str("shader//shader.vert");
g_vshader = sm->CreateShader((void*)str.c_str(), SHT_VERTEX, true);
str.assign("shader//shader.frag");
g_fshader = sm->CreateShader((void*)str.c_str(), SHT_PIXEL, true);
return ZFX_OK;
} // ProgramStartup
/**
* WinMain function to get the thing started.
*/
int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrevInstance,
LPSTR lpCmdLine, int nCmdShow) {
WNDCLASSEX wndclass;
HRESULT hr;
HWND hWnd;
MSG msg;
// Set up window attributes
wndclass.cbSize = sizeof(wndclass);
wndclass.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC | CS_DBLCLKS;
wndclass.lpfnWndProc = MsgProc;
wndclass.cbClsExtra = 0;
wndclass.cbWndExtra = 0;
wndclass.hInstance = hInst;
wndclass.hIcon = LoadIcon(NULL, IDI_APPLICATION);
wndclass.hCursor = LoadCursor(NULL, IDC_ARROW);
wndclass.hbrBackground = (HBRUSH)(COLOR_WINDOW);
wndclass.lpszMenuName = NULL;
wndclass.lpszClassName = g_szAppClass;
wndclass.hIconSm = LoadIcon(NULL, IDI_APPLICATION);
if (RegisterClassEx(&wndclass) == 0)
return 0;
// create window
if (!(hWnd = CreateWindowEx(NULL, g_szAppClass,
"ZFXEngine - Demo Application",
WS_OVERLAPPEDWINDOW | WS_VISIBLE,
GetSystemMetrics(SM_CXSCREEN) / 2 - 400,
GetSystemMetrics(SM_CYSCREEN) / 2 - 300,
800, 600, NULL, NULL, hInst, NULL)))
return 0;
ShowWindow(hWnd, SW_HIDE);
g_hWnd = hWnd;
g_hInst = hInst;
int SwitchAPI = 1;
std::string chAPI;
switch (SwitchAPI)
{
case 0:
chAPI.assign("Direct3D");
break;
case 1:
chAPI.assign("OpenGL");
break;
default:
chAPI.assign("Direct3D");
break;
}
// try to start the engine
if (FAILED(hr = ProgramStartup(chAPI.c_str())))
{
GetLogger().Print(LOG_DEBUG,log_file,"error: ProgramStartup() failed\n");
g_bDone = true;
}
else if (hr == ZFX_CANCELED)
{
GetLogger().Print(LOG_DEBUG,log_file,"error: ProgramStartup() canceled by user \n");
g_bDone = true;
}
else
{
GetLogger().Print(LOG_DEBUG,log_file,"ProgramStartup Success");
g_pDevice->SetClearColor(1, 1, 1);
ShowWindow(hWnd, SW_SHOW);
LoadModel();
}
//DrawVertex();
InitTriangleExam();
InitFont();
//InitLightExam();
InitGlyphTex();
GetTimer()->Reset();
while (!g_bDone)
{
while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
if (g_bIsActive)
{
UpdateFPS();
//DrawGlyphTex();
//DrawLightExam();
//ProgramTick();
IShaderManager* sm = g_pDevice->GetShaderManager();
sm->EnableShader(false);
//DrawTriangle(sm);
//DrawS3DModel();
DrawString("Life is cool");
/*if (g_pDevice->IsWindowed())
{
g_pDevice->UseWindow(1);
g_pDevice->SetView3D(vU*-1.0f, vR, vD, vP);
ProgramTick();
g_pDevice->UseWindow(2);
g_pDevice->SetView3D(vR*-1.0f, vU*-1, vD, vP);
ProgramTick();
g_pDevice->UseWindow(3);
g_pDevice->SetView3D(vU, vR*-1, vD, vP);
ProgramTick();
}*/
}
}
// cleanup stuff
ProgramCleanup();
UnregisterClass(g_szAppClass, hInst);
// return back to windows
return (int)msg.wParam;
} // WinMain
void DrawLightExam()
{
// compute camera
g_pos.y = distance * sin(yAngle);
g_pos.x = distance * cos(yAngle) * sin(-xAngle);
g_pos.z = distance * cos(yAngle) * cos(-xAngle);
g_lightPos.y = LightDistantce * sin(yLightAngle);
g_lightPos.x = LightDistantce * cos(yLightAngle) * sin(-xLightAngle);
g_lightPos.z = LightDistantce * cos(yLightAngle) * cos(-xLightAngle);
light.vcPosition = g_lightPos;
light.vcDirection = -g_lightPos;
light.vcDirection.w = 0;
light.fPhi = g_cutoff;
light.fExponent = g_exponent;
g_pDevice->UseWindow(0);
ZFXVector vU(0, 1, 0);
g_pDevice->SetViewLookAt(g_pos, ZFXVector(0, 0, 0), vU);
IShaderManager *sm = g_pDevice->GetShaderManager();
sm->SetNamedConstant("camera_position", DAT_FVEC4, 1, g_pos.v);
GLfloat f[16] = { 0.0 };
glGetFloatv(GL_MODELVIEW_MATRIX, f);
glGetFloatv(GL_PROJECTION_MATRIX, f);
ZFXMatrix mWorld;
mWorld.Identity();
g_pDevice->SetWorldTransform(&mWorld);
//sm->EnableShader(false);
g_pDevice->SetAmbientLight(0.1, 0.1, 0.1);
g_pDevice->SetLight(&light, 0);
float v[4];
glGetMaterialfv(GL_FRONT, GL_AMBIENT, v);
glGetMaterialfv(GL_FRONT, GL_DIFFUSE, v);
glGetMaterialfv(GL_FRONT, GL_SPECULAR, v);
glGetMaterialfv(GL_FRONT, GL_EMISSION, v);
DrawOBJModel();
GLenum error = glGetError();
if (error != GL_NO_ERROR)
{
int i = 0;
}
glGetMaterialfv(GL_FRONT, GL_AMBIENT, v);
glGetMaterialfv(GL_FRONT, GL_DIFFUSE, v);
glGetMaterialfv(GL_FRONT, GL_SPECULAR, v);
glGetMaterialfv(GL_FRONT, GL_EMISSION, v);
glGetLightfv(GL_LIGHT0, GL_AMBIENT, v);
glGetLightfv(GL_LIGHT0, GL_DIFFUSE, v);
glGetLightfv(GL_LIGHT0, GL_SPECULAR, v);
error = glGetError();
if (error != GL_NO_ERROR)
{
int i = 0;
}
}
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;
}
int main()
{
int d = 1;
GF_PRINT_CONSOLE_INFO("Hello:%d\n", d);
SDeviceContextSettings settings;
settings.MultiSamplingCount = 4;
settings.MultiSamplingQuality = 32;
IDevice* device = createDevice(EDT_DIRECT3D11, 800, 600, EWS_NONE, true, settings);
IVideoDriver* driver = device->getVideoDriver();
IShaderManager* shaderManager = driver->getShaderManager();
IInputLayoutManager* inputlayoutManager = driver->getInputLayoutManager();
IPipelineManager* pipelineMgr = driver->getPipelineManager();
IShader* vs = shaderManager->load(EST_VERTEX_SHADER, "color.hlsl", "ColorVertexShader");
IShader* ps = shaderManager->load(EST_PIXEL_SHADER, "PixelShader.hlsl", "ColorPixelShader");
std::vector<SInputLayoutElement> elements;
elements.resize(2);
elements[0].SemanticName = "POSITION";
elements[0].SemanticIndex = 0;
elements[0].Format = EGF_R32G32B32_FLOAT;
elements[0].Offset = 0;
elements[1].SemanticName = "COLOR";
elements[1].SemanticIndex = 0;
elements[1].Format = EGF_R32G32B32A32_FLOAT;
elements[1].Offset = 12;
IInputLayout* layout = inputlayoutManager->create(elements, vs);
IShader* shaders[2] = { vs, ps };
IPipeline* pipeline = pipelineMgr->create("color", shaders, 2, layout, EPT_TRIANGLELIST);
ISceneManager* smgr = device->getSceneManager();
Vertex vertices[3];
vertices[0] = Vertex(XMFLOAT3(-1.0f, -0.6f, 0.0f), XMFLOAT4(1.0f, 0.0f, 0.0f, 1.0f));
vertices[1] = Vertex(XMFLOAT3(0.0f, 0.6f, 0.0f), XMFLOAT4(0.0f, 1.0f, 0.0f, 1.0f));
vertices[2] = Vertex(XMFLOAT3(1.0f, -0.6f, 0.0f), XMFLOAT4(1.0f, 0.0f, 1.0f, 1.0f));
//IMesh* mesh = smgr->createSimpleMesh(&vertices, 3, sizeof(Vertex), nullptr, 0, 0);
IMesh* mesh = smgr->createCubeMesh();
IMeshNode* meshNode = smgr->addMeshNode(mesh, pipeline);
//CD3D11ShaderManager* s = new CD3D11ShaderManager(nullptr);
XMVECTOR eye = XMVectorSet(0.0f, 0.0f, -5.0f, 1.0f);
XMVECTOR up = XMVectorSet(0.0f, 1.0f, 0.0f, 0.0f);
XMVECTOR at = XMVectorZero();
XMMATRIX view = XMMatrixLookAtLH(eye, at, up);
XMMATRIX proj = XMMatrixPerspectiveFovLH(0.25f * 3.14f,
static_cast<float>(SCREEN_WIDTH) / static_cast<float>(SCREEN_HEIGHT),
1.0f, 1000.0f);
meshNode->translate(0, 0, 5.0f);
XMMATRIX world = meshNode->getAbsoluteTransformation();
//XMMATRIX world = XMMatrixIdentity();
pipeline->setMatrix("viewMatrix", reinterpret_cast<f32*>(&view));
pipeline->setMatrix("projectionMatrix", reinterpret_cast<f32*>(&proj));
SShaderAutoVariable var;
var.Type = ESAVT_WORLD_MATRIX;
var.ShaderType = EST_VERTEX_SHADER;
var.VariableName = "worldMatrix";
pipeline->addShaderAutoVariable(var);
std::cout << "Hello World" << std::endl;
ITimer* timer = device->createTimer();
timer->reset();
while (device->run())
{
const float clearColor[] = { 0.0f, 0.0f, 0.0f, 1.0f };
driver->beginScene(true, true, clearColor);
f32 dt = timer->tick();
//std::cout << dt << std::endl;
meshNode->setPosition(0, 0, -2.0f);
meshNode->yaw(1.0f * dt);
smgr->drawAll();
//XMMATRIX world = meshNode->getAbsoluteTransformation();
//pipeline->setMatrix("worldMatrix", reinterpret_cast<f32*>(&world));
driver->endScene();
}
return 0;
}
