bool HwAccVaApi::fillContext(AVCodecContext *avctx) {
if (status() != VA_STATUS_SUCCESS)
return false;
freeContext();
d->context.display = VaApi::glx();
if (!d->context.display)
return false;
const auto codec = VaApi::codec(avctx->codec_id);
if (!codec)
return false;
d->profile = codec->profile(avctx->profile);
VAConfigAttrib attr = { VAConfigAttribRTFormat, 0 };
if(!isSuccess(vaGetConfigAttributes(d->context.display, d->profile, VAEntrypointVLD, &attr, 1)))
return false;
const uint rts = attr.value & (VA_RT_FORMAT_YUV420 | VA_RT_FORMAT_YUV422);
if(!rts)
return isSuccess(VA_STATUS_ERROR_UNSUPPORTED_RT_FORMAT);
if(!isSuccess(vaCreateConfig(d->context.display, d->profile, VAEntrypointVLD, &attr, 1, &d->context.config_id)))
return false;
const int w = avctx->width, h = avctx->height;
auto tryRtFormat = [rts, this, codec, w, h] (uint rt) { return (rts & rt) && d->pool.create(codec->surfaces, w, h, rt); };
if (!tryRtFormat(VA_RT_FORMAT_YUV420) && !tryRtFormat(VA_RT_FORMAT_YUV422))
return false;
VaApi::get().setSurfaceFormat(d->pool.format());
auto ids = d->pool.ids();
if (!isSuccess(vaCreateContext(d->context.display, d->context.config_id, w, h, VA_PROGRESSIVE, ids.data(), ids.size(), &d->context.context_id)))
return false;
return true;
}
int ooH323EpDestroy(void)
{
/* free any internal memory allocated
close trace file free context structure
*/
OOH323CallData * cur, *temp;
if(OO_TESTFLAG(gH323ep.flags, OO_M_ENDPOINTCREATED))
{
OOTRACEINFO1("Destroying H323 Endpoint\n");
if(gH323ep.callList)
{
cur = gH323ep.callList;
while(cur)
{
temp = cur;
cur = cur->next;
temp->callEndReason = OO_REASON_LOCAL_CLEARED;
ooCleanCall(temp);
}
gH323ep.callList = NULL;
}
if(gH323ep.listener)
{
ooSocketClose(*(gH323ep.listener));
gH323ep.listener = NULL;
}
ooGkClientDestroy();
if(gH323ep.fptraceFile)
{
fclose(gH323ep.fptraceFile);
gH323ep.fptraceFile = NULL;
}
freeContext(&(gH323ep.ctxt));
freeContext(&(gH323ep.msgctxt));
OO_CLRFLAG(gH323ep.flags, OO_M_ENDPOINTCREATED);
}
return OO_OK;
}
bool HwAccVda::fillContext(AVCodecContext *avctx) {
freeContext();
d->ok = false;
d->context.width = avctx->width;
d->context.height = avctx->height;
d->context.format = 'avc1';
d->context.use_sync_decoding = 1;
d->context.use_ref_buffer = 1;
if (kVDADecoderNoErr != _ff_vda_create_decoder(&d->context, avctx->extradata, avctx->extradata_size))
return false;
return (d->ok = true);
}
bool WinWindow::deactivate()
{
// minimize window while not active. skip if being destroyed.
if (!inDestroy)
ShowWindow(hwnd, SW_MINIMIZE);
// destroy OpenGL context
const bool hadChild = (hDCChild != NULL);
freeContext();
inactiveDueToDeactivate = true;
return hadChild;
}
iocp_key_t IOCPNetwork::add(HANDLE h, unsigned long sessionTimeo, size_t readSpeedLmt, size_t writeSpeedLmt, bool isFile, bool sync)
{
iocp_context_t* context = allocContext();
context->h = h;
if(isFile) context->type = IOCP_HANDLE_FILE;
else context->type = IOCP_HANDLE_SOCKET;
context->lockPtr = NULL;
context->readOlp.speedLmt = readSpeedLmt;
context->writeOlp.speedLmt = writeSpeedLmt;
context->startCounter = _hrt.now();
context->sessionTimeo = sessionTimeo;
bool ret = true;
_lock.lock();
do
{
if( _iocpHandle != CreateIoCompletionPort(h, _iocpHandle, reinterpret_cast<ULONG_PTR>(context), 0))
{
assert(0);
ret = false;
break;
}
else
{
if(sync)
{
context->lockPtr = _lockPool.allocate();
}
else
{
context->lockPtr = NULL;
}
_contextMap.insert(std::make_pair(h, context));
}
}while(0);
_lock.unlock();
if(ret)
{
//TRACE("iocp key 0x%x allocated.\r\n", context);
return context;
}
else
{
freeContext(context);
return IOCP_NULLKEY;
}
}
int main( int argc, char *argv[] )
{
// Open the program's source.
if ( argc != 2 )
usage();
FILE *fp = fopen( argv[ 1 ], "r" );
if ( !fp ) {
fprintf( stderr, "Can't open file: %s\n", argv[ 1 ] );
usage();
}
// Parse the whole program source into an expression object.
// The parser uses a one-token lookahead to help parsing compound expressions.
char tok[ MAX_TOKEN + 1 ];
Expr *expr = parse( expectToken( tok, fp ), fp );
// If this is a legal input, there shouldn't be any extra tokens at the end.
if ( nextToken( tok, fp ) ) {
fprintf( stderr, "line %d: unexpected token \"%s\"\n", linesRead(), tok );
exit( EXIT_FAILURE );
}
fclose( fp );
// Run the program.
Context *ctxt = makeContext();
char *result = expr->eval( expr, ctxt );
// Everything evaluates to a dynamically allocated string, but we don't
// do anything with the one out of the top-level expression.
free( result );
// We're done, free everything.
freeContext( ctxt );
expr->destroy( expr );
return EXIT_SUCCESS;
}
int IOCPNetwork::destroy()
{
/*
* destroy 需要等待工作线程结束,如果工作线程中调用destroy,会死锁.
*/
if(_tids)
{
uintptr_t curThread = reinterpret_cast<uintptr_t>(GetCurrentThread());
for(int i = 0; i < _threads; ++i)
{
if(curThread == _tids[i]) return IOCP_DESTROYFAILED;
}
}
/*
* 马上设置停止标志
*/
_inited = false;
/*
* 发送退出通知,确保工作线程都从GetQueuedCompletionStatus阻塞中返回并终止运行.
*/
if(_tids)
{
assert(_threads > 0);
if(_iocpHandle)
{
for(int i = 0; i < _threads; ++i)
{
PostQueuedCompletionStatus(_iocpHandle, 0, NULL, NULL);
}
}
for(int i = 0; i < _threads; ++i)
{
if( _tids[i] )
{
WaitForSingleObject(reinterpret_cast<HANDLE>(_tids[i]), INFINITE);
CloseHandle(reinterpret_cast<HANDLE>(_tids[i]));
}
}
delete []_tids;
}
_tids = NULL;
_threads = 0;
/*
* 关闭完成端口句柄
*/
if(_iocpHandle)
{
if(!CloseHandle(_iocpHandle))
{
assert(0);
}
_iocpHandle = NULL;
}
/*
* 关闭定时器
*/
_timerQueue.destroy();
/*
* 回收资源
*/
if(_contextMap.size() > 0)
{
for(context_map_t::iterator iter = _contextMap.begin(); iter != _contextMap.end(); ++iter)
{
iocp_context_t *context = iter->second;
/*
* 关闭套接字
*/
if(!(context->status & IOCP_HANDLE_CLOSED))
{
closeHandle(context);
context->status |= IOCP_HANDLE_CLOSED;
}
freeContext(context);
}
_contextMap.clear();
}
/*
* 同步锁池
*/
_lockPool.destroy();
return IOCP_SUCESS;
}
int IOCPNetwork::remove(iocp_key_t key)
{
if( !_inited ) return IOCP_UNINITIALIZED;
iocp_context_t* context = reinterpret_cast<iocp_context_t*>(key);
bool isBusy = false;
/*
* 如果套接字处于忙碌状态,则设置删除标志并关闭套接字.
*/
if(context->lockPtr) context->lockPtr->wlock();
if( context->readOlp.oppType != IOCP_NONE || context->writeOlp.oppType != IOCP_NONE )
{
isBusy = true;
}
else
{
/* 空闲状态,设置一个删除标志,禁止继续操作 */
context->status |= IOCP_REMOVE;
}
if(context->lockPtr) context->lockPtr->unlock();
/*
* 如果套接字处于忙碌状态,则关闭
*/
if(isBusy)
{
return IOCP_BUSY;
}
/*
* 删除各个定时器.延时操作.
*/
if(context->readOlp.timer != NULL)
{
assert(0);
_timerQueue.deleteTimer(context->readOlp.timer, true);
context->readOlp.timer = NULL;
}
if(context->writeOlp.timer != NULL)
{
assert(0);
_timerQueue.deleteTimer(context->writeOlp.timer, true);
context->writeOlp.timer = NULL;
}
/*
* 关闭套接字
*/
if(!(context->status & IOCP_HANDLE_CLOSED))
{
closeHandle(context);
context->status |= IOCP_HANDLE_CLOSED;
}
/*
* 移除记录
*/
_lock.lock();
_contextMap.erase(context->h);
if(context->lockPtr)
{
_lockPool.recycle(context->lockPtr);
context->lockPtr = NULL;
}
_lock.unlock();
/*
* 回收资源
*/
freeContext(context);
return IOCP_SUCESS;
}
static struct session *h225_ras_callback(struct session *ras, u_char *data, uint32_t len)
{
OOCTXT ctxt;
H225RasMessage *pRasMsg;
struct session *cs;
struct session *rasbkp;
initContext(&ctxt);
if (ASN_OK != setPERBuffer(&ctxt, data, len, TRUE))
return ras;
rasbkp = ras;
pRasMsg = (H225RasMessage *)memAlloc(&ctxt, sizeof (H225RasMessage));
if (ASN_OK == asn1PD_H225RasMessage(&ctxt, pRasMsg))
switch (pRasMsg->t) {
case T_H225RasMessage_admissionRequest:
if (bonus_time)
break;
if ('\0' != ras->u.ras_params.call_id[0])
ras = sessions_add(TYPE_UDP | TYPE_H225_RAS, &ras->addr, NULL);
memcpy(ras->u.ras_params.call_id, pRasMsg->u.admissionRequest->conferenceID.data, 16);
ras->u.ras_params.seqnum = pRasMsg->u.admissionRequest->requestSeqNum;
ras->timeout = nids_last_pcap_header->ts.tv_sec + 60;
/* 60 seconds for the gatekeeper to confirm admission */
break;
case T_H225RasMessage_admissionConfirm:
if (bonus_time)
break;
while ((NULL != ras) && (ras->u.ras_params.seqnum != pRasMsg->u.admissionConfirm->requestSeqNum))
ras = sessions_find(ras->next, TYPE_UDP | TYPE_H225_RAS, 0, &ras->addr);
if (NULL == ras) {
ras = rasbkp;
break;
}
if (pRasMsg->u.admissionConfirm->destCallSignalAddress.t != T_H225TransportAddress_ipAddress) {
ras->timeout = nids_last_pcap_header->ts.tv_sec; /* delete after dumping frame */
break;
}
ras->u.ras_params.cs_addr.dest = pRasMsg->u.admissionConfirm->destCallSignalAddress.u.ipAddress->port;
ras->u.ras_params.cs_addr.daddr = *((u_int *)pRasMsg->u.admissionConfirm->destCallSignalAddress.u.ipAddress->ip.data);
if (NULL != (cs = sessions_add(TYPE_TCP | TYPE_H225_CS, &ras->u.ras_params.cs_addr, ras)))
cs->timeout = nids_last_pcap_header->ts.tv_sec + 60;
/* 60 seconds to establish the Call Signaling stream */
break;
case T_H225RasMessage_admissionReject:
while ((NULL != ras) && (ras->u.ras_params.seqnum != pRasMsg->u.admissionReject->requestSeqNum))
ras = sessions_find(ras->next, TYPE_UDP | TYPE_H225_RAS, 0, &ras->addr);
if (NULL == ras) {
ras = rasbkp;
break;
}
ras->timeout = nids_last_pcap_header->ts.tv_sec; /* delete after dumping frame */
break;
case T_H225RasMessage_disengageRequest:
while ((NULL != ras) && memcmp(ras->u.ras_params.call_id, pRasMsg->u.disengageRequest->conferenceID.data, 16))
ras = sessions_find(ras->next, TYPE_UDP | TYPE_H225_RAS, 0, &ras->addr);
if (NULL == ras) {
ras = rasbkp;
break;
}
ras->u.ras_params.seqnum = pRasMsg->u.disengageRequest->requestSeqNum;
break;
case T_H225RasMessage_disengageConfirm:
while ((NULL != ras) && (ras->u.ras_params.seqnum != pRasMsg->u.disengageConfirm->requestSeqNum))
ras = sessions_find(ras->next, TYPE_UDP | TYPE_H225_RAS, 0, &ras->addr);
if (NULL == ras) {
ras = rasbkp;
break;
}
ras->timeout = nids_last_pcap_header->ts.tv_sec; /* delete after dumping frame */
}
memFreePtr(&ctxt, pRasMsg);
freeContext(&ctxt);
return ras;
}
HwAccVaApi::~HwAccVaApi() {
freeContext();
if (d->context.config_id != VA_INVALID_ID)
vaDestroyConfig(d->context.display, d->context.config_id);
delete d;
}
OOH323CallData* ooCreateCall(char* type, char*callToken)
{
OOH323CallData *call=NULL;
OOCTXT *pctxt=NULL;
pctxt = newContext();
if(!pctxt)
{
OOTRACEERR1("ERROR:Failed to create OOCTXT for new call\n");
return NULL;
}
call = (OOH323CallData*)memAlloc(pctxt, sizeof(OOH323CallData));
if(!call)
{
OOTRACEERR1("ERROR:Memory - ooCreateCall - call\n");
return NULL;
}
/* memset(call, 0, sizeof(OOH323CallData));*/
call->pctxt = pctxt;
call->callMode = gH323ep.callMode;
sprintf(call->callToken, "%s", callToken);
sprintf(call->callType, "%s", type);
call->callReference = 0;
if(gH323ep.callerid) {
strncpy(call->ourCallerId, gH323ep.callerid, sizeof(call->ourCallerId)-1);
call->ourCallerId[sizeof(call->ourCallerId)-1] = '\0';
}
else {
call->ourCallerId[0] = '\0';
}
memset(&call->callIdentifier, 0, sizeof(H225CallIdentifier));
memset(&call->confIdentifier, 0, sizeof(H225ConferenceIdentifier));
call->flags = 0;
if (OO_TESTFLAG(gH323ep.flags, OO_M_TUNNELING))
OO_SETFLAG (call->flags, OO_M_TUNNELING);
if(gH323ep.gkClient)
{
if(OO_TESTFLAG(gH323ep.flags, OO_M_GKROUTED))
{
OO_SETFLAG(call->flags, OO_M_GKROUTED);
}
}
if (OO_TESTFLAG(gH323ep.flags, OO_M_FASTSTART))
OO_SETFLAG (call->flags, OO_M_FASTSTART);
if (OO_TESTFLAG(gH323ep.flags, OO_M_MEDIAWAITFORCONN))
OO_SETFLAG (call->flags, OO_M_MEDIAWAITFORCONN);
call->callState = OO_CALL_CREATED;
call->callEndReason = OO_REASON_UNKNOWN;
call->pCallFwdData = NULL;
if(!strcmp(call->callType, "incoming"))
{
call->callingPartyNumber = NULL;
}
else{
if(ooUtilsIsStrEmpty(gH323ep.callingPartyNumber))
{
call->callingPartyNumber = NULL;
}
else{
call->callingPartyNumber = (char*) memAlloc(call->pctxt,
strlen(gH323ep.callingPartyNumber)+1);
if(call->callingPartyNumber)
{
strcpy(call->callingPartyNumber, gH323ep.callingPartyNumber);
}
else{
OOTRACEERR3("Error:Memory - ooCreateCall - callingPartyNumber"
".(%s, %s)\n", call->callType, call->callToken);
freeContext(pctxt);
return NULL;
}
}
}
call->calledPartyNumber = NULL;
call->h245ConnectionAttempts = 0;
call->h245SessionState = OO_H245SESSION_IDLE;
call->dtmfmode = gH323ep.dtmfmode;
call->mediaInfo = NULL;
strcpy(call->localIP, gH323ep.signallingIP);
call->pH225Channel = NULL;
call->pH245Channel = NULL;
call->h245listener = NULL;
call->h245listenport = NULL;
call->remoteIP[0] = '\0';
call->remotePort = 0;
call->remoteH245Port = 0;
call->remoteDisplayName = NULL;
call->remoteAliases = NULL;
call->ourAliases = NULL;
call->masterSlaveState = OO_MasterSlave_Idle;
call->statusDeterminationNumber = 0;
call->localTermCapState = OO_LocalTermCapExchange_Idle;
call->remoteTermCapState = OO_RemoteTermCapExchange_Idle;
call->ourCaps = NULL;
call->remoteCaps = NULL;
call->jointCaps = NULL;
dListInit(&call->remoteFastStartOLCs);
call->remoteTermCapSeqNo =0;
call->localTermCapSeqNo = 0;
memcpy(&call->capPrefs, &gH323ep.capPrefs, sizeof(OOCapPrefs));
call->logicalChans = NULL;
call->noOfLogicalChannels = 0;
call->logicalChanNoBase = 1001;
call->logicalChanNoMax = 1100;
call->logicalChanNoCur = 1001;
call->nextSessionID = 4; /* 1,2,3 are reserved for audio, video and data */
dListInit(&call->timerList);
call->msdRetries = 0;
call->pFastStartRes = NULL;
call->usrData = NULL;
OOTRACEINFO3("Created a new call (%s, %s)\n", call->callType,
call->callToken);
/* Add new call to calllist */
ooAddCallToList (call);
if(gH323ep.h323Callbacks.onNewCallCreated)
gH323ep.h323Callbacks.onNewCallCreated(call);
return call;
}
int ooCleanCall(OOH323CallData *call)
{
OOCTXT *pctxt;
OOTRACEWARN4 ("Cleaning Call (%s, %s)- reason:%s\n",
call->callType, call->callToken,
ooGetReasonCodeText (call->callEndReason));
/* First clean all the logical channels, if not already cleaned. */
if(call->logicalChans)
ooClearAllLogicalChannels(call);
/* Close H.245 connection, if not already closed */
if(call->h245SessionState != OO_H245SESSION_CLOSED)
ooCloseH245Connection(call);
else{
if(call->pH245Channel && call->pH245Channel->outQueue.count > 0)
{
dListFreeAll(call->pctxt, &(call->pH245Channel->outQueue));
memFreePtr(call->pctxt, call->pH245Channel);
}
}
/* Close H.245 listener, if not already closed */
if(call->h245listener)
{
ooCloseH245Listener(call);
}
/* Close H225 connection, if not already closed. */
if (0 != call->pH225Channel && 0 != call->pH225Channel->sock)
{
ooCloseH225Connection(call);
}
/* Clean timers */
if(call->timerList.count > 0)
{
dListFreeAll(call->pctxt, &(call->timerList));
}
if(gH323ep.gkClient && !OO_TESTFLAG(call->flags, OO_M_DISABLEGK))
{
ooGkClientCleanCall(gH323ep.gkClient, call);
}
ooRemoveCallFromList (call);
OOTRACEINFO3("Removed call (%s, %s) from list\n", call->callType,
call->callToken);
if(call->pCallFwdData && call->pCallFwdData->fwdedByRemote)
{
if(gH323ep.h323Callbacks.onCallForwarded)
gH323ep.h323Callbacks.onCallForwarded(call);
if(ooH323HandleCallFwdRequest(call)!= OO_OK)
{
OOTRACEERR3("Error:Failed to forward call (%s, %s)\n", call->callType,
call->callToken);
}
}
else {
if(gH323ep.h323Callbacks.onCallCleared)
gH323ep.h323Callbacks.onCallCleared(call);
}
pctxt = call->pctxt;
freeContext(pctxt);
ASN1CRTFREE0(pctxt);
return OO_OK;
}
HwAccVdpau::~HwAccVdpau() {
freeContext();
delete d;
}
int main(void) {
unsigned ticksPerFrame = 1000/FRAMES_PER_SECOND;
SDL_Surface* screen;
Context* ct;
if(SDL_Init(SDL_INIT_EVERYTHING) != 0) {
fprintf(stderr,"SDL init failed");
return -1;
}
if(!(screen = SDL_SetVideoMode(SCREEN_WIDTH,SCREEN_HEIGHT,
SCREEN_BPP,SDL_SWSURFACE))) {
fprintf(stderr,"SDL video init failed");
return -1;
}
if(!(ct = createContext(SCREEN_WIDTH,SCREEN_HEIGHT))) {
fprintf(stderr,"Context init failed");
return -1;
}
ct->depthEnabled = 1;
ct->cullBackFace = 1;
ct->frontFace = WINDING_CCW;
ct->vertShader = &shadeVertex;
ct->fragShader = &shadeFragment;
mat44Perspective(matStackTop(ct->matrices[MATRIX_PROJECTION]),
FOVY,SCREEN_WIDTH/(float)SCREEN_HEIGHT,1,30);
printf("Projection:\n");
mat44Print(stdout,matStackTop(ct->matrices[MATRIX_PROJECTION]));
mat44Ident(matStackTop(ct->matrices[MATRIX_MODELVIEW]));
Mat44 translate;
mat44Translate(translate,0,0,-4);
Mat44 rotateVert;
mat44Ident(rotateVert);
Mat44 tetraTransform;
mat44Ident(tetraTransform);
float tetraHorizRot = 0,
tetraVertRot = 0;
VertexArray* varr = createVertArray(0,NULL);
varr->locs = &verts[0].loc;
varr->locStep = sizeof(CustomVert);
varr->colors = &verts[0].color;
varr->colorStep = sizeof(CustomVert);
Color4 black = { 0,0,0,0 };
CustomVert* gridVerts;
unsigned* gridIndices;
unsigned gridNumEdges;
makeGrid(&gridVerts,&gridIndices,&gridNumEdges,
-6,-6,6,6,12,12);
VertexArray* gridArr = createVertArray(0,NULL);
gridArr->locs = &gridVerts[0].loc;
gridArr->locStep = sizeof(CustomVert);
gridArr->colors = &gridVerts[0].color;
gridArr->colorStep = sizeof(CustomVert);
Mat44 gridTransform;
mat44Translate(gridTransform,0,-5,0);
SDL_WM_SetCaption(TITLE,NULL);
char title[256];
float fps = 0;
float fpsLerp = 0.2;
int numViewports = 1;
int mouseCaptured = 0;
int running = 1;
int debugged = 0;
while(running) {
Uint32 startTicks = SDL_GetTicks();
int vertRot = 0,
horizRot = 0;
SDL_Event event;
while(SDL_PollEvent(&event)) {
switch(event.type) {
case SDL_QUIT:
running = 0;
break;
case SDL_KEYDOWN:
switch(event.key.keysym.sym) {
case SDLK_ESCAPE:
mouseCaptured = !mouseCaptured;
SDL_ShowCursor(mouseCaptured ? SDL_DISABLE :
SDL_ENABLE);
break;
case SDLK_p:
debugged = 0;
break;
case SDLK_BACKQUOTE:
if(numViewports == 1) {
numViewports = 2;
} else {
numViewports = 1;
}
mat44Perspective(matStackTop(ct->matrices[MATRIX_PROJECTION]),
FOVY,SCREEN_WIDTH/(float)numViewports/SCREEN_HEIGHT,1,30);
break;
default:
break;
}
break;
case SDL_MOUSEMOTION:
if(mouseCaptured) {
SDL_WarpMouse(SCREEN_WIDTH/2,SCREEN_HEIGHT/2);
horizRot = -event.motion.xrel,
vertRot = event.motion.yrel;
}
break;
default:
break;
}
}
if(!debugged) {
printf("\nDebugging!\n\n");
}
clearColorBuffer(ct);
fillDepthBuffer(ct,1);
/* fillBuffers(ct,black,1); */
Uint8* keys = SDL_GetKeyState(NULL);
if(!mouseCaptured) {
vertRot = horizRot = 0;
if(keys[SDLK_UP]) {
vertRot += 1;
}
if(keys[SDLK_DOWN]) {
vertRot -= 1;
}
if(keys[SDLK_RIGHT]) {
horizRot += 1;
}
if(keys[SDLK_LEFT]) {
horizRot -= 1;
}
}
int xDelta = 0,
yDelta = 0,
zDelta = 0;
if(keys[SDLK_w]) {
zDelta -= 1;
}
if(keys[SDLK_s]) {
zDelta += 1;
}
if(keys[SDLK_a]) {
xDelta -= 1;
}
if(keys[SDLK_d]) {
xDelta += 1;
}
if(keys[SDLK_RSHIFT] || keys[SDLK_LSHIFT]) {
yDelta -= 1;
}
if(keys[SDLK_SPACE]) {
yDelta += 1;
}
Mat44 tmp;
if(xDelta || yDelta || zDelta) {
float xDiff = xDelta*MOVEMENT_SPEED*SECONDS_PER_FRAME,
yDiff = yDelta*MOVEMENT_SPEED*SECONDS_PER_FRAME,
zDiff = zDelta*MOVEMENT_SPEED*SECONDS_PER_FRAME;
mat44Translate(tmp,-xDiff,-yDiff,-zDiff);
mat44Mult(translate,tmp,translate);
}
if(vertRot) {
float vertDiff = vertRot*(mouseCaptured ?
DEGREES_PER_PIXEL :
ROTATION_SPEED*SECONDS_PER_FRAME);
mat44Rotate(tmp,vertDiff,-1,0,0);
mat44Mult(rotateVert,tmp,rotateVert);
}
if(horizRot) {
float horizDiff = horizRot*(mouseCaptured ?
DEGREES_PER_PIXEL :
ROTATION_SPEED*SECONDS_PER_FRAME);
mat44Rotate(tmp,horizDiff,0,1,0);
mat44Mult(translate,tmp,translate);
}
tetraHorizRot += TETRA_HORIZ_ROTATION_SPEED*SECONDS_PER_FRAME;
tetraVertRot += TETRA_VERT_ROTATION_SPEED *SECONDS_PER_FRAME;
mat44Rotate(tetraTransform,tetraHorizRot,0,1,0);
mat44Rotate(tmp,tetraHorizRot,0,1,0);
Vec4 xAxis = { 1,0,0,1 };
mat44MultVec4(xAxis,tmp,xAxis);
mat44Rotate(tmp,tetraVertRot,xAxis[0],xAxis[1],xAxis[2]);
mat44Mult(tetraTransform,tetraTransform,tmp);
ct->viewport.width = ct->_width/numViewports;
unsigned i;
for(i=0;i<numViewports;++i) {
ct->viewport.x = ct->_width-ct->viewport.width*(i+1);
matStackPush(ct->matrices[MATRIX_MODELVIEW]);
if(i == 0) {
matStackMult(ct->matrices[MATRIX_MODELVIEW],rotateVert);
matStackMult(ct->matrices[MATRIX_MODELVIEW],translate);
} else {
mat44Translate(tmp,0,0,-5);
matStackMult(ct->matrices[MATRIX_MODELVIEW],tmp);
}
//drawShapeIndexed(ct,SHAPE_TRIANGLE,4,varr,indices);
matStackPush(ct->matrices[MATRIX_MODELVIEW]);
matStackMult(ct->matrices[MATRIX_MODELVIEW],gridTransform);
drawShapeIndexed(ct,SHAPE_LINE,gridNumEdges,gridArr,gridIndices);
matStackPop(ct->matrices[MATRIX_MODELVIEW]);
matStackPush(ct->matrices[MATRIX_MODELVIEW]);
matStackMult(ct->matrices[MATRIX_MODELVIEW],tetraTransform);
drawShapeIndexed(ct,SHAPE_TRIANGLE,4,varr,indices);
matStackPop(ct->matrices[MATRIX_MODELVIEW]);
matStackPop(ct->matrices[MATRIX_MODELVIEW]);
debugged = 1;
}
SDL_BlitSurface(ct->surface,NULL,screen,NULL);
SDL_Flip(screen);
unsigned elapsedTime = SDL_GetTicks()-startTicks;
/* printf("%d ms/frame\n",elapsedTime); */
unsigned currFps = 1000/elapsedTime;
if(currFps > FRAMES_PER_SECOND) {
currFps = FRAMES_PER_SECOND;
}
fps = fpsLerp*currFps+(1-fpsLerp)*fps;
sprintf(title,"%s %u/%u ms%s",TITLE,elapsedTime,ticksPerFrame,
elapsedTime > ticksPerFrame ? "!!":"");
SDL_WM_SetCaption(title,NULL);
if(elapsedTime < ticksPerFrame) {
SDL_Delay(ticksPerFrame-elapsedTime);
}
}
free(gridVerts);
free(gridIndices);
freeVertArray(gridArr);
freeVertArray(varr);
freeContext(ct);
return 0;
}
HwAccVda::~HwAccVda() {
freeContext();
delete d;
}
