void executeProgram(char* name)
{
char buffer[13312];
int i=0,process,seg;
setKernelDataSegment() ;
readFile(name,buffer);
process=0;
while(process<8)
{
if(p[process].active==0)
{
p[process].active=1;
seg=process+2;
seg=seg * 4096;
currentProcess=process;
break;
}
process++;
}
while(i < 13312)
{
putInMemory(seg,i,buffer[i]);
i++;
}
printString("hi");
initializeProgram(seg);
printString("process initialised");
restoreDataSegment();
}
//------------------------------------------------------------------------------
int main(int argc, char **argv ){
// init GLUT and create Window
glutInit( &argc, argv );
glutInitDisplayMode( GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA );
glutInitWindowSize( 320, 320 );
glutCreateWindow( "Onion World" );
initializeProgram();
initializeVertexBuffer();
initializeVertexArrayObjects();
glEnable( GL_CULL_FACE );
glCullFace( GL_BACK );
glFrontFace( GL_CW );
glEnable( GL_DEPTH_TEST );
glDepthMask( GL_TRUE );
glDepthFunc( GL_LEQUAL );
glDepthRange( 0.0, 1.0f );
// register callbacks
glutDisplayFunc( renderScene );
glutReshapeFunc( reshape );
glutKeyboardFunc( keyPressed );
glutMainLoop();
return EXIT_SUCCESS;
}
void init()
{
initializeProgram();
initializeVertexBuffer();
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
}
void AABBRenderer::initialize() {
m_cubeMesh.reset(new CubeMesh());
initializeProgram();
initializeVAO();
m_initialized = true;
}
int main() {
if (initializeProgram() == 1){
printf("File failed to open.");
}
system("pause");
return 0;
}
int executeProgram(char* name){
char buffer[13312];
int i;
int freeSegment;
int segment;
struct PCB *pcb;
setKernelDataSegment();
freeSegment = getFreeMemorySegment();
restoreDataSegment();
if(freeSegment == -1){
print("No Memory Available\0");
return -2;
}
// if(freeSegment == 0x0000 || freeSegment == 0x1000){
// print("Invalid Segment\0");
// return -1;
// }
interrupt(0x21, 0x03, name, buffer, 0);
if(buffer[0] == 0x00){
print("File not found\0");
return -1;
}
segment = 0x1000*(freeSegment+2);
for(i = 0;i<13312;i++){
putInMemory(segment, i, buffer[i]);
}
setKernelDataSegment();
pcb = getFreePCB();
restoreDataSegment();
if(pcb == NULL){
return -2;
}
kStrCopy(name,(*pcb).name, 6);
setKernelDataSegment();
(*pcb).segment = segment;
(*pcb).stackPointer = 0xFF00;
addToReady(pcb);
restoreDataSegment();
initializeProgram(segment);
return 1;
}
Ball() {
LOGI("init for ball");
fXOffset = 0.0f;
fYOffset = 0.0f;
initializeVertexShader();
initializeFragmentShader();
initializeProgram();
initializeVertexPositions();
initializeVertexBuffer();
positionBufferPointer = glGetAttribLocation(theProgram, "vPosition");
}
void executeProgram(char* name, int toWaitOn){
char buffer[MAXFILESIZE];
int curLoadChar;
int q, found, process, charTemp;
int segment = 0;
found = readFile(name, buffer);
if(found != 1){
return;
}
setKernelDataSegment();
for(q=0; q<NUMBEROFPROCESSENTRIES; q++){
if(processTable[q].active == 0){
segment = findProcessTableSegment(q);
break;
}
}
restoreDataSegment();
process = q;
if(segment == 0){
printString("Too many processes");
return;
}
for(curLoadChar=0; curLoadChar<MAXFILESIZE; curLoadChar++){
putInMemory(segment, curLoadChar, buffer[curLoadChar]);
}
initializeProgram(segment);
for(q=0; q<NAMELENGTH; q++){
charTemp = name[q];
setKernelDataSegment();
processTable[process].name[q] = charTemp;
restoreDataSegment();
}
setKernelDataSegment();
processTable[process].name[q] = '\0';
if(toWaitOn != NOONE){
processTable[toWaitOn].waitingOn = process;
}
processTable[process].active = 1;
processTable[process].stackPointer = INTITALSTACKLOCATION;
restoreDataSegment();
return;
}
int executeProgram(char* name){
int i = 0;
int offset = 0x0000;
char buffer[512];
int sectors;
int segment;
struct PCB *pcb;
setKernelDataSegment();
pcb = getFreePCB();
restoreDataSegment();
setKernelDataSegment();
segment = getFreeMemorySegment()
restoreDataSegment();
if(segment == -1){
return -2;
}
sectors = readfile(name, buffer);
if(sectors == -1){
return -1;
}
for (i; i < sectors*512 ; i++) {
putInMemory(segment,offset,buffer[i]);
offset++;
}
// pcb->name[0] = name[0];
// pcb->name[1] = name[1];
// pcb->name[2] = name[2];
// pcb->name[3] = name[3];
// pcb->name[4] = name[4];
// pcb->name[5] = name[5];
kStrCopy(name, pcb->name, 6);
setKernelDataSegment();
pcb->state = STARTING;
pcb->segment = segment;
pcb->stackPointer = 0xFF00;
restoreDataSegment();
initializeProgram(segment);
return 1;
}
/**
* This is pretty low performance, but it is used only for debugging physics, so it is good enough
*/
void GLHelper::drawLine(const glm::vec3 &from, const glm::vec3 &to,
const glm::vec3 &fromColor, const glm::vec3 &toColor, bool willTransform) {
static GLuint program, viewTransformU, lineInfoU, vao, vbo;
static std::map<std::string, Uniform*> uniformMap;//FIXME That map will always be empty, maybe we should overload
if (program == 0 || vbo == 0 || vao == 0) {
program = initializeProgram("./Data/Shaders/Line/vertex.glsl", "./Data/Shaders/Line/fragment.glsl", uniformMap);
lineInfoU = glGetUniformLocation(program, "lineInfo");
viewTransformU = glGetUniformLocation(program, "cameraTransformMatrix");
state->setProgram(program);
vbo = generateBuffer(1);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
std::vector<GLint> indexes;
indexes.push_back(0);
indexes.push_back(1);
glBufferData(GL_ARRAY_BUFFER, indexes.size() * sizeof(GLint), indexes.data(), GL_STATIC_DRAW);
//this means the vao is not created yet.
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
//stride means the space between start of 2 elements. 0 is special, means the space is equal to size.
glVertexAttribPointer(0, 1, GL_INT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(0);
}
state->setProgram(program);
glm::mat4 matrix(glm::vec4(from, 1.0f),
glm::vec4(to, 1.0f),
glm::vec4(fromColor, 1.0f),
glm::vec4(toColor, 1.0f));
glUniformMatrix4fv(lineInfoU, 1, GL_FALSE, glm::value_ptr(matrix));
if (willTransform) {
glUniformMatrix4fv(viewTransformU, 1, GL_FALSE, glm::value_ptr(getProjectionMatrix() * getCameraMatrix()));
} else {
glUniformMatrix4fv(viewTransformU, 1, GL_FALSE, glm::value_ptr(glm::mat4(1.0)));
}
glBindVertexArray(vao);
glDrawArrays(GL_LINES, 0, 2);
glBindVertexArray(0);
//state->setProgram(0);
checkErrors("drawLine");
}
//------------------------------------------------------------------------------
int main(int argc, char **argv ){
// init GLUT and create Window
glutInit( &argc, argv );
glutInitDisplayMode( GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA );
glutInitWindowSize( 320, 320 );
glutCreateWindow( "Onion World" );
initializeProgram();
initializeVertexBuffer();
// register callbacks
glutDisplayFunc( renderScene );
glutReshapeFunc( reshape );
glutMainLoop();
return EXIT_SUCCESS;
}
RacketBar(bool userBar) {
if(userBar)
LOGI("Racketbar for user init");
else
LOGI("Racketbar for CPU init");
if(userBar){
fYOffset = -0.8f;
} else {
fYOffset = 0.8f;
}
isUserBar = userBar;
initializeVertexShader();
initializeFragmentShader();
initializeProgram();
initializeVertexPositions();
initializeVertexBuffer();
positionBufferPointer = glGetAttribLocation(theProgram, "vPosition");
}
//------------------------------------------------------------------------------
int main(int argc, char **argv ){
// init GLUT and create Window
glutInit( &argc, argv );
glutInitDisplayMode( GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA );
glutInitWindowSize( 320, 320 );
glutCreateWindow( "Example03" );
initializeProgram();
initializeVertexBuffer();
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
glFrontFace(GL_CW);
// register callbacks
glutDisplayFunc( renderScene );
glutReshapeFunc( reshape );
glutMainLoop();
return EXIT_SUCCESS;
}
int runProgram(char* name, int dirID) {
char errorMessage[10];
char number[10];
char newline[3];
char programBuffer[13312];
int i, t, current, curProcUser;
int segment2;
readFile(name, programBuffer, ROOT_SECTOR);
setKernelDataSegment();
for (i = 0; i < PROC_ENTRY_NUM; i++) {
if (procTable[i].active == 0 && procTable[i].waiting == -1) {
procTable[i].sp = 0xFF00;
t = i;
break;
}
}
restoreDataSegment();
/* convertIntToString(number, t); */
/* number[1] = ' '; */
/* number[2] = '\0'; */
/* printString(number); */
segment2 = (t + 2) * 0x1000;
for (i = 0; i <= 13312; i++) {
putInMemory(segment2, i, programBuffer[i]);
}
initializeProgram(segment2);
setKernelDataSegment();
procTable[t].active = 1;
restoreDataSegment();
return t;
}
void Painter::initializeGL(const Shape& shape, const std::string &vert, const std::string &frag)
{
initializeProgram(vert, frag);
initializeVAO(shape);
}
