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