HRESULT CRenderer::Render() { HRESULT hr = S_OK; D3DXMATRIXA16 matWorld; IFC(m_pd3dDevice->BeginScene()); IFC(m_pd3dDevice->Clear( 0, NULL, D3DCLEAR_TARGET, D3DCOLOR_ARGB(128, 0, 0, 128), // NOTE: Premultiplied alpha! 1.0f, 0 )); D3DXMATRIXA16 m_matView; D3DXMATRIXA16 m; D3DXMATRIXA16 *pView; pView = m_Happy->HCamera.CnodeList[0]->GetViewMatrix(); // 카메라 클래스로부터 행렬정보를 얻는다. m = *pView * m_matProj; // World좌표를 얻기위해서 View * Proj행렬을 계산한다. m_pFrustum->Make( &m ); // View*Proj행렬로 Frustum을 만든다. m_pFrustum->ViewSet(pView); BspNode->draw(); practices->draw(); //TileTerrainNode->draw(m_pFrustum); IFC(m_pd3dDevice->EndScene()); Cleanup: return hr; }
//+----------------------------------------------------------------------------- // // Member: // CRendererManager::EnsureRenderers // // Synopsis: // Makes sure the CRenderer objects exist // //------------------------------------------------------------------------------ HRESULT CRendererManager::EnsureRenderers() { HRESULT hr = S_OK; if (!m_rgRenderers) { IFC(EnsureHWND()); assert(m_cAdapters); m_rgRenderers = new CRenderer*[m_cAdapters]; IFCOOM(m_rgRenderers); ZeroMemory(m_rgRenderers, m_cAdapters * sizeof(m_rgRenderers[0])); for (UINT i = 0; i < m_cAdapters; ++i) { IFC(CTriangleRenderer::Create(m_pD3D, m_pD3DEx, m_hwnd, i, &m_rgRenderers[i])); } // Default to the default adapter m_pCurrentRenderer = m_rgRenderers[0]; } Cleanup: return hr; }
//+----------------------------------------------------------------------------- // // Member: // CRendererManager::EnsureD3DObjects // // Synopsis: // Makes sure the D3D objects exist // //------------------------------------------------------------------------------ HRESULT CRendererManager::EnsureD3DObjects() { HRESULT hr = S_OK; HMODULE hD3D = NULL; if (!m_pD3D) { hD3D = LoadLibrary(TEXT("d3d9.dll")); DIRECT3DCREATE9EXFUNCTION pfnCreate9Ex = (DIRECT3DCREATE9EXFUNCTION)GetProcAddress(hD3D, "Direct3DCreate9Ex"); if (pfnCreate9Ex) { IFC((*pfnCreate9Ex)(D3D_SDK_VERSION, &m_pD3DEx)); IFC(m_pD3DEx->QueryInterface(__uuidof(IDirect3D9), reinterpret_cast<void **>(&m_pD3D))); } else { m_pD3D = Direct3DCreate9(D3D_SDK_VERSION); if (!m_pD3D) { IFC(E_FAIL); } } m_cAdapters = m_pD3D->GetAdapterCount(); } Cleanup: if (hD3D) { FreeLibrary(hD3D); } return hr; }
extern "C" HRESULT WINAPI GetBackBufferNoRef(IDirect3DSurface9 **ppSurface) { HRESULT hr = S_OK; IFC(EnsureRendererManager()); IFC(pManager->GetBackBufferNoRef(ppSurface)); Cleanup: return hr; }
HRESULT CTedMediaFileRenderer::Load(IMFTopology** ppOutputTopology) { HRESULT hr; CComPtr<IMFTopology> spPartialTopology; IFC( CreatePartialTopology(&spPartialTopology) ); IFC( m_spTopoLoader->Load(spPartialTopology, ppOutputTopology, NULL) ); Cleanup: return hr; }
//+----------------------------------------------------------------------------- // // Member: // CRendererManager::GetBackBufferNoRef // // Synopsis: // Returns the surface of the current renderer without adding a reference // // This can return NULL if we're in a bad device state. // //------------------------------------------------------------------------------ HRESULT CRendererManager::GetBackBufferNoRef(IDirect3DSurface9 **ppSurface) { HRESULT hr = S_OK; // Make sure we at least return NULL *ppSurface = NULL; CleanupInvalidDevices(); IFC(EnsureD3DObjects()); // // Even if we never render to another adapter, this sample creates devices // and resources on each one. This is a potential waste of video memory, // but it guarantees that we won't have any problems (e.g. out of video // memory) when switching to render on another adapter. In your own code // you may choose to delay creation but you'll need to handle the issues // that come with it. // IFC(EnsureRenderers()); if (m_fSurfaceSettingsChanged) { if (FAILED(TestSurfaceSettings())) { IFC(E_FAIL); } for (UINT i = 0; i < m_cAdapters; ++i) { IFC(m_rgRenderers[i]->CreateSurface(m_uWidth, m_uHeight, m_fUseAlpha, m_uNumSamples)); } m_fSurfaceSettingsChanged = false; } if (m_pCurrentRenderer) { *ppSurface = m_pCurrentRenderer->GetSurfaceNoRef(); } Cleanup: // If we failed because of a bad device, ignore the failure for now and // we'll clean up and try again next time. if (hr == D3DERR_DEVICELOST) { hr = S_OK; } return hr; }
HRESULT CTedPlayer::HandleNotifyPresentationTime(IMFMediaEvent* pEvent) { HRESULT hr = S_OK; IFC( pEvent->GetUINT64(MF_EVENT_START_PRESENTATION_TIME, (UINT64*) &m_hnsStartTime) ); IFC( pEvent->GetUINT64(MF_EVENT_PRESENTATION_TIME_OFFSET, (UINT64*) &m_hnsOffsetTime) ); IFC( pEvent->GetUINT64(MF_EVENT_START_PRESENTATION_TIME_AT_OUTPUT, (UINT64*) &m_hnsStartTimeAtOutput) ); m_fReceivedTime = true; Cleanup: return( hr ); }
HRESULT CTedPlayer::HandleEvent(IMFMediaEvent * pEvent) { HRESULT hr = S_OK; HRESULT hrEvent = S_OK; MediaEventType met; PROPVARIANT var; PropVariantInit(&var); IFC(pEvent->GetType(&met)); IFC(pEvent->GetStatus(&hrEvent)); IFC(pEvent->GetValue(&var)); switch(met) { case MESessionStarted: IFC( HandleSessionStarted( pEvent ) ); m_bIsPlaying = true; break; case MESessionEnded: m_bIsPlaying = false; if(m_fIsTranscoding) { m_spSession->Close(); } break; case MESessionTopologySet: if(SUCCEEDED(hrEvent)) { m_fTopologySet = true; m_bIsPaused = false; } m_spFullTopology.Release(); var.punkVal->QueryInterface(IID_IMFTopology, (void**) &m_spFullTopology); break; case MESessionNotifyPresentationTime: IFC( HandleNotifyPresentationTime( pEvent ) ); break; } m_pMediaEventHandler->HandleMediaEvent(pEvent); Cleanup: PropVariantClear(&var); return hr; }
HRESULT CTedPlayer::SetRate(float flRate) { HRESULT hr = S_OK; CComPtr<IMFRateControl> spRateControl = NULL; IFC( MFGetService( m_spSession, MF_RATE_CONTROL_SERVICE, IID_IMFRateControl, (void**) &spRateControl )); IFC( spRateControl->SetRate( FALSE, flRate ) ); Cleanup: return( hr ); }
HRESULT CTedPlayer::GetRateBounds(MFRATE_DIRECTION eDirection, float* pflSlowest, float* pflFastest) { HRESULT hr = S_OK; CComPtr<IMFRateSupport> spRateSupport; assert(pflSlowest != NULL); assert(pflFastest != NULL); IFC( MFGetService( m_spSession, MF_RATE_CONTROL_SERVICE, IID_IMFRateSupport, (void**) &spRateSupport ) ); IFC( spRateSupport->GetSlowestRate( eDirection, FALSE, pflSlowest ) ); IFC( spRateSupport->GetFastestRate( eDirection, FALSE, pflFastest ) ); Cleanup: return( hr ); }
HRESULT CTedMediaFileRenderer::CreatePartialTopology(IMFTopology** ppPartialTopology) { HRESULT hr; IMFTopology* pPartialTopology; CComPtr<IMFMediaSource> spSource; IFC( MFCreateTopology(&pPartialTopology) ); IFC( CreateSource(&spSource) ); IFC( BuildTopologyFromSource(pPartialTopology, spSource) ); *ppPartialTopology = pPartialTopology; Cleanup: return hr; }
static int dot_pz(char *line, CKTcircuit *ckt, INPtables *tab, struct card *current, TSKtask *task, CKTnode *gnode, JOB *foo) { int error; /* error code temporary */ IFvalue ptemp; /* a value structure to package resistance into */ IFvalue *parm; /* a pointer to a value struct for function returns */ int which; /* which analysis we are performing */ char *steptype; /* ac analysis, type of stepping function */ NG_IGNORE(gnode); /* .pz nodeI nodeG nodeJ nodeK {V I} {POL ZER PZ} */ which = ft_find_analysis("PZ"); if (which == -1) { LITERR("Pole-zero analysis unsupported.\n"); return (0); } IFC(newAnalysis, (ckt, which, "Pole-Zero Analysis", &foo, task)); parm = INPgetValue(ckt, &line, IF_NODE, tab); GCA(INPapName, (ckt, which, foo, "nodei", parm)); parm = INPgetValue(ckt, &line, IF_NODE, tab); GCA(INPapName, (ckt, which, foo, "nodeg", parm)); parm = INPgetValue(ckt, &line, IF_NODE, tab); GCA(INPapName, (ckt, which, foo, "nodej", parm)); parm = INPgetValue(ckt, &line, IF_NODE, tab); GCA(INPapName, (ckt, which, foo, "nodek", parm)); INPgetTok(&line, &steptype, 1); /* get V or I */ ptemp.iValue = 1; GCA(INPapName, (ckt, which, foo, steptype, &ptemp)); INPgetTok(&line, &steptype, 1); /* get POL, ZER, or PZ */ ptemp.iValue = 1; GCA(INPapName, (ckt, which, foo, steptype, &ptemp)); return (0); }
static int dot_ac(char *line, CKTcircuit *ckt, INPtables *tab, struct card *current, TSKtask *task, CKTnode *gnode, JOB *foo) { int error; /* error code temporary */ IFvalue ptemp; /* a value structure to package resistance into */ IFvalue *parm; /* a pointer to a value struct for function returns */ int which; /* which analysis we are performing */ char *steptype; /* ac analysis, type of stepping function */ NG_IGNORE(gnode); /* .ac {DEC OCT LIN} NP FSTART FSTOP */ which = ft_find_analysis("AC"); if (which == -1) { LITERR("AC small signal analysis unsupported.\n"); return (0); } IFC(newAnalysis, (ckt, which, "AC Analysis", &foo, task)); INPgetTok(&line, &steptype, 1); /* get DEC, OCT, or LIN */ ptemp.iValue = 1; GCA(INPapName, (ckt, which, foo, steptype, &ptemp)); tfree(steptype); parm = INPgetValue(ckt, &line, IF_INTEGER, tab); /* number of points */ GCA(INPapName, (ckt, which, foo, "numsteps", parm)); parm = INPgetValue(ckt, &line, IF_REAL, tab); /* fstart */ GCA(INPapName, (ckt, which, foo, "start", parm)); parm = INPgetValue(ckt, &line, IF_REAL, tab); /* fstop */ GCA(INPapName, (ckt, which, foo, "stop", parm)); return (0); }
static int dot_tf(char *line, CKTcircuit *ckt, INPtables *tab, struct card *current, TSKtask *task, CKTnode *gnode, JOB *foo) { char *name; /* the resistor's name */ int error; /* error code temporary */ IFvalue ptemp; /* a value structure to package resistance into */ int which; /* which analysis we are performing */ char *nname1; /* the first node's name */ char *nname2; /* the second node's name */ CKTnode *node1; /* the first node's node pointer */ CKTnode *node2; /* the second node's node pointer */ /* .tf v( node1, node2 ) src */ /* .tf vsrc2 src */ which = ft_find_analysis("TF"); if (which == -1) { LITERR("Transfer Function analysis unsupported.\n"); return (0); } IFC(newAnalysis, (ckt, which, "Transfer Function", &foo, task)); INPgetTok(&line, &name, 0); /* name is now either V or I or a serious error */ if (*name == 'v' && strlen(name) == 1) { if (*line != '(' ) { /* error, bad input format */ } INPgetNetTok(&line, &nname1, 0); INPtermInsert(ckt, &nname1, tab, &node1); ptemp.nValue = node1; GCA(INPapName, (ckt, which, foo, "outpos", &ptemp)); if (*line != ')') { INPgetNetTok(&line, &nname2, 1); INPtermInsert(ckt, &nname2, tab, &node2); ptemp.nValue = node2; GCA(INPapName, (ckt, which, foo, "outneg", &ptemp)); ptemp.sValue = tprintf("V(%s,%s)", nname1, nname2); GCA(INPapName, (ckt, which, foo, "outname", &ptemp)); } else { ptemp.nValue = gnode; GCA(INPapName, (ckt, which, foo, "outneg", &ptemp)); ptemp.sValue = tprintf("V(%s)", nname1); GCA(INPapName, (ckt, which, foo, "outname", &ptemp)); } } else if (*name == 'i' && strlen(name) == 1) { INPgetTok(&line, &name, 1); INPinsert(&name, tab); ptemp.uValue = name; GCA(INPapName, (ckt, which, foo, "outsrc", &ptemp)); } else { LITERR("Syntax error: voltage or current expected.\n"); return 0; } INPgetTok(&line, &name, 1); INPinsert(&name, tab); ptemp.uValue = name; GCA(INPapName, (ckt, which, foo, "insrc", &ptemp)); return (0); }
void INP2V(void *ckt, INPtables * tab, card * current) { /* Vname <node> <node> [ [DC] <val>] [AC [<val> [<val> ] ] ] * [<tran function>] */ int type; /* the type the model says it is */ char *line; /* the part of the current line left to parse */ char *name; /* the resistor's name */ char *nname1; /* the first node's name */ char *nname2; /* the second node's name */ void *node1; /* the first node's node pointer */ void *node2; /* the second node's node pointer */ int error; /* error code temporary */ void *fast; /* pointer to the actual instance */ IFvalue ptemp; /* a value structure to package resistance into */ int waslead; /* flag to indicate that funny unlabeled number was found */ double leadval; /* actual value of unlabeled number */ IFuid uid; /* uid for default model */ type = INPtypelook("Vsource"); if (type < 0) { LITERR("Device type Vsource not supported by this binary\n"); return; } line = current->line; INPgetTok(&line, &name, 1); INPinsert(&name, tab); INPgetNetTok(&line, &nname1, 1); INPtermInsert(ckt, &nname1, tab, &node1); INPgetNetTok(&line, &nname2, 1); INPtermInsert(ckt, &nname2, tab, &node2); if (!tab->defVmod) { /* create default V model */ IFnewUid(ckt, &uid, (IFuid) NULL, "V", UID_MODEL, (void **) NULL); IFC(newModel, (ckt, type, &(tab->defVmod), uid)); } IFC(newInstance, (ckt, tab->defVmod, &fast, name)); IFC(bindNode, (ckt, fast, 1, node1)); IFC(bindNode, (ckt, fast, 2, node2)); PARSECALL((&line, ckt, type, fast, &leadval, &waslead, tab)); if (waslead) { ptemp.rValue = leadval; GCA(INPpName, ("dc", &ptemp, ckt, type, fast)); } }
HRESULT CTedPlayer::Reset() { HRESULT hr; IFC( m_spSession->ClearTopologies() ); Cleanup: return hr; }
/*SP: Steady State Analyis */ static int dot_pss(char *line, void *ckt, INPtables *tab, struct card *current, void *task, void *gnode, JOB *foo) { int error; /* error code temporary */ IFvalue ptemp; /* a value structure to package resistance into */ IFvalue *parm; /* a pointer to a value struct for function returns */ char *nname; /* the oscNode name */ CKTnode *nnode; /* the oscNode node */ int which; /* which analysis we are performing */ char *word; /* something to stick a word of input into */ NG_IGNORE(gnode); /* .pss Fguess StabTime OscNode <UIC>*/ which = ft_find_analysis("PSS"); if (which == -1) { LITERR("Periodic steady state analysis unsupported.\n"); return (0); } IFC(newAnalysis, (ckt, which, "Periodic Steady State Analysis", &foo, task)); parm = INPgetValue(ckt, &line, IF_REAL, tab); /* Fguess */ GCA(INPapName, (ckt, which, foo, "fguess", parm)); parm = INPgetValue(ckt, &line, IF_REAL, tab); /* StabTime */ GCA(INPapName, (ckt, which, foo, "stabtime", parm)); INPgetNetTok(&line, &nname, 0); INPtermInsert(ckt, &nname, tab, &nnode); ptemp.nValue = nnode; GCA(INPapName, (ckt, which, foo, "oscnode", &ptemp)); /* OscNode given as string */ parm = INPgetValue(ckt, &line, IF_INTEGER, tab); /* PSS points */ GCA(INPapName, (ckt, which, foo, "points", parm)); parm = INPgetValue(ckt, &line, IF_INTEGER, tab); /* PSS harmonics */ GCA(INPapName, (ckt, which, foo, "harmonics", parm)); parm = INPgetValue(ckt, &line, IF_INTEGER, tab); /* SC iterations */ GCA(INPapName, (ckt, which, foo, "sc_iter", parm)); parm = INPgetValue(ckt, &line, IF_REAL, tab); /* Steady coefficient */ GCA(INPapName, (ckt, which, foo, "steady_coeff", parm)); if (*line) { INPgetTok(&line, &word, 1); /* uic? */ if (strcmp(word, "uic") == 0) { ptemp.iValue = 1; GCA(INPapName, (ckt, which, foo, "uic", &ptemp)); } else { fprintf(stderr,"Error: unknown parameter %s on .pss - ignored\n", word); } } return (0); }
HRESULT CTedPlayer::InitFromSession() { HRESULT hr = S_OK; CComPtr<IMFClock> spClock; if(m_spSessionClock.p) { m_spSessionClock.Release(); } IFC( Reset() ); IFC( m_spSession->GetClock(&spClock) ); IFC( spClock->QueryInterface(IID_IMFPresentationClock, (void**) &m_spSessionClock) ); m_bIsPaused = false; Cleanup: return hr; }
HRESULT CTedPlayer::Pause() { HRESULT hr; m_bIsPaused = true; IFC( m_spSession->Pause() ); Cleanup: return hr; }
HRESULT CTedPlayer::InitClear() { HRESULT hr; if(m_spSession) { if(m_bIsPlaying) { m_bIsPlaying = false; m_spSession->Stop(); } m_spSession.Release(); } if(m_fPendingClearCustomTopoloader && m_spClearSession.p) { m_spClearSession->Shutdown(); m_spClearSession.Release(); } if(m_spClearSession.p == NULL) { CComPtr<IMFAttributes> spConfiguration = NULL; if(m_fPendingClearCustomTopoloader && GUID_NULL != m_gidCustomTopoloader) { IFC( MFCreateAttributes(&spConfiguration, 1) ); IFC( spConfiguration->SetGUID(MF_SESSION_TOPOLOADER, m_gidCustomTopoloader) ); } IFC( MFCreateMediaSession(spConfiguration, &m_spClearSession) ); IFC( m_spClearSession->BeginGetEvent(&m_xOnClearSessionEvent, NULL) ); m_fPendingClearCustomTopoloader = false; } m_spSession = m_spClearSession; IFC( InitFromSession() ); Cleanup: return hr; }
extern "C" HRESULT WINAPI SetAlpha(BOOL fUseAlpha) { HRESULT hr = S_OK; IFC(EnsureRendererManager()); pManager->SetAlpha(!!fUseAlpha); Cleanup: return hr; }
extern "C" HRESULT WINAPI SetSize(UINT uWidth, UINT uHeight) { HRESULT hr = S_OK; IFC(EnsureRendererManager()); pManager->SetSize(uWidth, uHeight); Cleanup: return hr; }
void CTedPlayer::OnProtectedSessionEvent(IMFAsyncResult* pResult) { HRESULT hr; CComPtr<IMFMediaEvent> spEvent; IFC( m_spProtectedSession->EndGetEvent(pResult, &spEvent) ); if(m_spSession.p == m_spProtectedSession.p) { IFC( HandleEvent(spEvent) ); } IFC( m_spProtectedSession->BeginGetEvent(&m_xOnProtectedSessionEvent, NULL) ); Cleanup: if(FAILED(hr)) { m_pMediaEventHandler->NotifyEventError(hr); } }
HRESULT CTedPlayer::Stop() { HRESULT hr; IFC( m_spSession->Stop() ); m_bIsPlaying = false; Cleanup: return hr; }
extern "C" HRESULT WINAPI SetAdapter(POINT screenSpacePoint) { HRESULT hr = S_OK; IFC(EnsureRendererManager()); pManager->SetAdapter(screenSpacePoint); Cleanup: return hr; }
extern "C" HRESULT WINAPI SetNumDesiredSamples(UINT uNumSamples) { HRESULT hr = S_OK; IFC(EnsureRendererManager()); pManager->SetNumDesiredSamples(uNumSamples); Cleanup: return hr; }
HRESULT CTedPlayer::GetDuration(MFTIME& hnsTime) { HRESULT hr = S_OK; IMFPresentationDescriptor *pPD = NULL; if(NULL != m_spSource.p) { IFC( m_spSource->CreatePresentationDescriptor( &pPD ) ); IFC( pPD->GetUINT64( MF_PD_DURATION, (UINT64*) &hnsTime ) ); } else { hr = E_POINTER; } Cleanup: if(pPD) pPD->Release(); return( hr ); }
HRESULT CTedTestSink::InitVideoStream() { HRESULT hr = S_OK; InternalAddRef(); /*IMFMediaSink* pMediaSink; InternalQueryInterface(this, CTedTestSink::_GetEntries(), IID_IMFMediaSink, (void**) &pMediaSink);*/ CComPtr<IMFMediaType> spVideoType; IFC( MFCreateMediaType(&spVideoType) ); IFC( spVideoType->SetGUID(MF_MT_MAJOR_TYPE, MFMediaType_Video) ); IFC( spVideoType->SetGUID(MF_MT_SUBTYPE, MFVideoFormat_RGB24) ); CComObject<CTedTestMediaTypeHandler>* pVideoTypeHandler = NULL; IFC( CComObject<CTedTestMediaTypeHandler>::CreateInstance(&pVideoTypeHandler) ); pVideoTypeHandler->AddRef(); pVideoTypeHandler->SetMajorType(MFMediaType_Video); pVideoTypeHandler->AddAvailableType(spVideoType); CComObject<CTedTestStreamSink>* pVideoStreamSink = NULL; IFC( CComObject<CTedTestStreamSink>::CreateInstance(&pVideoStreamSink) ); pVideoStreamSink->AddRef(); m_spVideoStreamSink = pVideoStreamSink; //IFC( pVideoStreamSink->Init(pMediaSink, pVideoTypeHandler, 1) ); IFC( pVideoStreamSink->Init(this, pVideoTypeHandler, 1) ); pVideoTypeHandler->Release(); pVideoStreamSink->Release(); //pMediaSink->Release(); Cleanup: return hr; }
//+----------------------------------------------------------------------------- // // Member: // CRenderer::CreateSurface // // Synopsis: // Creates and sets the render target // //------------------------------------------------------------------------------ HRESULT CRenderer::CreateSurface(UINT uWidth, UINT uHeight, bool fUseAlpha, UINT m_uNumSamples) { HRESULT hr = S_OK; SAFE_RELEASE(m_pd3dRTS); IFC(m_pd3dDevice->CreateRenderTarget( uWidth, uHeight, fUseAlpha ? D3DFMT_A8R8G8B8 : D3DFMT_X8R8G8B8, static_cast<D3DMULTISAMPLE_TYPE>(m_uNumSamples), 0, m_pd3dDeviceEx ? FALSE : TRUE, // Lockable RT required for good XP perf &m_pd3dRTS, NULL )); IFC(m_pd3dDevice->SetRenderTarget(0, m_pd3dRTS)); Cleanup: return hr; }
HRESULT Init() { HRESULT hr = S_OK; // Get OpenGL functions glGenBuffers = (PFNGLGENBUFFERSPROC)wglGetProcAddress("glGenBuffers"); glBindBuffer = (PFNGLBINDBUFFERPROC)wglGetProcAddress("glBindBuffer"); glBufferData = (PFNGLBUFFERDATAPROC)wglGetProcAddress("glBufferData"); glEnableVertexAttribArray = (PFNGLENABLEVERTEXATTRIBARRAYPROC)wglGetProcAddress("glEnableVertexAttribArray"); glVertexAttribPointer = (PFNGLVERTEXATTRIBPOINTERPROC)wglGetProcAddress("glVertexAttribPointer"); glCreateProgram = (PFNGLCREATEPROGRAMPROC)wglGetProcAddress("glCreateProgram"); glDeleteProgram = (PFNGLDELETEPROGRAMPROC)wglGetProcAddress("glDeleteProgram"); glUseProgram = (PFNGLUSEPROGRAMPROC)wglGetProcAddress("glUseProgram"); glAttachShader = (PFNGLATTACHSHADERPROC)wglGetProcAddress("glAttachShader"); glLinkProgram = (PFNGLLINKPROGRAMPROC)wglGetProcAddress("glLinkProgram"); glGetProgramiv = (PFNGLGETPROGRAMIVPROC)wglGetProcAddress("glGetProgramiv"); glGetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC)wglGetProcAddress("glGetProgramInfoLog"); glGetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC)wglGetProcAddress("glGetShaderInfoLog"); glCreateShader = (PFNGLCREATESHADERPROC)wglGetProcAddress("glCreateShader"); glDeleteShader = (PFNGLDELETESHADERPROC)wglGetProcAddress("glDeleteShader"); glShaderSource = (PFNGLSHADERSOURCEPROC)wglGetProcAddress("glShaderSource"); glCompileShader = (PFNGLCOMPILESHADERPROC)wglGetProcAddress("glCompileShader"); glGetShaderiv = (PFNGLGETSHADERIVPROC)wglGetProcAddress("glGetShaderiv"); GLuint program; IFC( CreateProgram(&program) ); glUseProgram(program); // Calculate random starting positions for (uint i = 0; i < g_numNodes; i++) { g_nodes[i].position.setX(frand()*2 - 1); g_nodes[i].position.setY(frand()*2 - 1); } // Initialize buffers uint positionSlot = 0; GLsizei stride = sizeof(g_nodes[0]); GLsizei totalSize = sizeof(g_nodes); uint offset = (char*)&g_nodes[0].position - (char*)&g_nodes[0]; glGenBuffers(1, &g_vboPos); glBindBuffer(GL_ARRAY_BUFFER, g_vboPos); glBufferData(GL_ARRAY_BUFFER, totalSize, g_nodes, GL_STREAM_DRAW); glEnableVertexAttribArray(positionSlot); glVertexAttribPointer(positionSlot, 2, GL_UNSIGNED_SHORT, GL_TRUE, stride, (GLvoid*)offset); Cleanup: return hr; }