void vertex_program :: render(GemState *state) { LoadProgram(); /* actually glProgramEnvParameter4fvARB really depends on GL_ARB_vertex_program * and cannot be used with _only_ GL_NV_vertex_program */ if(GLEW_ARB_vertex_program) { if(m_programID&&(m_envNum>=0)) { glProgramEnvParameter4fvARB(m_programTarget, m_envNum, m_param); } } }
extern int KernelExec(char *filename, char **argvec, ExceptionStackFrame *frame) { TracePrintf(256, "Exec: filename(%s), argvec(%s)\n", filename, argvec); int status = LoadProgram(filename, argvec, frame); if (status !=0) { //KernelExit here return ERROR; } else return 0; }
bool ProgramStringIsNative(GLenum target, const char* filename) { // clear any current GL errors so that the following check is valid glClearErrors(); const GLuint tempProg = LoadProgram(target, filename, (target == GL_VERTEX_PROGRAM_ARB? "vertex": "fragment")); if (tempProg == 0) { return false; } glSafeDeleteProgram(tempProg); return true; }
void PezInitialize() { const PezConfig cfg = PezGetConfig(); pezSwAddDirective("*", "#extension GL_ARB_explicit_attrib_location : enable"); strcpy(Globals.Message, "Hello, world."); // Compile shaders Globals.QuadProgram = LoadProgram("Quad.VS", 0, "Quad.FS"); Globals.LitProgram = LoadProgram("Lit.VS", 0, "Lit.FS"); Globals.TextProgram = LoadProgram("Text.VS", "Text.GS", "Text.Smooth.FS"); // Set up viewport float fovy = 16 * TwoPi / 180; float aspect = (float) cfg.Width / cfg.Height; float zNear = 0.1, zFar = 300; Globals.Transforms.Projection = M4MakePerspective(fovy, aspect, zNear, zFar); Globals.Transforms.Ortho = M4MakeOrthographic(0, cfg.Width, cfg.Height, 0, 0, 1); // Create geometry glUseProgram(Globals.QuadProgram); Globals.QuadVao = CreateQuad(cfg.Width, -cfg.Height, cfg.Width, cfg.Height); glUseProgram(Globals.TextProgram); Globals.TextVao = CreateText(Globals.Message); glUseProgram(Globals.LitProgram); Globals.TrefoilKnot = CreateTrefoil(); // Load textures Globals.FontMap = LoadTexture("FontMap.png"); //Globals.FontMap = LoadTexture("Mona-EDT-Small.png"); // Misc Initialization Globals.Theta = 0; glClearColor(0.184, 0.310, 0.310, 1); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); pezCheck(OpenGLError); }
Renderer::Renderer(void) { // VertexPosProgram = LoadProgram("VertexPos.vsh","VertexPos.fsh"); VertexPosColorProgram = LoadProgram("VertexPosColor.vsh","VertexPosColor.fsh"); // VertexPosTexProgram = LoadProgram("VertexPosTex.vsh","VertexPosTex.fsh"); // VertexPosNormalTexProgram = LoadProgram("VertexPosNormalTex.vsh","VertexPosNormalTex.fsh"); // VertexPosColorTexProgram = LoadProgram("VertexPosColorTex.vsh","VertexPosColorTex.fsh"); // VertexPosNormalColorTexProgram = LoadProgram("VertexPosNormalColorTex.vsh","VertexPosNormalColorTex.fsh"); // VertexPosNormalColorDualTexProgram = LoadProgram("VertexPosNormalColorDualTex.vsh","VertexPosNormalColorDualTex.fsh"); // VertexPosDualTexProgram = LoadProgram("VertexPosDualTex.vsh","VertexPosDualTex.fsh"); // VertexPos2DProgram = LoadProgram("VertexPos2D.vsh","VertexPos2D.fsh"); // VertexPos2DColorProgram = LoadProgram("VertexPos2DColor.vsh","VertexPos2DColor.fsh"); // VertexPos2DTexProgram = LoadProgram("VertexPos2DTex.vsh","VertexPos2DTex.fsh"); // VertexPos2DColorTexProgram = LoadProgram("VertexPos2DColorTex.vsh","VertexPos2DColorTex.fsh"); // VertexPos4DProgram = LoadProgram("VertexPos4D.vsh","VertexPos4D.fsh"); }
void init() { initGL(); Program = LoadProgram(file_manager->getAsset("shaders/particle.vert").c_str(), file_manager->getAsset("shaders/particle.frag").c_str()); attrib_pos = glGetAttribLocation(Program, "position"); attrib_sz = glGetAttribLocation(Program, "size"); attrib_lf = glGetAttribLocation(Program, "lifetime"); attrib_quadcorner = glGetAttribLocation(Program, "quadcorner"); attrib_texcoord = glGetAttribLocation(Program, "texcoord"); uniform_matrix = glGetUniformLocation(Program, "ProjectionMatrix"); uniform_viewmatrix = glGetUniformLocation(Program, "ViewMatrix"); uniform_texture = glGetUniformLocation(Program, "texture"); uniform_invproj = glGetUniformLocation(Program, "invproj"); uniform_screen = glGetUniformLocation(Program, "screen"); uniform_normal_and_depths = glGetUniformLocation(Program, "normals_and_depth"); }
RainNode::RainNode(scene::ISceneManager* mgr, ITexture *tex) : GPUParticle(0, mgr, tex) { RenderProgram = LoadProgram(file_manager->getAsset("shaders/rain.vert").c_str(), file_manager->getAsset("shaders/rain.frag").c_str()); loc_screenw = glGetUniformLocation(RenderProgram, "screenw"); loc_screen = glGetUniformLocation(RenderProgram, "screen"); loc_invproj = glGetUniformLocation(RenderProgram, "invproj"); texloc_tex = glGetUniformLocation(RenderProgram, "tex"); texloc_normal_and_depths = glGetUniformLocation(RenderProgram, "normals_and_depth"); const char *varyings[] = { "currentPosition" }; SimulationProgram = LoadTFBProgram(file_manager->getAsset("shaders/rainsim.vert").c_str(), varyings, 1); loc_campos = glGetUniformLocation(SimulationProgram, "campos"); loc_viewm = glGetUniformLocation(SimulationProgram, "viewm"); loc_time = glGetUniformLocation(SimulationProgram, "time"); count = 2500; area = 3500; u32 i; float x, y, z, vertices[7500]; for (i = 0; i < count; i++) { x = ((rand() % area) - area / 2) / 100.0f; y = ((rand() % 2400)) / 100.0f; z = ((rand() % area) - area / 2) / 100.0f; vertices[3 * i] = x; vertices[3 * i + 1] = y; vertices[3 * i + 2] = z; } texture = getTextureGLuint(tex); normal_and_depth = getTextureGLuint(irr_driver->getRTT(RTT_NORMAL_AND_DEPTH)); glGenBuffers(2, tfb_vertex_buffer); glBindBuffer(GL_ARRAY_BUFFER, tfb_vertex_buffer[0]); glBufferData(GL_ARRAY_BUFFER, 3 * count * sizeof(float), vertices, GL_STREAM_DRAW); glBindBuffer(GL_ARRAY_BUFFER, tfb_vertex_buffer[1]); glBufferData(GL_ARRAY_BUFFER, 3 * count * sizeof(float), 0, GL_STREAM_DRAW); box.addInternalPoint(vector3df((float)(-area / 2))); box.addInternalPoint(vector3df((float)(area / 2))); }
bool InitGL() { if (glewInit() != GLEW_OK) { return false; } g_ProjMat = glm::perspective(45.0f, (float)RES_W / (float)RES_H, 0.01f, 100.0f); g_ViewMat = glm::lookAt( glm::vec3(10.0f, 10.0f, 10.0f), glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(0.0f, 1.0f, 0.0f)); g_uLightProg = LoadProgram("data/shaders/light.vert", "data/shaders/light.frag"); if (!g_uLightProg) { return false; } return true; }
bool CNetwork::LoadScript(char *filename) { size_t memsize = aux_ProgramSize(filename); if(memsize == 0) { printf("Script file not found or corrupted\n"); return false; } memset((void*)&inimod_amx, 0, sizeof(AMX)); void * program = malloc(memsize); if (program == NULL) { printf("Memory allocation for script failed\n"); return false; } if(!LoadProgram(filename,program)) { printf("Loading script into Abstract Machine failed\n"); return false; } amx_CoreInit(&inimod_amx); amx_FloatInit(&inimod_amx); amx_StringInit(&inimod_amx); //amx_FileInit(&inimod_amx); amx_TimeInit(&inimod_amx); return true; }
GLShader(char const *vertFilePath, char const *fragFilePath) { m_gProgram = LoadProgram(vertFilePath, fragFilePath); }
ret_ CXMLLoaderActions::LoadIf(CProgram &Program, const DOMElement *pElement, const CPDUInfo *pPDU) { #ifdef _DEBUG_ if (!pElement) return (PARAMETER_NULL | PARAMETER_3); #endif DOMElement *pSub = (DOMElement *)pElement->getFirstChild(); if (!pSub) return XML_LOADER_ERROR; auto_xerces_str wsDataBlock ("data_block"); auto_xerces_str wsExpressionUnitary ("expression_unitary"); auto_xerces_str wsExpressionDuality ("expression_duality"); auto_xerces_str wsConditionUnitary ("condition_unitary"); auto_xerces_str wsConditionDuality ("condition_duality"); auto_xerces_str wsProgram ("program"); CProgramIf *pPI = new CProgramIf(); pPI->Data().SetParent(&Program.Data()); while (pSub) { if (0 == XMLString::compareString(pSub->getNodeName(), wsDataBlock)) { CData Data; if (SUCCESS != (LoadDataBlock(Data, pSub))) return XML_LOADER_ERROR; pPI->SetData(Data); } else if (0 == XMLString::compareString(pSub->getNodeName(), wsExpressionUnitary) || 0 == XMLString::compareString(pSub->getNodeName(), wsExpressionDuality) || 0 == XMLString::compareString(pSub->getNodeName(), wsConditionUnitary) || 0 == XMLString::compareString(pSub->getNodeName(), wsConditionDuality)) { CExpression *pExpression = null_v; if (SUCCESS != LoadExpression(pPI->Data(), pSub, pExpression, pPDU)) { return XML_LOADER_ERROR; } if (false_v == pPI->AddExpression(pExpression)) return XML_LOADER_ERROR; } else if (0 == XMLString::compareString(pSub->getNodeName(), wsProgram)) { CProgram *pProgram = new CProgram(); if (SUCCESS != LoadProgram(&pPI->Data(), *pProgram, pSub, pPDU)) { return XML_LOADER_ERROR; } if (false_v == pPI->AddOperator(pProgram)) return XML_LOADER_ERROR; } pSub = (DOMElement *)pSub->getNextSibling(); } if (false_v == Program.AddOperator(pPI)) return XML_LOADER_ERROR; return SUCCESS; }
ret_ CXMLLoaderActions::Load(XercesDOMParser *pParser, const ch_1 *pszEnvironmentPath) { #ifdef _DEBUG_ if (!pParser) return PARAMETER_NULL | PARAMETER_1; if (!pszEnvironmentPath) return PARAMETER_NULL | PARAMETER_2; if (null_v == pszEnvironmentPath[0]) return PARAMETER_EMPTY | PARAMETER_2; #endif SetParser(pParser); ch_1 sActions[ENVIRONMENT_PATH_LENGTH]; memset(sActions, 0, ENVIRONMENT_PATH_LENGTH); sprintf(sActions, "%s%s", pszEnvironmentPath, ACTIONS_XML_FILE); DOMDocument *pActionsDoc = null_v; try { GetParser()->parse(sActions); pActionsDoc = GetParser()->getDocument(); } catch (const OutOfMemoryException &err) { auto_xerces_str sErr(err.getMessage()); printf("%s\n", (const ch_1 *)sErr); return XML_LOADER_ERROR; } catch (const XMLException &err) { auto_xerces_str sErr(err.getMessage()); printf("%s\n", (const ch_1 *)sErr); return XML_LOADER_ERROR; } catch (const DOMException &err) { auto_xerces_str sErr(err.msg); printf("%s\n", (const ch_1 *)sErr); return XML_LOADER_ERROR; } catch (...) { printf("Unexpected error during parsing.\n"); return XML_LOADER_ERROR; } if (!pActionsDoc) return XML_LOADER_ERROR; DOMElement *pRoot = pActionsDoc->getDocumentElement(); if (!pRoot) return XML_LOADER_ERROR; DOMElement *pChild = (DOMElement *)pRoot->getFirstChild(); if (!pChild) return XML_LOADER_ERROR; auto_xerces_str wsDataBlock("data_block"); auto_xerces_str wsStart("start"); auto_xerces_str wsProcessor("processor"); auto_xerces_str wsEnd("end"); while (pChild) { if (0 == XMLString::compareString(pChild->getNodeName(), wsDataBlock)) { if (SUCCESS != LoadDataBlock(CUIManager::Instance()->Data(), pChild)) { return XML_LOADER_ERROR; } } else if (0 == XMLString::compareString(pChild->getNodeName(), wsStart)) { if (SUCCESS != LoadProgram(&CUIManager::Instance()->Data(), CUIManager::Instance()->StartProgram(), pChild)) { return XML_LOADER_ERROR; } } else if (0 == XMLString::compareString(pChild->getNodeName(), wsProcessor)) { if (SUCCESS != LoadProcessor(pChild)) return XML_LOADER_ERROR; m_pTmpContainer = null_v; } else if (0 == XMLString::compareString(pChild->getNodeName(), wsEnd)) { if (SUCCESS != LoadProgram(&CUIManager::Instance()->Data(), CUIManager::Instance()->EndProgram(), pChild)) { return XML_LOADER_ERROR; } } pChild = (DOMElement *)pChild->getNextSibling(); } return SUCCESS; }
ret_ CXMLLoaderActions::LoadProcessBlock(CProgram &Program, const DOMElement *pElement, const CPDUInfo *pPDU) { #ifdef _DEBUG_ if (!pElement) return (PARAMETER_NULL | PARAMETER_2); #endif DOMElement *pChild = (DOMElement *)pElement->getFirstChild(); if (!pChild) return XML_LOADER_ERROR; auto_xerces_str wsEmpty ("empty"); auto_xerces_str wsUnitaryCalculate ("unitary_calculate"); auto_xerces_str wsDualityCalculate ("duality_calculate"); auto_xerces_str wsConfigGroup ("config_group"); auto_xerces_str wsIf ("if"); auto_xerces_str wsWhile ("while"); auto_xerces_str wsContinue ("continue"); auto_xerces_str wsBlock ("block"); auto_xerces_str wsBreak ("break"); auto_xerces_str wsSend ("send"); auto_xerces_str wsReadFile ("read_file"); auto_xerces_str wsSaveFile ("save_file"); auto_xerces_str wsDeleteFile ("delete_file"); auto_xerces_str wsSplit ("split"); auto_xerces_str wsDie ("die"); auto_xerces_str wsShowWindow ("show_window"); auto_xerces_str wsWaitMessage ("wait_message"); auto_xerces_str wsAlert ("alert"); auto_xerces_str wsEnable ("enable"); auto_xerces_str wsAddItem ("add_item"); auto_xerces_str wsProgram ("program"); while (pChild) { if (0 == XMLString::compareString(pChild->getNodeName(), wsEmpty)) { if (SUCCESS != LoadEmpty(Program, pChild, pPDU)) return XML_LOADER_ERROR; } else if (0 == XMLString::compareString(pChild->getNodeName(), wsUnitaryCalculate)) { if (SUCCESS != LoadUnitaryCalculate(Program, pChild, pPDU)) return XML_LOADER_ERROR; } else if (0 == XMLString::compareString(pChild->getNodeName(), wsDualityCalculate)) { if (SUCCESS != LoadDualityCalculate(Program, pChild, pPDU)) return XML_LOADER_ERROR; } else if (0 == XMLString::compareString(pChild->getNodeName(), wsConfigGroup)) { if (SUCCESS != LoadConfigGroup(Program, pChild, pPDU)) return XML_LOADER_ERROR; } else if (0 == XMLString::compareString(pChild->getNodeName(), wsIf)) { if (SUCCESS != LoadIf(Program, pChild, pPDU)) return XML_LOADER_ERROR; } else if (0 == XMLString::compareString(pChild->getNodeName(), wsWhile)) { if (SUCCESS != LoadWhile(Program, pChild, pPDU)) return XML_LOADER_ERROR; } else if (0 == XMLString::compareString(pChild->getNodeName(), wsContinue)) { if (SUCCESS != LoadContinue(Program)) return XML_LOADER_ERROR; } else if (0 == XMLString::compareString(pChild->getNodeName(), wsBlock)) { if (SUCCESS != LoadBlock(Program)) return XML_LOADER_ERROR; } else if (0 == XMLString::compareString(pChild->getNodeName(), wsBreak)) { if (SUCCESS != LoadBreak(Program)) return XML_LOADER_ERROR; } else if (0 == XMLString::compareString(pChild->getNodeName(), wsSend)) { if (SUCCESS != LoadSend(Program, pChild, pPDU)) return XML_LOADER_ERROR; } else if (0 == XMLString::compareString(pChild->getNodeName(), wsReadFile)) { if (SUCCESS != LoadReadFile(Program, pChild, pPDU)) return XML_LOADER_ERROR; } else if (0 == XMLString::compareString(pChild->getNodeName(), wsSaveFile)) { if (SUCCESS != LoadSaveFile(Program, pChild, pPDU)) return XML_LOADER_ERROR; } else if (0 == XMLString::compareString(pChild->getNodeName(), wsDeleteFile)) { if (SUCCESS != LoadDeleteFile(Program, pChild, pPDU)) return XML_LOADER_ERROR; } else if (0 == XMLString::compareString(pChild->getNodeName(), wsSplit)) { if (SUCCESS != LoadSplit(Program, pChild, pPDU)) return XML_LOADER_ERROR; } else if (0 == XMLString::compareString(pChild->getNodeName(), wsDie)) { if (SUCCESS != LoadDie(Program)) return XML_LOADER_ERROR; } else if (0 == XMLString::compareString(pChild->getNodeName(), wsShowWindow)) { if (SUCCESS != LoadShowWindow(Program, pChild)) return XML_LOADER_ERROR; } else if (0 == XMLString::compareString(pChild->getNodeName(), wsWaitMessage)) { if (SUCCESS != LoadWaitMessage(Program, pChild)) return XML_LOADER_ERROR; } else if (0 == XMLString::compareString(pChild->getNodeName(), wsAlert)) { if (SUCCESS != LoadAlert(Program, pChild)) return XML_LOADER_ERROR; } else if (0 == XMLString::compareString(pChild->getNodeName(), wsEnable)) { if (SUCCESS != LoadEnable(Program, pChild)) return XML_LOADER_ERROR; } else if (0 == XMLString::compareString(pChild->getNodeName(), wsAddItem)) { if (SUCCESS != LoadAddItem(Program, pChild, pPDU)) return XML_LOADER_ERROR; } else if (0 == XMLString::compareString(pChild->getNodeName(), wsProgram)) { CProgram *pSubProgram = new CProgram(); if (SUCCESS != LoadProgram(&Program.Data(), *pSubProgram, pChild, pPDU)) { return XML_LOADER_ERROR; } if (false_v == Program.AddOperator(pSubProgram)) return XML_LOADER_ERROR; } pChild = (DOMElement *)pChild->getNextSibling(); } return SUCCESS; }
ret_ CXMLLoaderActions::LoadProcessor(const DOMElement *pElement) { #ifdef _DEBUG_ if (!pElement) return PARAMETER_NULL | PARAMETER_2; #endif // auto_xerces_str wsName("name"); auto_xerces_str wsPDU("pdu"); auto_xerces_str sName(pElement->getAttribute(wsName)); auto_xerces_str wsDataBlock("data_block"); auto_xerces_str wsStart("start"); auto_xerces_str wsOnClick("on_click"); auto_xerces_str wsOnMessage("on_message"); auto_xerces_str wsEnd("end"); m_pTmpContainer = CUIManager::Instance()->GetContainer(sName); // Check if there is corresponding container, it should be exist if (!m_pTmpContainer) return XML_LOADER_ERROR; CProtocolInfo *pProtocol = CProtocolManager::Instance()->GetProtocol(); // Protocol should be loaded if (!pProtocol) return XML_LOADER_ERROR; // DOMElement *pChild = (DOMElement *)pElement->getFirstChild(); if (!pChild) return XML_LOADER_ERROR; while (pChild) { if (0 == XMLString::compareString(pChild->getNodeName(), wsDataBlock)) { if (SUCCESS != LoadDataBlock(m_pTmpContainer->Data(), pChild)) return XML_LOADER_ERROR; m_pTmpContainer->Data().SetParent(&CUIManager::Instance()->Data()); } else if (0 == XMLString::compareString(pChild->getNodeName(), wsStart)) { if (SUCCESS != LoadProgram(&m_pTmpContainer->Data(), m_pTmpContainer->StartProgram(), pChild)) { return XML_LOADER_ERROR; } } else if (0 == XMLString::compareString(pChild->getNodeName(), wsOnClick)) { auto_xerces_str sName(pChild->getAttribute(wsName)); CProgram *pProgram = null_v; if (!m_pTmpContainer->AddOnClickProcessor(sName, pProgram)) return XML_LOADER_ERROR; if (SUCCESS != LoadProgram(&m_pTmpContainer->Data(), *pProgram, pChild)) { return XML_LOADER_ERROR; } } else if (0 == XMLString::compareString(pChild->getNodeName(), wsOnMessage)) { auto_xerces_str sPDU(pChild->getAttribute(wsPDU)); CPDUInfo *pPDUInfo = null_v; if (SUCCESS != pProtocol->GetPDU(sPDU, pPDUInfo)) return XML_LOADER_ERROR; CProgram *pProgram = null_v; if (!m_pTmpContainer->AddMessageProcessor(sPDU, pProgram)) return XML_LOADER_ERROR; if (SUCCESS != LoadProgram(&m_pTmpContainer->Data(), *pProgram, pChild, pPDUInfo)) { return XML_LOADER_ERROR; } } else if (0 == XMLString::compareString(pChild->getNodeName(), wsEnd)) { if (SUCCESS != LoadProgram(&m_pTmpContainer->Data(), m_pTmpContainer->EndProgram(), pChild)) { return XML_LOADER_ERROR; } } pChild = (DOMElement *)pChild->getNextSibling(); } return SUCCESS; }
void GLGSRender::ExecCMD() { if(!LoadProgram()) { ConLog.Error("LoadProgram failed."); Emu.Pause(); return; } if(!m_fbo.IsCreated() || m_width != last_width || m_height != last_height || last_depth_format != m_surface_depth_format) { ConLog.Warning("New FBO (%dx%d)", m_width, m_height); last_width = m_width; last_height = m_height; last_depth_format = m_surface_depth_format; m_fbo.Create(); checkForGlError("m_fbo.Create"); m_fbo.Bind(); m_rbo.Create(4 + 1); checkForGlError("m_rbo.Create"); for(int i=0; i<4; ++i) { m_rbo.Bind(i); m_rbo.Storage(GL_RGBA, m_width, m_height); checkForGlError("m_rbo.Storage(GL_RGBA)"); } m_rbo.Bind(4); switch(m_surface_depth_format) { case 1: m_rbo.Storage(GL_DEPTH_COMPONENT16, m_width, m_height); checkForGlError("m_rbo.Storage(GL_DEPTH_COMPONENT16)"); break; case 2: m_rbo.Storage(GL_DEPTH24_STENCIL8, m_width, m_height); checkForGlError("m_rbo.Storage(GL_DEPTH24_STENCIL8)"); break; default: ConLog.Error("Bad depth format! (%d)", m_surface_depth_format); assert(0); break; } for(int i=0; i<4; ++i) { m_fbo.Renderbuffer(GL_COLOR_ATTACHMENT0 + i, m_rbo.GetId(i)); checkForGlError(wxString::Format("m_fbo.Renderbuffer(GL_COLOR_ATTACHMENT%d)", i)); } m_fbo.Renderbuffer(GL_DEPTH_ATTACHMENT, m_rbo.GetId(4)); checkForGlError("m_fbo.Renderbuffer(GL_DEPTH_ATTACHMENT)"); if(m_surface_depth_format == 2) { m_fbo.Renderbuffer(GL_STENCIL_ATTACHMENT, m_rbo.GetId(4)); checkForGlError("m_fbo.Renderbuffer(GL_STENCIL_ATTACHMENT)"); } } if(!m_set_surface_clip_horizontal) { m_surface_clip_x = 0; m_surface_clip_w = m_width; } if(!m_set_surface_clip_vertical) { m_surface_clip_y = 0; m_surface_clip_h = m_height; } m_fbo.Bind(); if(Ini.GSDumpDepthBuffer.GetValue()) WriteDepthBuffer(); static const GLenum draw_buffers[] = { GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1, GL_COLOR_ATTACHMENT2, GL_COLOR_ATTACHMENT3 }; switch(m_surface_colour_target) { case 0x0: break; case 0x1: glDrawBuffer(draw_buffers[0]); break; case 0x2: glDrawBuffer(draw_buffers[1]); break; case 0x13: glDrawBuffers(2, draw_buffers); break; case 0x17: glDrawBuffers(3, draw_buffers); break; case 0x1f: glDrawBuffers(4, draw_buffers); break; default: ConLog.Error("Bad surface colour target: %d", m_surface_colour_target); break; } if(m_set_color_mask) { glColorMask(m_color_mask_r, m_color_mask_g, m_color_mask_b, m_color_mask_a); checkForGlError("glColorMask"); } if(m_set_viewport_horizontal && m_set_viewport_vertical) { glViewport(m_viewport_x, m_height-m_viewport_y-m_viewport_h, m_viewport_w, m_viewport_h); checkForGlError("glViewport"); } if(m_set_scissor_horizontal && m_set_scissor_vertical) { glScissor(m_scissor_x, m_height-m_scissor_y-m_scissor_h, m_scissor_w, m_scissor_h); checkForGlError("glScissor"); } if(m_clear_surface_mask) { GLbitfield f = 0; if (m_clear_surface_mask & 0x1) { glClearDepth(m_clear_surface_z / (float)0xffffff); f |= GL_DEPTH_BUFFER_BIT; } if (m_clear_surface_mask & 0x2) { glClearStencil(m_clear_surface_s); f |= GL_STENCIL_BUFFER_BIT; } if (m_clear_surface_mask & 0xF0) { glClearColor( m_clear_surface_color_r / 255.0f, m_clear_surface_color_g / 255.0f, m_clear_surface_color_b / 255.0f, m_clear_surface_color_a / 255.0f); f |= GL_COLOR_BUFFER_BIT; } glClear(f); } if(m_set_front_polygon_mode) { glPolygonMode(GL_FRONT, m_front_polygon_mode); checkForGlError("glPolygonMode"); } Enable(m_depth_test_enable, GL_DEPTH_TEST); Enable(m_set_alpha_test, GL_ALPHA_TEST); Enable(m_set_depth_bounds_test, GL_DEPTH_CLAMP); Enable(m_set_blend, GL_BLEND); Enable(m_set_logic_op, GL_LOGIC_OP); Enable(m_set_cull_face_enable, GL_CULL_FACE); Enable(m_set_dither, GL_DITHER); Enable(m_set_stencil_test, GL_STENCIL_TEST); Enable(m_set_line_smooth, GL_LINE_SMOOTH); Enable(m_set_poly_smooth, GL_POLYGON_SMOOTH); if(m_set_clip_plane) { Enable(m_clip_plane_0, GL_CLIP_PLANE0); Enable(m_clip_plane_1, GL_CLIP_PLANE1); Enable(m_clip_plane_2, GL_CLIP_PLANE2); Enable(m_clip_plane_3, GL_CLIP_PLANE3); Enable(m_clip_plane_4, GL_CLIP_PLANE4); Enable(m_clip_plane_5, GL_CLIP_PLANE5); checkForGlError("m_set_clip_plane"); } checkForGlError("glEnable"); if(m_set_two_sided_stencil_test_enable) { if(m_set_stencil_fail && m_set_stencil_zfail && m_set_stencil_zpass) { glStencilOpSeparate(GL_FRONT, m_stencil_fail, m_stencil_zfail, m_stencil_zpass); checkForGlError("glStencilOpSeparate"); } if(m_set_stencil_mask) { glStencilMaskSeparate(GL_FRONT, m_stencil_mask); checkForGlError("glStencilMaskSeparate"); } if(m_set_stencil_func && m_set_stencil_func_ref && m_set_stencil_func_mask) { glStencilFuncSeparate(GL_FRONT, m_stencil_func, m_stencil_func_ref, m_stencil_func_mask); checkForGlError("glStencilFuncSeparate"); } if(m_set_back_stencil_fail && m_set_back_stencil_zfail && m_set_back_stencil_zpass) { glStencilOpSeparate(GL_BACK, m_back_stencil_fail, m_back_stencil_zfail, m_back_stencil_zpass); checkForGlError("glStencilOpSeparate(GL_BACK)"); } if(m_set_back_stencil_mask) { glStencilMaskSeparate(GL_BACK, m_back_stencil_mask); checkForGlError("glStencilMaskSeparate(GL_BACK)"); } if(m_set_back_stencil_func && m_set_back_stencil_func_ref && m_set_back_stencil_func_mask) { glStencilFuncSeparate(GL_BACK, m_back_stencil_func, m_back_stencil_func_ref, m_back_stencil_func_mask); checkForGlError("glStencilFuncSeparate(GL_BACK)"); } } else { if(m_set_stencil_fail && m_set_stencil_zfail && m_set_stencil_zpass) { glStencilOp(m_stencil_fail, m_stencil_zfail, m_stencil_zpass); checkForGlError("glStencilOp"); } if(m_set_stencil_mask) { glStencilMask(m_stencil_mask); checkForGlError("glStencilMask"); } if(m_set_stencil_func && m_set_stencil_func_ref && m_set_stencil_func_mask) { glStencilFunc(m_stencil_func, m_stencil_func_ref, m_stencil_func_mask); checkForGlError("glStencilFunc"); } } if(m_set_shade_mode) { glShadeModel(m_shade_mode); checkForGlError("glShadeModel"); } if(m_set_depth_mask) { glDepthMask(m_depth_mask); checkForGlError("glDepthMask"); } if(m_set_depth_func) { glDepthFunc(m_depth_func); checkForGlError("glDepthFunc"); } if(m_set_clip) { glDepthRangef(m_clip_min, m_clip_max); checkForGlError("glDepthRangef"); } if(m_set_line_width) { glLineWidth(m_line_width / 255.f); checkForGlError("glLineWidth"); } if(m_set_blend_equation) { glBlendEquationSeparate(m_blend_equation_rgb, m_blend_equation_alpha); checkForGlError("glBlendEquationSeparate"); } if(m_set_blend_sfactor && m_set_blend_dfactor) { glBlendFuncSeparate(m_blend_sfactor_rgb, m_blend_dfactor_rgb, m_blend_sfactor_alpha, m_blend_dfactor_alpha); checkForGlError("glBlendFuncSeparate"); } if(m_set_blend_color) { glBlendColor(m_blend_color_r, m_blend_color_g, m_blend_color_b, m_blend_color_a); checkForGlError("glBlendColor"); } if(m_set_cull_face) { glCullFace(m_cull_face); checkForGlError("glCullFace"); } if(m_set_alpha_func && m_set_alpha_ref) { glAlphaFunc(m_alpha_func, m_alpha_ref); checkForGlError("glAlphaFunc"); } if(m_set_fog_mode) { glFogi(GL_FOG_MODE, m_fog_mode); checkForGlError("glFogi(GL_FOG_MODE)"); } if(m_set_fog_params) { glFogf(GL_FOG_START, m_fog_param0); checkForGlError("glFogf(GL_FOG_START)"); glFogf(GL_FOG_END, m_fog_param1); checkForGlError("glFogf(GL_FOG_END)"); } if(m_indexed_array.m_count && m_draw_array_count) { ConLog.Warning("m_indexed_array.m_count && draw_array_count"); } for(u32 i=0; i<m_textures_count; ++i) { if(!m_textures[i].IsEnabled()) continue; glActiveTexture(GL_TEXTURE0 + i); checkForGlError("glActiveTexture"); m_gl_textures[i].Create(); m_gl_textures[i].Bind(); checkForGlError(wxString::Format("m_gl_textures[%d].Bind", i)); m_program.SetTex(i); m_gl_textures[i].Init(m_textures[i]); checkForGlError(wxString::Format("m_gl_textures[%d].Init", i)); } m_vao.Bind(); if(m_indexed_array.m_count) { LoadVertexData(m_indexed_array.index_min, m_indexed_array.index_max - m_indexed_array.index_min + 1); } EnableVertexData(m_indexed_array.m_count ? true : false); InitVertexData(); InitFragmentData(); if(m_indexed_array.m_count) { switch(m_indexed_array.m_type) { case 0: glDrawElements(m_draw_mode - 1, m_indexed_array.m_count, GL_UNSIGNED_INT, nullptr); checkForGlError("glDrawElements #4"); break; case 1: glDrawElements(m_draw_mode - 1, m_indexed_array.m_count, GL_UNSIGNED_SHORT, nullptr); checkForGlError("glDrawElements #2"); break; default: ConLog.Error("Bad indexed array type (%d)", m_indexed_array.m_type); break; } DisableVertexData(); m_indexed_array.Reset(); } if(m_draw_array_count) { glDrawArrays(m_draw_mode - 1, 0, m_draw_array_count); checkForGlError("glDrawArrays"); DisableVertexData(); m_draw_array_count = 0; } if(Ini.GSDumpColorBuffers.GetValue()) WriteBuffers(); }
int main(int argc, char const *argv[]) { Display *display; Window window; int screen; display = XOpenDisplay(0); if (display == 0) { fprintf(stderr, "Cannot open display\n"); return 1; } screen = DefaultScreen(display); u32 border_color = WhitePixel(display, screen); u32 bg_color = BlackPixel(display, screen); window = XCreateSimpleWindow(display, RootWindow(display, screen), 300, 300, kWindowWidth * SCREEN_ZOOM, kWindowHeight * SCREEN_ZOOM, 0, border_color, bg_color); XSetStandardProperties(display, window, "6502 virtual machine", "Hi!", None, NULL, 0, NULL); XSelectInput(display, window, ExposureMask | KeyPressMask | KeyReleaseMask | ButtonPressMask | StructureNotifyMask); XMapRaised(display, window); Atom wmDeleteMessage = XInternAtom(display, "WM_DELETE_WINDOW", False); XSetWMProtocols(display, window, &wmDeleteMessage, 1); GC gc; XGCValues gcvalues; // Create x image { for (;;) { XEvent e; XNextEvent(display, &e); if (e.type == MapNotify) break; } gXImage = XGetImage(display, window, 0, 0, kWindowWidth * SCREEN_ZOOM, kWindowHeight * SCREEN_ZOOM, AllPlanes, ZPixmap); gLinuxBitmapMemory = (void *)gXImage->data; gc = XCreateGC(display, window, 0, &gcvalues); } // Init VM memory gMachineMemory = malloc(kMachineMemorySize); gVideoMemory = (u8 *)gMachineMemory + 0x0200; // Load the program at $D400 LoadProgram("test/pong.s", 0xD400); gRunning = true; // Run the machine pthread_t thread_id; if (pthread_create(&thread_id, 0, &machine_thread, 0) != 0) { fprintf(stderr, "Cannot create thread\n"); return 1; } while (gRunning) { // Process events while (XPending(display)) { XEvent event; XNextEvent(display, &event); // Close window message if (event.type == ClientMessage) { if (event.xclient.data.l[0] == wmDeleteMessage) { gRunning = false; } } } // Copy data from the machine's video memory to our "display" // and stretch pixels for (int y = 0; y < kWindowHeight; y++) { for (int x = 0; x < kWindowWidth; x++) { u8 *src_pixel = gVideoMemory + kWindowWidth * y + x; u32 *dest_pixel = (u32 *)gLinuxBitmapMemory + (kWindowWidth * SCREEN_ZOOM * y + x) * SCREEN_ZOOM; u32 color = GetColor(*src_pixel); for (int py = 0; py < SCREEN_ZOOM; py++) { for (int px = 0; px < SCREEN_ZOOM; px++) { *(dest_pixel + py * kWindowWidth * SCREEN_ZOOM + px) = color; } } } } XPutImage(display, window, gc, gXImage, 0, 0, 0, 0, kWindowWidth * SCREEN_ZOOM, kWindowHeight * SCREEN_ZOOM); } XCloseDisplay(display); return 0; }
void InitializeProgram() { // load and compile shaders, link the program and return it PhongShade = LoadProgram("PCN.vert", "PhongLighting.frag"); }
unsigned int LoadFragmentProgram(const char* filename) { return LoadProgram(GL_FRAGMENT_PROGRAM_ARB, filename, "fragment"); }
unsigned int LoadVertexProgram(const char* filename) { return LoadProgram(GL_VERTEX_PROGRAM_ARB, filename, "vertex"); }
void InitializeProgram() { g_WhiteDiffuseColor = LoadProgram("DirVertexLighting_PN.vert", "ColorPassthrough.frag"); g_VertexDiffuseColor = LoadProgram("DirVertexLighting_PCN.vert", "ColorPassthrough.frag"); }
/* * start of code */ void graphics_init() { const char *vShaderStr = "attribute vec4 a_position; \n" "uniform mat4 u_ViewMatrix; // A constant representing the combined model/view matrix. \n" "attribute vec2 a_texCoord; \n" "varying vec2 v_texCoord; \n" "void main() \n" "{ \n" " gl_Position = u_ViewMatrix * a_position; \n" " v_texCoord = a_texCoord; \n" "} \n"; #if 0 const char *vShaderStr = "attribute vec4 a_position; \n" "uniform mat4 u_ViewMatrix; // A constant representing the combined model/view matrix. \n" "attribute vec2 a_texCoord; \n" "varying vec2 v_texCoord; \n" "void main() \n" "{ \n" " gl_Position = u_ViewMatrix * a_position; \n" " v_texCoord = a_texCoord; \n" "} \n"; #endif const char *fShaderStr = "precision mediump float; \n" "varying vec2 v_texCoord; \n" "uniform sampler2D s_texture; \n" "void main() \n" "{ \n" " gl_FragColor = texture2D( s_texture, v_texCoord );\n" " // gl_FragColor = vec4( 1.0, 0.0, 0.0, 1.0 );\n" "} \n"; int i; init_ogl(); assert( glGetError() == GL_NO_ERROR ); // Set background color and clear buffers glClearColor(0.15f, 0.25f, 0.35f, 1.0f); // Load the shaders and get a linked program object programObject = LoadProgram( vShaderStr, fShaderStr ); assert( glGetError() == GL_NO_ERROR ); // Get the attribute locations positionLoc = glGetAttribLocation ( programObject, "a_position" ); texCoordLoc = glGetAttribLocation ( programObject, "a_texCoord" ); assert( glGetError() == GL_NO_ERROR ); viewMatrixLoc = glGetUniformLocation( programObject, "u_ViewMatrix" ); // Get the sampler location samplerLoc = glGetUniformLocation ( programObject, "s_texture" ); // glGenBuffers( 1, &vertexBufferID ); glGenBuffers( 1, &indexBufferID ); assert( glGetError() == GL_NO_ERROR ); for( i = 0; i < MAX_TILES; i++ ) tiles[i].vertexBufferID = -1; // Enable back face culling. // glEnable(GL_CULL_FACE); }
void GLGSRender::ExecCMD() { //return; if(!LoadProgram()) { ConLog.Error("LoadProgram failed."); Emu.Pause(); return; } if(!m_fbo.IsCreated() || RSXThread::m_width != last_width || RSXThread::m_height != last_height || last_depth_format != m_surface_depth_format) { ConLog.Warning("New FBO (%dx%d)", RSXThread::m_width, RSXThread::m_height); last_width = RSXThread::m_width; last_height = RSXThread::m_height; last_depth_format = m_surface_depth_format; m_fbo.Create(); checkForGlError("m_fbo.Create"); m_fbo.Bind(); m_rbo.Create(4 + 1); checkForGlError("m_rbo.Create"); for(int i=0; i<4; ++i) { m_rbo.Bind(i); m_rbo.Storage(GL_RGBA, RSXThread::m_width, RSXThread::m_height); checkForGlError("m_rbo.Storage(GL_RGBA)"); } m_rbo.Bind(4); switch(m_surface_depth_format) { // case 0 found in BLJM60410-[Suzukaze no Melt - Days in the Sanctuary] // [E : RSXThread]: Bad depth format! (0) // [E : RSXThread]: glEnable: opengl error 0x0506 // [E : RSXThread]: glDrawArrays: opengl error 0x0506 case 0: m_rbo.Storage(GL_DEPTH_COMPONENT, RSXThread::m_width, RSXThread::m_height); checkForGlError("m_rbo.Storage(GL_DEPTH_COMPONENT)"); break; case CELL_GCM_SURFACE_Z16: m_rbo.Storage(GL_DEPTH_COMPONENT16, RSXThread::m_width, RSXThread::m_height); checkForGlError("m_rbo.Storage(GL_DEPTH_COMPONENT16)"); break; case CELL_GCM_SURFACE_Z24S8: m_rbo.Storage(GL_DEPTH24_STENCIL8, RSXThread::m_width, RSXThread::m_height); checkForGlError("m_rbo.Storage(GL_DEPTH24_STENCIL8)"); break; default: ConLog.Error("Bad depth format! (%d)", m_surface_depth_format); assert(0); break; } for(int i=0; i<4; ++i) { m_fbo.Renderbuffer(GL_COLOR_ATTACHMENT0 + i, m_rbo.GetId(i)); checkForGlError(fmt::Format("m_fbo.Renderbuffer(GL_COLOR_ATTACHMENT%d)", i)); } m_fbo.Renderbuffer(GL_DEPTH_ATTACHMENT, m_rbo.GetId(4)); checkForGlError("m_fbo.Renderbuffer(GL_DEPTH_ATTACHMENT)"); if(m_surface_depth_format == 2) { m_fbo.Renderbuffer(GL_STENCIL_ATTACHMENT, m_rbo.GetId(4)); checkForGlError("m_fbo.Renderbuffer(GL_STENCIL_ATTACHMENT)"); } } if(!m_set_surface_clip_horizontal) { m_surface_clip_x = 0; m_surface_clip_w = RSXThread::m_width; } if(!m_set_surface_clip_vertical) { m_surface_clip_y = 0; m_surface_clip_h = RSXThread::m_height; } m_fbo.Bind(); if(Ini.GSDumpDepthBuffer.GetValue()) WriteDepthBuffer(); static const GLenum draw_buffers[] = { GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1, GL_COLOR_ATTACHMENT2, GL_COLOR_ATTACHMENT3 }; switch(m_surface_colour_target) { case CELL_GCM_SURFACE_TARGET_NONE: break; case CELL_GCM_SURFACE_TARGET_0: glDrawBuffer(draw_buffers[0]); break; case CELL_GCM_SURFACE_TARGET_1: glDrawBuffer(draw_buffers[1]); break; case CELL_GCM_SURFACE_TARGET_MRT1: glDrawBuffers(2, draw_buffers); break; case CELL_GCM_SURFACE_TARGET_MRT2: glDrawBuffers(3, draw_buffers); break; case CELL_GCM_SURFACE_TARGET_MRT3: glDrawBuffers(4, draw_buffers); break; default: ConLog.Error("Bad surface colour target: %d", m_surface_colour_target); break; } if(m_set_color_mask) { glColorMask(m_color_mask_r, m_color_mask_g, m_color_mask_b, m_color_mask_a); checkForGlError("glColorMask"); } if(m_set_viewport_horizontal && m_set_viewport_vertical) { //glViewport(m_viewport_x, m_viewport_y, m_viewport_w, m_viewport_h); //checkForGlError("glViewport"); } if (m_set_scissor_horizontal && m_set_scissor_vertical) { glScissor(m_scissor_x, m_scissor_y, m_scissor_w, m_scissor_h); checkForGlError("glScissor"); } if(m_clear_surface_mask) { GLbitfield f = 0; if (m_clear_surface_mask & 0x1) { glClearDepth(m_clear_surface_z / (float)0xffffff); f |= GL_DEPTH_BUFFER_BIT; } if (m_clear_surface_mask & 0x2) { glClearStencil(m_clear_surface_s); f |= GL_STENCIL_BUFFER_BIT; } if (m_clear_surface_mask & 0xF0) { glClearColor( m_clear_surface_color_r / 255.0f, m_clear_surface_color_g / 255.0f, m_clear_surface_color_b / 255.0f, m_clear_surface_color_a / 255.0f); f |= GL_COLOR_BUFFER_BIT; } glClear(f); } Enable(m_set_depth_test, GL_DEPTH_TEST); Enable(m_set_alpha_test, GL_ALPHA_TEST); Enable(m_set_depth_bounds_test, GL_DEPTH_BOUNDS_TEST_EXT); Enable(m_set_blend, GL_BLEND); Enable(m_set_logic_op, GL_LOGIC_OP); Enable(m_set_cull_face, GL_CULL_FACE); Enable(m_set_dither, GL_DITHER); Enable(m_set_stencil_test, GL_STENCIL_TEST); Enable(m_set_line_smooth, GL_LINE_SMOOTH); Enable(m_set_poly_smooth, GL_POLYGON_SMOOTH); Enable(m_set_point_sprite_control, GL_POINT_SPRITE); Enable(m_set_specular, GL_LIGHTING); Enable(m_set_poly_offset_fill, GL_POLYGON_OFFSET_FILL); Enable(m_set_poly_offset_line, GL_POLYGON_OFFSET_LINE); Enable(m_set_poly_offset_point, GL_POLYGON_OFFSET_POINT); Enable(m_set_restart_index, GL_PRIMITIVE_RESTART); Enable(m_set_line_stipple, GL_LINE_STIPPLE); if(m_set_clip_plane) { Enable(m_clip_plane_0, GL_CLIP_PLANE0); Enable(m_clip_plane_1, GL_CLIP_PLANE1); Enable(m_clip_plane_2, GL_CLIP_PLANE2); Enable(m_clip_plane_3, GL_CLIP_PLANE3); Enable(m_clip_plane_4, GL_CLIP_PLANE4); Enable(m_clip_plane_5, GL_CLIP_PLANE5); checkForGlError("m_set_clip_plane"); } checkForGlError("glEnable"); if (m_set_front_polygon_mode) { glPolygonMode(GL_FRONT, m_front_polygon_mode); checkForGlError("glPolygonMode(Front)"); } if (m_set_back_polygon_mode) { glPolygonMode(GL_BACK, m_back_polygon_mode); checkForGlError("glPolygonMode(Back)"); } if (m_set_point_size) { glPointSize(m_point_size); checkForGlError("glPointSize"); } if (m_set_poly_offset_mode) { glPolygonOffset(m_poly_offset_scale_factor, m_poly_offset_bias); checkForGlError("glPolygonOffset"); } if (m_set_logic_op) { glLogicOp(m_logic_op); checkForGlError("glLogicOp"); } if(m_set_two_sided_stencil_test_enable) { if(m_set_stencil_fail && m_set_stencil_zfail && m_set_stencil_zpass) { glStencilOpSeparate(GL_FRONT, m_stencil_fail, m_stencil_zfail, m_stencil_zpass); checkForGlError("glStencilOpSeparate"); } if(m_set_stencil_mask) { glStencilMaskSeparate(GL_FRONT, m_stencil_mask); checkForGlError("glStencilMaskSeparate"); } if(m_set_stencil_func && m_set_stencil_func_ref && m_set_stencil_func_mask) { glStencilFuncSeparate(GL_FRONT, m_stencil_func, m_stencil_func_ref, m_stencil_func_mask); checkForGlError("glStencilFuncSeparate"); } if(m_set_back_stencil_fail && m_set_back_stencil_zfail && m_set_back_stencil_zpass) { glStencilOpSeparate(GL_BACK, m_back_stencil_fail, m_back_stencil_zfail, m_back_stencil_zpass); checkForGlError("glStencilOpSeparate(GL_BACK)"); } if(m_set_back_stencil_mask) { glStencilMaskSeparate(GL_BACK, m_back_stencil_mask); checkForGlError("glStencilMaskSeparate(GL_BACK)"); } if(m_set_back_stencil_func && m_set_back_stencil_func_ref && m_set_back_stencil_func_mask) { glStencilFuncSeparate(GL_BACK, m_back_stencil_func, m_back_stencil_func_ref, m_back_stencil_func_mask); checkForGlError("glStencilFuncSeparate(GL_BACK)"); } } else { if(m_set_stencil_fail && m_set_stencil_zfail && m_set_stencil_zpass) { glStencilOp(m_stencil_fail, m_stencil_zfail, m_stencil_zpass); checkForGlError("glStencilOp"); } if(m_set_stencil_mask) { glStencilMask(m_stencil_mask); checkForGlError("glStencilMask"); } if(m_set_stencil_func && m_set_stencil_func_ref && m_set_stencil_func_mask) { glStencilFunc(m_stencil_func, m_stencil_func_ref, m_stencil_func_mask); checkForGlError("glStencilFunc"); } } if(m_set_shade_mode) { glShadeModel(m_shade_mode); checkForGlError("glShadeModel"); } if(m_set_depth_mask) { glDepthMask(m_depth_mask); checkForGlError("glDepthMask"); } if(m_set_depth_func) { //ConLog.Warning("glDepthFunc(0x%x)", m_depth_func); glDepthFunc(m_depth_func); checkForGlError("glDepthFunc"); } if(m_set_depth_bounds) { //ConLog.Warning("glDepthBounds(%f, %f)", m_depth_bounds_min, m_depth_bounds_max); glDepthBoundsEXT(m_depth_bounds_min, m_depth_bounds_max); checkForGlError("glDepthBounds"); } if(m_set_clip) { //ConLog.Warning("glDepthRangef(%f, %f)", m_clip_min, m_clip_max); glDepthRangef(m_clip_min, m_clip_max); checkForGlError("glDepthRangef"); } if(m_set_line_width) { glLineWidth(m_line_width); checkForGlError("glLineWidth"); } if (m_set_line_stipple) { glLineStipple(m_line_stipple_factor, m_line_stipple_pattern); checkForGlError("glLineStipple"); } if(m_set_blend_equation) { glBlendEquationSeparate(m_blend_equation_rgb, m_blend_equation_alpha); checkForGlError("glBlendEquationSeparate"); } if(m_set_blend_sfactor && m_set_blend_dfactor) { glBlendFuncSeparate(m_blend_sfactor_rgb, m_blend_dfactor_rgb, m_blend_sfactor_alpha, m_blend_dfactor_alpha); checkForGlError("glBlendFuncSeparate"); } if(m_set_blend_color) { glBlendColor(m_blend_color_r, m_blend_color_g, m_blend_color_b, m_blend_color_a); checkForGlError("glBlendColor"); } if(m_set_cull_face) { glCullFace(m_cull_face); checkForGlError("glCullFace"); } if (m_set_front_face) { glFrontFace(m_front_face); checkForGlError("glFrontFace"); } if(m_set_alpha_func && m_set_alpha_ref) { glAlphaFunc(m_alpha_func, m_alpha_ref); checkForGlError("glAlphaFunc"); } if(m_set_fog_mode) { glFogi(GL_FOG_MODE, m_fog_mode); checkForGlError("glFogi(GL_FOG_MODE)"); } if(m_set_fog_params) { glFogf(GL_FOG_START, m_fog_param0); checkForGlError("glFogf(GL_FOG_START)"); glFogf(GL_FOG_END, m_fog_param1); checkForGlError("glFogf(GL_FOG_END)"); } if(m_set_restart_index) { glPrimitiveRestartIndex(m_restart_index); checkForGlError("glPrimitiveRestartIndex"); } if(m_indexed_array.m_count && m_draw_array_count) { ConLog.Warning("m_indexed_array.m_count && draw_array_count"); } for(u32 i=0; i<m_textures_count; ++i) { if(!m_textures[i].IsEnabled()) continue; glActiveTexture(GL_TEXTURE0 + i); checkForGlError("glActiveTexture"); m_gl_textures[i].Create(); m_gl_textures[i].Bind(); checkForGlError(fmt::Format("m_gl_textures[%d].Bind", i)); m_program.SetTex(i); m_gl_textures[i].Init(m_textures[i]); checkForGlError(fmt::Format("m_gl_textures[%d].Init", i)); } m_vao.Bind(); if(m_indexed_array.m_count) { LoadVertexData(m_indexed_array.index_min, m_indexed_array.index_max - m_indexed_array.index_min + 1); } EnableVertexData(m_indexed_array.m_count ? true : false); InitVertexData(); InitFragmentData(); if(m_indexed_array.m_count) { switch(m_indexed_array.m_type) { case CELL_GCM_DRAW_INDEX_ARRAY_TYPE_32: glDrawElements(m_draw_mode - 1, m_indexed_array.m_count, GL_UNSIGNED_INT, nullptr); checkForGlError("glDrawElements #4"); break; case CELL_GCM_DRAW_INDEX_ARRAY_TYPE_16: glDrawElements(m_draw_mode - 1, m_indexed_array.m_count, GL_UNSIGNED_SHORT, nullptr); checkForGlError("glDrawElements #2"); break; default: ConLog.Error("Bad indexed array type (%d)", m_indexed_array.m_type); break; } DisableVertexData(); m_indexed_array.Reset(); } if(m_draw_array_count) { //ConLog.Warning("glDrawArrays(%d,%d,%d)", m_draw_mode - 1, m_draw_array_first, m_draw_array_count); glDrawArrays(m_draw_mode - 1, 0, m_draw_array_count); checkForGlError("glDrawArrays"); DisableVertexData(); } if (Ini.GSDumpColorBuffers.GetValue()) { WriteColorBuffers(); } }
void KernelStart(char *cmd_args[], unsigned int pmem_size, UserContext *uctxt) { virtual_memory_enabled = false; next_synch_resource_id = 1; // Initialize the interrupt vector table and write the base address // to the REG_VECTOR_BASE register TrapTableInit(); // Create the idle proc UserContext model_user_context = *uctxt; idle_proc = NewBlankPCB(model_user_context); // Perform the malloc for the idle proc's kernel stack page table before making page tables. idle_proc->kernel_stack_page_table = (struct pte *) calloc(KERNEL_STACK_MAXSIZE / PAGESIZE, sizeof(struct pte)); // Build the initial page table for region 0 such that page = frame for all valid pages. region_0_page_table = (struct pte *) calloc(VMEM_0_SIZE / PAGESIZE, sizeof(struct pte)); // Create the idle proc's page table for region 1. CreateRegion1PageTable(idle_proc); // Create the PTEs for the kernel text and data with the proper protections. unsigned int i; for (i = 0; i < kernel_brk_page; i++) { region_0_page_table[i].valid = 1; region_0_page_table[i].pfn = i; if (i < kernel_data_start_page) { // Text section. region_0_page_table[i].prot = PROT_READ | PROT_EXEC; } else { // Data section. region_0_page_table[i].prot = PROT_READ | PROT_WRITE; } } // Create the PTEs for the idle proc's kernel stack with page = frame and the proper protections. unsigned int kernel_stack_base_page = ADDR_TO_PAGE(KERNEL_STACK_BASE); for (i = 0; i < NUM_KERNEL_PAGES; i++) { idle_proc->kernel_stack_page_table[i].valid = 1; idle_proc->kernel_stack_page_table[i].pfn = i + kernel_stack_base_page; idle_proc->kernel_stack_page_table[i].prot = PROT_READ | PROT_WRITE; } // Load this new page table UseKernelStackForProc(idle_proc); idle_proc->kernel_context_initialized = true; // Set the TLB registers for the region 0 page table. WriteRegister(REG_PTBR0, (unsigned int) region_0_page_table); WriteRegister(REG_PTLR0, VMEM_0_SIZE / PAGESIZE); // Set the TLB registers for the region 1 page table. WriteRegister(REG_PTBR1, (unsigned int) idle_proc->region_1_page_table); WriteRegister(REG_PTLR1, VMEM_1_SIZE / PAGESIZE); // Enable virtual memory. Wooooo! TracePrintf(TRACE_LEVEL_DETAIL_INFO, "Enabling virtual memory. Wooooo!\n"); virtual_memory_enabled = true; WriteRegister(REG_VM_ENABLE, 1); // Initialize the physical memory management data structures. Then, initialize the // kernel book keeping structs. // Make idle the current proc since it has a region 1 page table that this call can use. current_proc = idle_proc; InitializePhysicalMemoryManagement(pmem_size); InitBookkeepingStructs(); int rc = LoadProgram("idle", NULL, idle_proc); if (rc != SUCCESS) { TracePrintf(TRACE_LEVEL_TERMINAL_PROBLEM, "KernelStart: FAILED TO LOAD IDLE!!\n"); Halt(); } // Load the init program. char *init_program_name = "init"; if (cmd_args[0]) { init_program_name = cmd_args[0]; } // Load the init program, but first make sure we are pointing to its region 1 page table. PCB *init_proc = NewBlankPCBWithPageTables(model_user_context); WriteRegister(REG_PTBR1, (unsigned int) init_proc->region_1_page_table); WriteRegister(REG_TLB_FLUSH, TLB_FLUSH_1); rc = LoadProgram(init_program_name, cmd_args, init_proc); if (rc != SUCCESS) { TracePrintf(TRACE_LEVEL_TERMINAL_PROBLEM, "KernelStart: FAILED TO LOAD INIT!!\n"); Halt(); } // Make idle the current proc. current_proc = idle_proc; WriteRegister(REG_PTBR1, (unsigned int) idle_proc->region_1_page_table); WriteRegister(REG_TLB_FLUSH, TLB_FLUSH_1); // Place the init proc in the ready queue. // On the first clock tick, the init process will be initialized and ran. ListAppend(ready_queue, init_proc, init_proc->pid); // Use the idle proc's user context after returning from KernelStart(). *uctxt = idle_proc->user_context; }
Shader::Shader(const GLchar* vertexPath, const GLchar* fragmentPath) : m_VertexPath(vertexPath) , m_FragmentPath(fragmentPath) { m_ProgramID = LoadProgram(); }
void InitScreenGlowShader(void) { bGlowShaderInitialised = false; // OPENGL EXTENSION LOADING #ifdef _WIN32 pglActiveTextureARB = (PFNGLACTIVETEXTUREARBPROC)wglGetProcAddress("glActiveTextureARB"); #else pglActiveTextureARB = SDL_GL_GetProcAddress("glActiveTextureARB"); #endif // TEXTURE CREATION unsigned char* pBlankTex = new unsigned char[ScreenWidth*ScreenHeight*3]; memset(pBlankTex, 0, ScreenWidth*ScreenHeight*3); glGenTextures(1, &g_uiSceneTex); glBindTexture(GL_TEXTURE_RECTANGLE_NV, g_uiSceneTex); glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexImage2D(GL_TEXTURE_RECTANGLE_NV, 0, GL_RGB8, ScreenWidth, ScreenHeight, 0, GL_RGB8, GL_UNSIGNED_BYTE, pBlankTex); glGenTextures(1, &g_uiBlurTex); glBindTexture(GL_TEXTURE_RECTANGLE_NV, g_uiBlurTex); glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexImage2D(GL_TEXTURE_RECTANGLE_NV, 0, GL_RGB8, ScreenWidth/4, ScreenHeight/4, 0, GL_RGB8, GL_UNSIGNED_BYTE, pBlankTex); delete[] pBlankTex; // CG INITIALISATION g_cgContext = cgCreateContext(); if (!g_cgContext) { #ifdef _WIN32 MessageBox(NULL, "Couldn't make Cg context", NULL, NULL); #else SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, "CG", "Couldn't make Cg context", NULL); #endif return; } // VERTEX PROFILE g_cgVertProfile = cgGLGetLatestProfile(CG_GL_VERTEX); if (g_cgVertProfile == CG_PROFILE_UNKNOWN) { #ifdef _WIN32 MessageBox(NULL, "Couldn't fetch valid VP profile", NULL, NULL); #else SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, "CG", "Couldn't fetch valid VP profile", NULL); #endif return; } cgGLSetOptimalOptions(g_cgVertProfile); // VP LOADING if (!LoadProgram(&g_cgVP_GlowDarken, g_cgVertProfile, "cgshaders/glow_darken_vp.cg")) return; if (!LoadProgram(&g_cgVP_GlowBlur, g_cgVertProfile, "cgshaders/glow_blur_vp.cg")) return; if (!LoadProgram(&g_cgVP_GlowCombine, g_cgVertProfile, "cgshaders/glow_combine_vp.cg")) return; // VP PARAM GRABBING g_cgpVP0_ModelViewMatrix = cgGetNamedParameter(g_cgVP_GlowDarken, "ModelViewProj"); g_cgpVP1_ModelViewMatrix = cgGetNamedParameter(g_cgVP_GlowBlur, "ModelViewProj"); g_cgpVP1_XOffset = cgGetNamedParameter(g_cgVP_GlowBlur, "XOffset"); g_cgpVP1_YOffset = cgGetNamedParameter(g_cgVP_GlowBlur, "YOffset"); g_cgpVP2_ModelViewMatrix = cgGetNamedParameter(g_cgVP_GlowCombine, "ModelViewProj"); // FRAGMENT PROFILE g_cgFragProfile = cgGLGetLatestProfile(CG_GL_FRAGMENT); if (g_cgFragProfile == CG_PROFILE_UNKNOWN) { #ifdef _WIN32 MessageBox(NULL, "Couldn't fetch valid VP profile", NULL, NULL); #else SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, "CG", "Couldn't fetch valid VP profile", NULL); #endif return; } cgGLSetOptimalOptions(g_cgFragProfile); // FP LOADING if (!LoadProgram(&g_cgFP_GlowDarken, g_cgFragProfile, "cgshaders/glow_darken_fp.cg")) return; if (!LoadProgram(&g_cgFP_GlowBlur, g_cgFragProfile, "cgshaders/glow_blur_fp.cg")) return; if (!LoadProgram(&g_cgFP_GlowCombine, g_cgFragProfile, "cgshaders/glow_combine_fp.cg")) return; bGlowShaderInitialised = true; }
void ParticleInstancingRenderer::BuildShaders() { debug1 << "building shaders" << endl; // program_instancing = LoadProgram("/home/collab/sshankar/visit_shigeru/src_nvd2/plots/Molecule/Instancing.Vertex.glsl", "/home/collab/sshankar/visit_shigeru/src_nvd2/plots/Molecule/Instancing.Fragment.glsl"); program_instancing = LoadProgram("./Instancing.Vertex.glsl", "./Instancing.Fragment.glsl"); }
void SRC_BindUberShader(uchar props) { uchar res_props; res_props = props & renderer.props; if (!ubershaders[res_props]) { currentShader = calloc(1,sizeof(shader_prog_t)); currentShader->props = res_props; ubershaders[res_props] = currentShader ; //MATLIB_printProp(res_props); LoadProgram(currentShader,"data/shaders/v_uber.glsl","data/shaders/f_uber.glsl",res_props); //Get all uniforms and attributes currentShader->vars[SHADER_MVT_MATRIX] = glGetUniformLocation(currentShader->prog,"modelViewProjectionMatrix"); currentShader->vars[SHADER_TEXT_COLOR_SAMPLER] = glGetUniformLocation(currentShader->prog,"s_baseMap"); currentShader->vars[SHADER_TEXT_BUMP_SAMPLER] = glGetUniformLocation(currentShader->prog,"s_bumpMap"); currentShader->vars[SHADER_UNI_LIGHT_POS] = glGetUniformLocation(currentShader->prog,"lightPosition"); currentShader->vars[SHADER_UNI_LIGHT_COL_AMBIENT] = glGetUniformLocation(currentShader->prog,"lightColorAmbient"); currentShader->vars[SHADER_UNI_LIGHT_COL_DIFFUSE] = glGetUniformLocation(currentShader->prog,"lightColorDiffuse"); currentShader->vars[SHADER_ATT_VERTEX] = glGetAttribLocation(currentShader->prog,"a_vertex"); currentShader->vars[SHADER_ATT_NORMAL] = glGetAttribLocation(currentShader->prog,"a_normal"); currentShader->vars[SHADER_ATT_UV] = glGetAttribLocation(currentShader->prog,"a_texcoord0"); currentShader->vars[SHADER_ATT_TANGENT] = glGetAttribLocation(currentShader->prog,"a_tangent"); currentShader->vars[SHADER_LIGHTPOV_MVT_MATRIX] = glGetUniformLocation(currentShader->prog,"lightPOVPVMMatrix"); currentShader->vars[SHADER_TEXT_SHADOWMAP_SAMPLER] = glGetUniformLocation(currentShader->prog,"s_shadowpMap"); currentShader->vars[SHADER_UNI_CAMERA_POS] = glGetUniformLocation(currentShader->prog,"cameraPosition"); currentShader->vars[SHADER_UNI_LIGHT_COL_SPECULAR] = glGetUniformLocation(currentShader->prog,"lightColorSpecular"); currentShader->vars[SHADER_UNI_MATERIAL_SHININESS] = glGetUniformLocation(currentShader->prog,"materialShininess"); currentShader->vars[SHADER_TEXT_SPEC_SAMPLER] = glGetUniformLocation(currentShader->prog,"s_specularMap"); currentShader->vars[SHADER_UNI_MAT_COL_SPECULAR] = glGetUniformLocation(currentShader->prog,"matColorSpecular"); } if (SRC_UseShader(ubershaders[res_props]) ) { if ((currentShader->props & PROP_SHADOW) == PROP_SHADOW) { glActiveTexture(GL_TEXTURE3); glBindTexture(GL_TEXTURE_2D,shadowMapTextureId); glUniform1i ( currentShader->vars[SHADER_TEXT_SHADOWMAP_SAMPLER], 3 ); } if ((currentShader->props & PROP_BUMP) == PROP_BUMP) glEnableVertexAttribArray(currentShader->vars[SHADER_ATT_TANGENT] ); else glDisableVertexAttribArray(currentShader->vars[SHADER_ATT_TANGENT]); glEnableVertexAttribArray(currentShader->vars[SHADER_ATT_UV]); glEnableVertexAttribArray(currentShader->vars[SHADER_ATT_VERTEX] ); glEnableVertexAttribArray(currentShader->vars[SHADER_ATT_NORMAL] ); //Setup light glUniform3fv(currentShader->vars[SHADER_UNI_LIGHT_COL_AMBIENT],1,light.ambient); glUniform3fv(currentShader->vars[SHADER_UNI_LIGHT_COL_DIFFUSE],1,light.diffuse); glUniform3fv(currentShader->vars[SHADER_UNI_LIGHT_COL_SPECULAR],1,light.specula); } }
void KernelStart(char *cmd_args[], unsigned int pmem_size, UserContext *uctxt) { //mark the initial KernelBrk KernelBrk = KernelDataEnd; //FreeFrameCount is only used page_table.c FreeFrameCount = pmem_size / PAGESIZE; ipc_table = (ObjectNode **) malloc(sizeof(ObjectNode *) * HASH_LEN); if (NULL == ipc_table) { TracePrintf(0, "ipc_table cannot be initialized!\n"); return; } memset(ipc_table, 0, sizeof(ObjectNode *) * HASH_LEN); ReadyQueue = (Queue *) malloc(sizeof(Queue)); DelayQueue = (Queue *) malloc(sizeof(Queue)); if (NULL == ReadyQueue) { TracePrintf(0, "ReadyQueue cannot be initialized!\n"); return; } if (NULL == DelayQueue) { TracePrintf(0, "DelayQueue cannot be initialized!\n"); return; } memset(ReadyQueue, 0, sizeof(Queue)); memset(DelayQueue, 0, sizeof(Queue)); u_int i; for (i = 0; i < NUM_TERMINALS; i++) { BufferQueue[i] = (Queue *) malloc(sizeof(Queue)); ReceiveQueue[i] = (Queue *) malloc(sizeof(Queue)); TransmitQueue[i] = (Queue *) malloc(sizeof(Queue)); if (NULL == BufferQueue[i]) { TracePrintf(0, "BufferQueue[%d] cannot be initialized!\n", i); return; } if (NULL == ReceiveQueue[i]) { TracePrintf(0, "ReceiveQueue[%d] cannot be initialized!\n", i); return; } if (NULL == TransmitQueue[i]) { TracePrintf(0, "TransmitQueue[%d] cannot be initialized!\n", i); return; } memset(BufferQueue[i], 0, sizeof(Queue)); memset(ReceiveQueue[i], 0, sizeof(Queue)); memset(TransmitQueue[i], 0, sizeof(Queue)); } //create interrupt vector table in kernel void **interruptVectorTable = (void **) malloc(sizeof(void *) * TRAP_VECTOR_SIZE); if (NULL == interruptVectorTable) { TracePrintf(0, "Interrupt Vector Table cannot be initialized!\n"); return; } //fill each entry in table with pointer to correct handler interruptVectorTable[TRAP_KERNEL] = &TrapKernelHandler; interruptVectorTable[TRAP_CLOCK] = &TrapClockHandler; interruptVectorTable[TRAP_ILLEGAL] = &TrapIllegalHandler; interruptVectorTable[TRAP_MEMORY] = &TrapMemoryHandler; interruptVectorTable[TRAP_MATH] = &TrapMathHandler; interruptVectorTable[TRAP_TTY_RECEIVE] = &TrapTtyReceiveHandler; interruptVectorTable[TRAP_TTY_TRANSMIT] = &TrapTtyTransmitHandler; interruptVectorTable[TRAP_DISK] = &TrapDiskHandler; for (i = 8; i < 16; i++) { interruptVectorTable[i] = &TrapErrorHandler; } //point REG_VECTOR_BASE to interrupt vector table WriteRegister(REG_VECTOR_BASE, (u_int) interruptVectorTable); TracePrintf(0, "Interrupt vector table initialization completed.\n"); //Build page table for Region 0 KernelPageTable = (PTE *) malloc(sizeof(PTE) * MAX_PT_LEN); if (NULL == KernelPageTable) { TracePrintf(0, "KernelPageTable cannot be initialized!\n"); return; } memset(KernelPageTable, 0, sizeof(PTE) * MAX_PT_LEN); TracePrintf(0, "Page tables built successfully.\n"); //create kernel stack union KS = (KernelStack *) KERNEL_STACK_BASE; TracePrintf(0, "Kernel stack initialization completed.\n"); //build input init process PCB KS->CurrentPCB = InitPCB = InitializePCB(); if (NULL == InitPCB) { TracePrintf(0, "InitPCB cannot be initialized!\n"); return; } // We enablePTE after using all the malloc in the kernel because // only in this way we can make sure the getFreeFrame will be called // and update the FreeFrameCount. enablePTE(0, Page(KernelDataStart), PROT_READ | PROT_EXEC); enablePTE(Page(KernelDataStart), Page(KernelBrk), PROT_READ | PROT_WRITE); enablePTE(INTERFACE, Page(KERNEL_STACK_LIMIT), PROT_READ | PROT_WRITE); // initialize virtual memory registers WriteRegister(REG_PTBR0, (u_int) KernelPageTable); WriteRegister(REG_PTLR0, MAX_PT_LEN); WriteRegister(REG_PTBR1, (u_int) KS->CurrentPCB->pagetable); WriteRegister(REG_PTLR1, MAX_PT_LEN); TracePrintf(0, "Table information loading to hardware completed.\n"); //set up the link list to keep track of free frames //from KernelBrk to KERNEL_STACK_BASE *FrameNumber(INTERFACE) = Page(KernelBrk); for (i = Page(KernelBrk); i < INTERFACE - 1; i++) { *FrameNumber(i) = i + 1; } *FrameNumber(INTERFACE - 1) = Page(VMEM_0_LIMIT); for (i = Page(VMEM_0_LIMIT); i < Page(pmem_size - 1); i++) { *FrameNumber(i) = i + 1; } TracePrintf(0, "Free frames' linked list has been set up.\n"); //enable virtual memory WriteRegister(REG_VM_ENABLE, 1); VM_ENABLED = 1; TracePrintf(0, "Virtual memory has been enabled.\n"); TracePrintf(0, "Load input program. (Default init)\n"); if (NULL != cmd_args[0]) { if (FAILURE == LoadProgram(cmd_args[0], cmd_args, InitPCB)) { TracePrintf(0, "Load input program failed!\n"); return; } } else { char *args[] = {"init", NULL}; if (FAILURE == LoadProgram(args[0], args, InitPCB)) { TracePrintf(0, "Load input program failed!\n"); return; } } TracePrintf(0, "Build the Idle process.\n"); //build kernel idle process PCB IdlePCB = InitializePCB(); if (NULL == IdlePCB) { TracePrintf(0, "IdlePCB cannot be initialized!\n"); return; } //sp = virtual address of top of stack IdlePCB->uctxt.sp = (void *) (VMEM_1_LIMIT - INITIAL_STACK_FRAME_SIZE - POST_ARGV_NULL_SPACE); //pc = virtual address of DoIdle function IdlePCB->uctxt.pc = &DoIdle; //enable user stack for idle process IdlePCB->pagetable[MAX_PT_LEN - 1].valid = 1; IdlePCB->pagetable[MAX_PT_LEN - 1].prot = PROT_READ | PROT_WRITE; if (0 == FreeFrameCount) { TracePrintf(0, "No frame for Idle process pagetable!\n"); return; } IdlePCB->pagetable[MAX_PT_LEN - 1].pfn = getFreeFrame(0); //use MyKCS initialize IdlePCB's KC and KS KernelContextSwitch(KCKSInit, (void *) IdlePCB, NULL); TracePrintf(0, "How many time will this line be printed?\n"); //copy current context into hardware provided context *uctxt = KS->CurrentPCB->uctxt; TracePrintf(0, "KernelStart finished.\n"); }
int main(int argc, char *argv[]) { uint32_t width = 1920, height = 1080; LoadOpenGLESWindow(width, height); // initial opengl state glEnable(GL_TEXTURE_2D); glEnable(GL_BLEND); glBlendFunc(GL_ONE, GL_ONE); glDisable(GL_CULL_FACE); glClearColor(0.0f, 0.0f, 0.0f, 0.0f); // load textures GLfloat max_anisotropy; glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY, &max_anisotropy); GLuint textures[TEXTURES_NUM]; glGenTextures(TEXTURES_NUM, textures); int i; for (i = 0; i < TEXTURES_NUM; i++) { int x, y, n; unsigned char *data = stbi_load(texture_files[i], &x, &y, &n, 3); if (data == NULL) { fprintf(stderr, "Could not load file: %s", texture_files[i]); exit(-1); } glBindTexture(GL_TEXTURE_2D, textures[i]); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, x, y, 0, GL_RGB, GL_UNSIGNED_BYTE, data); glGenerateMipmap(GL_TEXTURE_2D); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY, max_anisotropy); stbi_image_free(data); } // load program GLuint programObject = LoadProgram(vertex_shader, fragment_shader); glUseProgram(programObject); glUniform1i(glGetUniformLocation(programObject, "tex"), 0); GLint colorUniformLocation = glGetUniformLocation(programObject, "color"); GLint transformUniformLocation = glGetUniformLocation(programObject, "transform"); // load quad data glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, quad_vertices); glEnableVertexAttribArray(0); glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, quad_texcoord); glEnableVertexAttribArray(1); unsigned int frames = 0; while(1) { glViewport(0, 0, width, height); // animation params double t = (frames++) * 0.02f; float a = 0.5f + 0.5f * sinf(t * 13.0f); float x = 0.2f * sinf(32.0f * t) * sinf(3.5f * t); float y = 0.1f * sinf(23.0f * t) * sinf(3.5f * t); // camera config mat4_t proj = mat4_perspective(50.0f, (float)width / (float)height, 0.1f, 1000.0f); mat4_t view = mat4_mul(//mat4_mul( mat4_translation(vec3(x, y, -3.0f)), // positioning mat4_rotation(-90.0f, vec3(0.0f, 0.0f, 1.0f)));//, // beamer rotation //mat4_rotation(180.0f, vec3(0.0f, 1.0f, 0.0f))); // horizontal "flip" mat4_t vp = mat4_mul(proj, view); // color glUniform3f(colorUniformLocation, a * (0.5f + 0.5f * sinf(t)), a * (0.5f + 0.5f * sinf(1.3f * t)), a * (0.5f + 0.5f * sinf(1.7f * t))); // draw radials int i; for (i = 0; i < 3; i++) { mat4_t mvp = mat4_mul(vp, mat4_rotation(20.0f * cos(t * 2.0f), vec3(0.0f, 1.0f, 0.0f))); mvp = mat4_mul(mvp, mat4_translation(vec3(0.0f, 0.8f, 0.0f))); mvp = mat4_mul(mvp, mat4_rotation(t * 32.0f * (0.5f + (i - 1)), vec3(0.0f, 0.0f, 1.0f))); glUniformMatrix4fv(transformUniformLocation, 1, GL_FALSE, mvp.m); glBindTexture(GL_TEXTURE_2D, textures[RADIAL0 + i]); glDrawArrays(GL_TRIANGLES, 0, 6); } // draw text mat4_t mvp = mat4_mul(vp, mat4_rotation(60.0f * sin(t), vec3(0.0f, 1.0f, 0.0f))); mvp = mat4_mul(mvp, mat4_translation(vec3(0.0f, -0.8f, 0.0f))); glUniformMatrix4fv(transformUniformLocation, 1, GL_FALSE, mvp.m); glBindTexture(GL_TEXTURE_2D, textures[TEXT]); glDrawArrays(GL_TRIANGLES, 0, 6); // present eglSwapBuffers(display, surface); } }
void InitializeProgram() { UniformColor = LoadProgram("PosOnlyWorldTransform.vert", "ColorUniform.frag"); ObjectColor = LoadProgram("PosColorWorldTransform.vert", "ColorPassthrough.frag"); UniformColorTint = LoadProgram("PosColorWorldTransform.vert", "ColorMultUniform.frag"); }