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