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; }