/*--------------------------------------------------------------------------
** Purpose: Initialise PCI console interface.
**
** Parameters: Name Description.
** eqNo equipment number
** unitNo unit number
** channelNo channel number the device is attached to
** deviceName optional device file name
**
** Returns: Nothing.
**
**------------------------------------------------------------------------*/
void pciConsoleInit(u8 eqNo, u8 unitNo, u8 channelNo, char *deviceName)
{
DevSlot *dp;
(void)unitNo;
(void)deviceName;
#if DEBUG
if (pciLog == NULL)
{
pciLog = fopen("pci_console_log.txt", "wt");
}
#endif
/*
** Attach device to channel and initialise device control block.
*/
dp = channelAttach(channelNo, eqNo, DtPciChannel);
dp->activate = pciActivate;
dp->disconnect = pciDisconnect;
dp->func = pciFunc;
dp->io = pciIo;
dp->flags = pciFlags;
dp->in = pciIn;
dp->out = pciOut;
dp->full = pciFull;
dp->empty = pciEmpty;
/*
** Allocate and initialise channel parameters.
*/
pci = calloc(1, sizeof(PciParam));
if (pci == NULL)
{
fprintf(stderr, "Failed to allocate PCI channel context block\n");
exit(1);
}
pci->fdPci = open(DEVICE_NODE, 0);
if (pci->fdPci < 0)
{
fprintf(stderr, "Can't open %s - error %s\n", DEVICE_NODE, strerror(errno));
exit(1);
}
pciCmd(PciCmdMasterClear);
windowInit();
/*
** Print a friendly message.
*/
printf("PCI channel interface initialised on channel %o unit %o\n", channelNo, unitNo);
}
static void createGUI(lua_State *L)
{
window *w = malloc(sizeof(window));
windowInit(w, "main", 300, 400);
widgetReposition(WIDGET(w), 50, 50);
widgetShow(WIDGET(w));
// GL stuff
widgetEnableGL(WIDGET(w));
WIDGET(w)->vtbl->doDraw = paintWithGL;
widgetAddTimerEventHandler(WIDGET(w), EVT_TIMER_SINGLE_SHOT, 3000,
timer, NULL, NULL);
}
int main(int argc, char *argv[]){
glutInit(&argc, argv); //initialize GL Utility Toolkit(GLUT) and extract command line arguments for GLUT and keep the counts for the remaining arguments
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB );
windowInit(&window);
std::ifstream ifs;
readFile(ifs);
readHeaders(&ifs, &window.width, &window.height, &window.numberOfPolyhedra);//read from datafile for the window-dimension and numberOfPolyhedra there are
glutInitWindowSize(window.width, window.height);
glutInitWindowPosition(100, 100);
// initialize the pixel buffers
PixelBuffer = new float[window.width*window.height*3];
SubWindowPixelBuffer1 = new float[ (window.width* window.height/4) * 3];
SubWindowPixelBuffer2 = new float[ (window.width* window.height/4) * 3];
SubWindowPixelBuffer3 = new float[ (window.width* window.height/4) * 3];
// create sub-windows and their callback functions
int mainWindowID = glutCreateWindow("Project 2");
glutDisplayFunc(callback_display);
int subWindowID1 = glutCreateSubWindow(mainWindowID, 0, 0, window.width/2, window.height/2);
glutDisplayFunc(callback_subdisplay1);
glutKeyboardFunc(callback_keyboard);
createMenu();
int subWindowID2 = glutCreateSubWindow(mainWindowID, window.width/2, 0, window.width/2, window.height/2);
glutDisplayFunc(callback_subdisplay2);
glutKeyboardFunc(callback_keyboard);
createMenu();
int subWindowID3 = glutCreateSubWindow(mainWindowID, 0, window.height/2, window.width/2, window.height/2);
glutDisplayFunc(callback_subdisplay3);
glutKeyboardFunc(callback_keyboard);
createMenu();
Graph graph(window.width,window.height, PixelBuffer);
globalGraphs[0] = &graph;//any function that wants to draw can use this pointer(globalGraph) to graph
graph.fillScreen(1,1,1); // white background
Graph subGraph1(window.width/2, window.height/2, SubWindowPixelBuffer1);
subGraph1.fillScreen(0.9,0.9,0.9);
globalGraphs[1] = &subGraph1;
Graph subGraph2(window.width/2, window.height/2, SubWindowPixelBuffer2);
subGraph2.fillScreen(0.7, 0.7, 0.7);
globalGraphs[2] = &subGraph2;
Graph subGraph3(window.width/2, window.height/2, SubWindowPixelBuffer3);
subGraph3.fillScreen(0.5,0.5,0.5);
globalGraphs[3] = &subGraph3;
Polyhedron *polyhedra[window.numberOfPolyhedra+1];
globalPolyhedra = polyhedra;
DPRINT("Read polyhedra, number of polyhdra:%d\n", window.numberOfPolyhedra);
readPolyhedra(&ifs, globalGraphs, polyhedra, window.numberOfPolyhedra);
//in addition of the polyhedra read from the datafile:
//add a an rotional axis
Edge edge = {0 , 1};
polyhedra[window.numberOfPolyhedra++] = new Polyhedron(globalGraphs, window.tf.pairOfPointsForRotAxis ,2, &edge, 1);
drawPolyhedra(polyhedra); // draw polyhedra(objects) the first time
//callback registration:
glutSetWindow(mainWindowID);
glutKeyboardFunc(callback_keyboard);
createMenu();
glutSetCursor(GLUT_CURSOR_CROSSHAIR);
glutMainLoop();
return 0;
}
int main(int argc, char **argv)
{
#define _KONFIGURACJA
#include "konfiguracja.cpp"
if (argc > 1 && argv[1][0] == '-' && argv[1][1] == 's') // poprawki w konfiguracji na podstawie parametró (te maj¹ pierwszeñstwo)
{
stereoTryb = 2;
oknoSzerkosc=800;
oknoWysokosc=600;
}
glutInit(&argc, argv); // INIT - wszystkie funkcje obs³ugi okna i przetwzrzania zdarzeñ realizuje GLUT
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH);
if (stereoTryb == 2) {
glutInitWindowSize(oknoSzerkosc-8,oknoWysokosc);
glutInitWindowPosition(0,0);
oknoLewe = glutCreateWindow("Lewe"); // ==1
HWND hwnd = FindWindow(NULL, "Lewe");
SetWindowLong(hwnd, GWL_STYLE, WS_BORDER | WS_MAXIMIZE);
glutSetWindow(oknoLewe);
windowInit();
glutReshapeFunc (rozmiarLewe); // def. obs³ugi zdarzenia resize (GLUT)
glutKeyboardFunc (KlawiszKlawiaturyWcisniety); // def. obs³ugi klawiatury
glutSpecialFunc (KlawiszSpecjalnyWcisniety); // def. obs³ugi klawiatury (klawisze specjalne)
glutMouseFunc (PrzyciskMyszyWcisniety); // def. obs³ugi zdarzenia przycisku myszy (GLUT)
glutMotionFunc (RuchKursoraMyszy); // def. obs³ugi zdarzenia ruchu myszy (GLUT)
glutDisplayFunc(rysuj); // def. funkcji rysuj¹cej
glutInitWindowSize(oknoSzerkosc-8,oknoWysokosc);
glutInitWindowPosition(oknoSzerkosc+4,0);
oknoPrawe = glutCreateWindow("Prawe"); // ==2
glutSetWindow(oknoPrawe);
windowInit();
hwnd = FindWindow(NULL, "Prawe");
SetWindowLong(hwnd, GWL_STYLE, WS_BORDER | WS_MAXIMIZE);
glutReshapeFunc (rozmiarPrawe); // def. obs³ugi zdarzenia resize (GLUT)
glutKeyboardFunc (KlawiszKlawiaturyWcisniety); // def. obs³ugi klawiatury
glutSpecialFunc (KlawiszSpecjalnyWcisniety); // def. obs³ugi klawiatury (klawisze specjalne)
glutMouseFunc (PrzyciskMyszyWcisniety); // def. obs³ugi zdarzenia przycisku myszy (GLUT)
glutMotionFunc (RuchKursoraMyszy); // def. obs³ugi zdarzenia ruchu myszy (GLUT)
glutDisplayFunc(rysuj); // def. funkcji rysuj¹cej
} else { // jedno okno
glutInitWindowSize(oknoSzerkosc,oknoWysokosc);
glutInitWindowPosition(0,0);
oknoLewe = glutCreateWindow("Szablon");
windowInit();
glutReshapeFunc (rozmiar); // def. obs³ugi zdarzenia resize (GLUT)
glutKeyboardFunc (KlawiszKlawiaturyWcisniety); // def. obs³ugi klawiatury
glutSpecialFunc (KlawiszSpecjalnyWcisniety); // def. obs³ugi klawiatury (klawisze specjalne)
glutMouseFunc (PrzyciskMyszyWcisniety); // def. obs³ugi zdarzenia przycisku myszy (GLUT)
glutMotionFunc (RuchKursoraMyszy); // def. obs³ugi zdarzenia ruchu myszy (GLUT)
glutDisplayFunc(rysuj); // def. funkcji rysuj¹cej
}
if (stereoTryb == 1 || !timing100FPS)
glutIdleFunc(timer);
else
glutTimerFunc(10,syncTimer,10);
resetKamery();
//srand( (unsigned)time( NULL ) ); // generator liczb losowych
ladujModele();
aktywujSpecjalneRenderowanieModelu("woda",1);
aktywujSpecjalneRenderowanieModelu("most",2);
if (oknoFullScreen && stereoTryb != 2) glutFullScreen();
glutMainLoop();
return(0);
}
HI_VOID *sw_HIFB_REFRESH(void *pData)
{
HI_S32 s32Ret = HI_SUCCESS;
HIFB_LAYER_INFO_S stLayerInfo = {0};
HIFB_BUFFER_S stCanvasBuf;
HI_U16 *pBuf;
HI_U32 x, y;
HI_BOOL Show;
HI_BOOL bCompress = HI_TRUE;
HIFB_POINT_S stPoint = {0};
struct fb_var_screeninfo stVarInfo;
char file[12] = "/dev/fb0";
HI_U32 maxW,maxH;
PTHREAD_HIFB_sw_INFO *pstInfo;
pstInfo = (PTHREAD_HIFB_sw_INFO *)pData;
HIFB_COLORKEY_S stColorKey;
switch (pstInfo->layer)
{
case 0 :
strcpy(file, "/dev/fb0");
break;
case 1 :
strcpy(file, "/dev/fb1");
break;
case 2 :
strcpy(file, "/dev/fb2");
break;
case 3 :
strcpy(file, "/dev/fb3");
break;
case 4 :
strcpy(file, "/dev/fb4");
break;
default:
strcpy(file, "/dev/fb0");
break;
}
pstInfo->fd = open(file, O_RDWR, 0);
if (pstInfo->fd < 0)
{
printf("open %s failed!\n",file);
return HI_NULL;
}
if (pstInfo->layer == HIFB_LAYER_0 )
{
if (ioctl(pstInfo->fd, FBIOPUT_COMPRESSION_HIFB, &bCompress) < 0)
{
printf("FBIOPUT_COMPRESSION_HIFB failed!\n");
close(pstInfo->fd);
return HI_NULL;
}
}
stColorKey.bKeyEnable = HI_TRUE;
stColorKey.u32Key = 0x0;
if (ioctl(pstInfo->fd, FBIOPUT_COLORKEY_HIFB, &stColorKey) < 0)
{
printf("FBIOPUT_COLORKEY_HIFB!\n");
close(pstInfo->fd);
return HI_NULL;
}
s32Ret = ioctl(pstInfo->fd, FBIOGET_VSCREENINFO, &stVarInfo);
if (s32Ret < 0)
{
printf("GET_VSCREENINFO failed!\n");
return HI_NULL;
}
if (ioctl(pstInfo->fd, FBIOPUT_SCREEN_ORIGIN_HIFB, &stPoint) < 0)
{
printf("set screen original show position failed!\n");
return HI_NULL;
}
maxW = 1280;
maxH = 720;
stVarInfo.xres = stVarInfo.xres_virtual = maxW;
stVarInfo.yres = stVarInfo.yres_virtual = maxH;
setRelolution(maxW,maxH);
s32Ret = ioctl(pstInfo->fd, FBIOPUT_VSCREENINFO, &stVarInfo);
if (s32Ret < 0)
{
printf("PUT_VSCREENINFO failed!\n");
return HI_NULL;
}
switch (pstInfo->ctrlkey)
{
case 0 :
{
stLayerInfo.BufMode = HIFB_LAYER_BUF_ONE;
stLayerInfo.u32Mask = HIFB_LAYERMASK_BUFMODE;
break;
}
case 1 :
{
stLayerInfo.BufMode = HIFB_LAYER_BUF_DOUBLE;
stLayerInfo.u32Mask = HIFB_LAYERMASK_BUFMODE;
break;
}
default:
{
stLayerInfo.BufMode = HIFB_LAYER_BUF_NONE;
stLayerInfo.u32Mask = HIFB_LAYERMASK_BUFMODE;
}
}
s32Ret = ioctl(pstInfo->fd, FBIOPUT_LAYER_INFO, &stLayerInfo);
if (s32Ret < 0)
{
printf("PUT_LAYER_INFO failed!\n");
return HI_NULL;
}
Show = HI_TRUE;
if (ioctl(pstInfo->fd, FBIOPUT_SHOW_HIFB, &Show) < 0)
{
printf("FBIOPUT_SHOW_HIFB failed!\n");
return HI_NULL;
}
if (HI_FAILURE == HI_MPI_SYS_MmzAlloc(&(stCanvasBuf.stCanvas.u32PhyAddr), ((void**)&pBuf),
NULL, NULL, maxW*maxH*2))
{
printf("allocate memory (maxW*maxH*2 bytes) failed\n");
return HI_NULL;
}
stCanvasBuf.stCanvas.u32Height = maxH;
stCanvasBuf.stCanvas.u32Width = maxW;
stCanvasBuf.stCanvas.u32Pitch = maxW*2;
stCanvasBuf.stCanvas.enFmt = HIFB_FMT_ARGB1555;
memset(pBuf, 0x00, stCanvasBuf.stCanvas.u32Pitch*stCanvasBuf.stCanvas.u32Height);
gdc.tcClear=0x00;
gdc.pWinFb->hFB=pstInfo->fd;
gdc.pWinFb->pMappedAddr=pBuf;
gdc.pWinFb->pPhyAddr=stCanvasBuf.stCanvas.u32PhyAddr;
gdc.pSzWin.nW=maxW;
gdc.pSzWin.nH=maxH;
windowInit();
CreateMsgQueue(&gdc.nMsgid,20);
while(1)
{
pWINDOW_S pOsd=getOSDWnd();
MSG msg={WIN_FLASH_ALL,0};
SendMsg(gdc.nMsgid,msg);
while(1)
{
RecvMsg(gdc.nMsgid,&msg,TRUE);
switch(msg.message)
{
case WIN_FLASH_ALL:
windowFlush();
stCanvasBuf.UpdateRect.x = 0;
stCanvasBuf.UpdateRect.y = 0;
stCanvasBuf.UpdateRect.w = maxW;
stCanvasBuf.UpdateRect.h = maxH;
s32Ret = ioctl(pstInfo->fd, FBIO_REFRESH, &stCanvasBuf);
if (s32Ret < 0)
{
printf("REFRESH failed!\n");
}
break;
case WIN_WIN_FLASH:
case WIN_FLASH_AREA:
case WIN_CTRL_FLASH:
break;
}
}
}
return HI_NULL;
}
/////////////////////////////////////////////////////////
// createWindow
//
/////////////////////////////////////////////////////////
int GemMan :: createWindow(char* disp)
{
if ( m_windowState ) return(s_singleContext);
debug_post("GemMan: create window");
WindowHints myHints;
myHints.border = m_border;
myHints.buffer = m_buffer;
myHints.width = m_width;
myHints.height = m_height;
myHints.fullscreen = m_fullscreen;
myHints.secondscreen = m_secondscreen;
myHints.x_offset = m_xoffset;
myHints.y_offset = m_yoffset;
myHints.shared = constInfo.context;
myHints.actuallyDisplay = 1;
myHints.display = disp;
myHints.title = const_cast<char*>(GemMan::m_title.c_str());
myHints.fsaa = fsaa;
if (disp) post("GEM: creating gem-window on display %s",disp);
if (!createGemWindow(gfxInfo, myHints) )
{
error("GEM: Unable to create window");
return(0);
}
/*
Check for the presence of a couple of useful OpenGL extensions
we can use to speed up the movie rendering.
GL_EXT_texture_rectangle allows for non-power-of-two sized
textures. Texture coordinates for these textures run from
0..width, 0..height instead of 0..1, 0..1 as for normal
power-of-two textures. GL_EXT_texture_rectangle is available
on the NVidia GeForce2MX and above, or the ATI Radeon and above.
*/
glewInitialized=false;
GLenum err = glewInit();
if (GLEW_OK != err) {
if(GLEW_ERROR_GLX_VERSION_11_ONLY == err) {
error("GEM: failed to init GLEW (glx): continuing anyhow - please report any problems to the gem-dev mailinglist!");
} else if (GLEW_ERROR_GL_VERSION_10_ONLY) {
error("GEM: failed to init GLEW: your system only supports openGL-1.0");
return(0);
} else {
error("GEM: failed to init GLEW");
return(0);
}
}
glewInitialized=true;
logpost(NULL, 4,"GEM: GLEW version %s",glewGetString(GLEW_VERSION));
checkOpenGLExtensions();
/* check the stack-sizes */
glGetIntegerv(GL_MAX_MODELVIEW_STACK_DEPTH, maxStackDepth+STACKMODELVIEW);
if(GLEW_ARB_imaging) {
glGetIntegerv(GL_MAX_COLOR_MATRIX_STACK_DEPTH, maxStackDepth+STACKCOLOR);
}
glGetIntegerv(GL_MAX_TEXTURE_STACK_DEPTH, maxStackDepth+STACKTEXTURE);
glGetIntegerv(GL_MAX_PROJECTION_STACK_DEPTH, maxStackDepth+STACKPROJECTION);
m_w=myHints.real_w;
m_h=myHints.real_h;
m_windowState = 1;
cursorOnOff(m_cursor);
topmostOnOff(m_topmost);
m_windowNumber++;
windowInit();
clock_delay(s_windowClock, s_windowDelTime);
s_windowRun = 1;
return(1);
}
