void initShaders() {
//ASCH - 25/05/2016 - Initialisation des shaders
sm.init();
shader_programme = sm.getShader_programme();
vs = sm.getVertexShader();
fs = sm.getFragShader();
//ASCH 25/05/2016 - Chargement des objets de scene
for_each(objetsDeScene.begin(), objetsDeScene.end(), charger);
/* A CONTROLER DANS LA CLASSE ObjetDeScene ou shaderManager
//ASCH 24/09/2015 - Modification pour prendre en compte le multiobjet
printf("---- taille : %d\n", objets.size());
vao = new GLuint[objets.size()];
//Création des tableaux en mémoire
glGenVertexArrays (objets.size(), vao);
// ASCH 20/04/2015 - Chargement des objets en mémoire graphique
for(int i = 0; i < objets.size(); i++) {
objets[i].construireVAO(vao[i], i);
nbVertex += objets[i].getNbVertex();
}
*/
}
void InitGL() {
// Init opengl(depth test, blending, lighting and so on...)
glEnable(GL_DEPTH_TEST);
glClearColor(0,0,0,1);
ShaderManager *sMan = ShaderManager::getDefaultManager();
shader = sMan->createShader("C:/Andrea/GLSL/version130/prova2.vert", "C:/Andrea/GLSL/version130/prova2.geom", "C:/Andrea/GLSL/version130/prova2.frag");
glGenVertexArrays(1, &vao); // create vao
glGenBuffers(2, vbo); // create vbo
glBindVertexArray(vao);
int posLocation = shader->getAttributeLocation("in_Position");
cout << posLocation << endl;
//vertices position attribute
glBindBuffer(GL_ARRAY_BUFFER, vbo[0]);
glBufferData(GL_ARRAY_BUFFER, 12 * sizeof(GLfloat), vertices, GL_STATIC_DRAW);
glVertexAttribPointer(posLocation, 3, GL_FLOAT, GL_FALSE, 0, 0);
//vertices indices
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vbo[1]);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, 6 * sizeof(GLuint), indices, GL_STATIC_DRAW);
glEnableVertexAttribArray(0);
glBindVertexArray(0);
}
void InitZephyrModules()
{
// A. Timer
Core::Timer *mTimer = new Timer();
mTimer->Initialize();
mTimer->Reset();
// B. Filesystem
Core::FileSystem *fsMngr = new Core::Win32FileSystem();
fsMngr->Initialize();
// C. Input manager
Input::SCTInputManager *inputMngr = new Input::SCTInputManagerWin32(mHinst, mHwnd);
inputMngr->Initialize();
inputMngr->CreateKeyboardDevice();
std::cout<<"$> Keyboard Device has been initialized\n";
inputMngr->CreateMouseDevice();
std::cout<<"$> Mouse Device has been initialized\n";
// D. Shader manager
ShaderManager *mShaderManager = new CgGLShaderManager();
mShaderManager->SetDebugMode(true); // Always?
mShaderManager->Initialize();
}
GLBox()
{
App = new sf::Window(sf::VideoMode(RES_WIDTH, RES_HEIGHT, 32), "Bubbles!");
// Setting up shaders
FILE * logFile;
logFile = fopen("log text", "wb");
if(NULL == logFile)
{
printf("Unable to open log file. Exiting...\n");
exit(2);
}
__glewInit(logFile);
ShaderManager shaders = ShaderManager(logFile);
char const * bubbleDrawVert = "BubbleShaders/bubbleRender3dModel.vert";
char const * bubbleDrawFrag = "BubbleShaders/bubbleRender3dModel.frag";
bubbleShaderProg = shaders.buildShaderProgram(&bubbleDrawVert, &bubbleDrawFrag, 1, 1);
Clock = sf::Clock();
mode = BUBBLE_MODE;
gfxinit();
while (App->IsOpened())
{
App->SetActive();
handleEvents();
setShader();
setShaderVariables(bubbleShaderProg);
display();
App->Display();
}
fclose(logFile);
}
/**
* Draw scene
**/
void Scene::draw(ShaderManager & shaderManager)
{
for(ModelVector::iterator it = modelVector.begin(); it != modelVector.end(); ++it)
{
if((*it) != 0)
{
// Only render transperent objects in the transperent stage
if((*it)->isTransperent() && shaderManager.getStateManager().getRenderingStage() != StateManager::TRANSPARENCY_STAGE) continue;
else if(!(*it)->isTransperent() && shaderManager.getStateManager().getRenderingStage() == StateManager::TRANSPARENCY_STAGE) continue;
for(Model::EntityVector::iterator entIt = (*it)->getAllEntities().begin(); entIt != (*it)->getAllEntities().end(); ++entIt)
{
glPushMatrix();
glTranslatef(entIt->position.x,entIt->position.y,entIt->position.z);
glRotatef(entIt->rotation.w,entIt->rotation.x,entIt->rotation.y,entIt->rotation.z);
glScalef(entIt->scale.x,entIt->scale.y,entIt->scale.z);
shaderManager.updateModelviewPerspectiveMatrix();
if(shaderManager.getStateManager().getRenderingStage() == StateManager::TRANSPARENCY_STAGE)
{
glm::mat4x4 tlMat = glm::translate(glm::mat4x4(1.0),entIt->position);
//glm::mat4x4 rotMat = glm::rotate(tlMat, entIt->rotation.w,glm::vec3(entIt->rotation.x,entIt->rotation.y,entIt->rotation.z));
//glm::mat4x4 scMat = glm::scale(rotMat, entIt->scale);
shaderManager.setCgParam(tlMat,"modelMatrix",VERTEX);
}
(*it)->draw(shaderManager);
glPopMatrix();
}
}
}
}
void ShadowMapDemo::RenderScene( ShaderManager& shader_mgr )
{
// m_pShadowMapManager->ShaderTechniqueForShadowCaster();
GraphicsDevice().SetRenderState( RenderStateType::ALPHA_BLEND, false );
GraphicsDevice().SetRenderState( RenderStateType::LIGHTING, m_Lighting );
shared_ptr<ShaderLightManager> pLightMgr = shader_mgr.GetShaderLightManager();
if( pLightMgr )
pLightMgr->CommitChanges();
int num_mesh_rows = 5;
for( int i=0; i<num_mesh_rows; i++ )
{
Matrix34 pose( Matrix34Identity() );
pose.vPosition = Vector3( 0.0f, (float)i * 1.25f, (float)i * 5.0f + 2.0f );
shader_mgr.SetWorldTransform( pose );
shared_ptr<BasicMesh> pMesh = m_Mesh.GetMesh();
if( pMesh )
pMesh->Render( shader_mgr );
}
shader_mgr.SetWorldTransform( Matrix44Identity() );
shared_ptr<BasicMesh> pFloor = m_FloorMesh.GetMesh();
if( pFloor )
pFloor->Render( shader_mgr );
// PrimitiveShapeRenderer renderer;
// renderer.SetShader( );
// renderer.RenderBox( Vector3( 100.0f, 0.1f, 100.0f ), Matrix34( Vector3(0.0f,-0.05f,0.0f), Matrix33Identity() ) );
}
/*************************************************
* OpenGL initialization
*************************************************/
static int initGL(WININFO *winInfo)
{
char errorString[MAX_ERROR_LENGTH + 1];
// Create openGL functions
for (int i=0; i<NUM_GL_NAMES; i++) glFP[i] = (GenFP)wglGetProcAddress(glnames[i]);
// Create and initialize the shader manager
if (shaderManager.init(errorString))
{
MessageBox(winInfo->hWnd, errorString, "Shader Manager Load", MB_OK);
return -1;
}
// Create and initialize everything needed for texture Management
if (textureManager.init(errorString))
{
MessageBox(winInfo->hWnd, errorString, "Texture Manager Load", MB_OK);
return -1;
}
// Create the text editor
if (editor.init(&shaderManager, &textureManager, errorString))
{
MessageBox(winInfo->hWnd, errorString, "Editor init", MB_OK);
return -1;
}
return 0;
}
/// Update light-related shader variables
void SetLightsToShader( CCopyEntity& entity, ShaderManager& rShaderMgr )
{
shared_ptr<ShaderLightManager> pShaderLightMgr = rShaderMgr.GetShaderLightManager();
int i, num_current_lights = entity.GetNumLights();
LightEntity *pLightEntity = NULL;
// clear any lights currenly stored in the shader light manager
pShaderLightMgr->ClearLights();
ShaderLightParamsWriter light_params_writer( pShaderLightMgr.get() );
for( i=0; i<num_current_lights; i++ )
{
EntityHandle<LightEntity>& light_entity = entity.GetLight( i );
LightEntity *pLightEntity = light_entity.GetRawPtr();
if( !pLightEntity )
continue;
// pLightEntity->SetLightToShader( pShaderLightMgr );
// copy light properties to the shader registers
pLightEntity->GetLightObject()->Accept( light_params_writer );
}
pShaderLightMgr->CommitChanges();
}
// Just to get something on the screen, we'll just not subdivide correctly.
void drawBezier(int ucount, int vcount)
{
u16 indices[3 * 3 * 6];
float customUV[32];
int c = 0;
for (int y = 0; y < 3; y++) {
for (int x = 0; x < 3; x++) {
indices[c++] = y * 4 + x;
indices[c++] = y * 4 + x + 1;
indices[c++] = (y + 1) * 4 + x + 1;
indices[c++] = (y + 1) * 4 + x + 1;
indices[c++] = (y + 1) * 4 + x;
indices[c++] = y * 4 + x;
}
}
for (int y = 0; y < 4; y++) {
for (int x = 0; x < 4; x++) {
customUV[(y * 4 + x) * 2 + 0] = (float)x/3.0f;
customUV[(y * 4 + x) * 2 + 1] = (float)y/3.0f;
}
}
LinkedShader *linkedShader = shaderManager.ApplyShader();
TransformAndDrawPrim(Memory::GetPointer(gstate.vertexAddr), &indices[0], GE_PRIM_TRIANGLES, 3 * 3 * 6, linkedShader, customUV, GE_VTYPE_IDX_16BIT);
}
void draw(sf::RenderTarget &tg)
{
if (first)
{
rt.clear();
rt.draw(sprite);
rt.draw(logo);
if (logo.getPosition().y == 0.0)rt.draw(press);
if (check && timer.getElapsedTime().asSeconds() < 1)
{
if ((int)(rand() % 10) == 3) rt.clear(sf::Color::White);
}
}
else
{
rt.clear(sf::Color::White);
rt.draw(system);
rt.draw(back2);
rt.draw(pointer);
}
rt.display();
sm.draw(rt, tg);
if (first) tg.draw(v);
};
int main(int argc, char** argv){
StringHelper::init();
Log >> new ConsoleLogger();
//Set filter to include all.
Log.setLevelFilter(LogManager::ll_Verbose);
for(int i = 1; i < argc; i+=2){
Log << argv[i];
ShaderManager manager;
manager.loadRaw(argv[i]);
manager.save(argv[i+1]);
ShaderManager saveTest;
saveTest.load(argv[i+1]);
}
Log.close();
return 0;
}
void CPURenderer::Draw(VolumeDataset &volume, ShaderManager &shaderManager, Camera &camera)
{
GLuint shaderProgramID = shaderManager.UseShader(TextureShader);
raycaster->Raycast(volume, transferFunction, shaderProgramID, camera);
}
void C2DPrimitiveRenderer_GL::Render( General2DVertex *paVertex, int num_vertices, PrimitiveType::Name primitive_type )
{
ShaderHandle shader
= sg_2DPrimitiveCommonShaders.GetShader( C2DPrimitiveCommonShaders::ST_DIFFUSE_COLOR );
ShaderManager *pShaderMgr = shader.GetShaderManager();
if( !pShaderMgr )
{
LOG_PRINT_ERROR( "The shader for 2D primitives is not available." );
return;
}
pShaderMgr->Begin();
RenderViaVertexAttribArray( paVertex, num_vertices, NULL, 0, ToGLPrimitiveType(primitive_type) );
}
static void RestoreOffsetWorldTransform( ShaderManager& rShaderManager )
{
Matrix44 matWorld, matView;
rShaderManager.GetWorldTransform( matWorld );
rShaderManager.GetViewTransform( matView );
matWorld(0,3) = s_OrigWorldPos.x;
matWorld(1,3) = s_OrigWorldPos.y;
matWorld(2,3) = s_OrigWorldPos.z;
matView(0,3) = s_OrigViewTrans.x;
matView(1,3) = s_OrigViewTrans.y;
matView(2,3) = s_OrigViewTrans.z;
rShaderManager.SetWorldTransform( matWorld );
rShaderManager.SetViewTransform( matView );
}
ShaderProgram::ShaderProgram(std::string* fileName)
{
this->name.assign(*fileName);
this->status = true;
this->id = glCreateProgram();
this->shaderCount = 0;
ShaderManager* shaderManager = ShaderManager::getShaderManager();
std::vector<std::string*>* strings = Util::Parsing::getStringArray(&this->name);
int linkStatus = 0;
for(unsigned int index = 0; index < strings->size(); index++)
{
//Ignore blank and comment lines.
if(Util::StringLib::isWhiteSpace((*strings)[index]) ||
Util::StringLib::startsWith((*strings)[index], "\\\\") ||
Util::StringLib::startsWith((*strings)[index], "#"))
{
continue;
}
this->shaders[this->shaderCount] = shaderManager->getShader((*strings)[index]);
glAttachShader(this->id, this->shaders[shaderCount]->id);
this->shaderCount++;
}
glLinkProgram( this->id);
glGetProgramiv(this->id, GL_LINK_STATUS, &linkStatus);
if(linkStatus == 0) //GL_FALSE
{
char* errorLogBuffer = NULL;
int errorLength = 0;
glGetProgramiv(this->id, GL_INFO_LOG_LENGTH, &errorLength);
errorLogBuffer = new char[errorLength];
memset(errorLogBuffer, 0, errorLength);
glGetProgramInfoLog(this->id, errorLength, NULL, errorLogBuffer);
Main::die(errorLogBuffer);
}
delete strings;
}
HRESULT MeshGroup::createDeviceStuffs(ID3D11Device* device)
{
HRESULT hr = S_OK;
hr = createBuffers(device);
if (FAILED(hr)) return hr;
ShaderManager shaderManager = ShaderManager::sharedShaderManager();
for (auto kv : materials) {
MeshMaterial *material = kv.second;
if (material->hasTexture) {
material->pixelShader = shaderManager.pixelShaderForTexture(device);
} else {
material->pixelShader = shaderManager.pixelShaderForNoTexture(device);
}
}
}
void C2DPrimitiveRenderer_GL::Render( const General2DVertex *pVertices, uint num_vertices, U16 *indices, uint num_indices, PrimitiveType::Name primitive_type, TextureHandle texture )
{
ShaderHandle shader
= sg_2DPrimitiveCommonShaders.GetShader( C2DPrimitiveCommonShaders::ST_DIFFUSE_COLOR_AND_TEXTURE );
ShaderManager *pShaderMgr = shader.GetShaderManager();
if( !pShaderMgr )
{
return;
}
pShaderMgr->SetTexture( 0, texture );
pShaderMgr->Begin();
RenderViaVertexAttribArray( pVertices, num_vertices, indices, num_indices, ToGLPrimitiveType(primitive_type) );
}
void FoliageMesh::StreamAllFoliage( Mesh* root )
{
Lilith3D* lilith = Lilith3D::Instance();
if ( lilith->RenderFoliage() && root )
{
L3PERFTRACK
//const Vector3F& eye = lilith->GetCamera()->Eye();
ShaderManager* shaderman = ShaderManager::Instance();
const Shader* shader = shaderman->GetShader( ShaderManager::FOLIAGE_SHADER );
L3State state;
state.blend = true;
state.shader = shader;
// FIXME: choose a proper texture name for the foliage, and document that
// all foliage needs to use the same texture.
state.texture = TextureManager::Instance()->GetTexture( "grass1", 0 );
StateManager::Enable( state );
float fOffset = float( Lilith3D::GetTimeClock()->Msec() ) / 900.0f;
shaderman->SetUniform( shader, "offset", fOffset );
shaderman->SetUniform( shader, "eyeDirection", lilith->GetCamera()->Direction() );
glColor4f( 1.0f, 1.0f, 1.0f, 1.0f );
while ( root )
{
GLASSERT( root->Type() == FOLIAGEMESH );
FoliageMesh* foliageMesh = (FoliageMesh*)root;
// FIXME: PreStreamOut checks for cull - do our own culling, pull in the blending for
// foliage much closer. (Also change the shader). 2 calls to OpenGL can be removed
// by setting the matrix rather than PUSH-MULT-POP
//
if ( foliageMesh->PreStreamOut( FOLIAGE_FADE, FOLIAGE_FADEOUT, 0 ) )
{
foliageMesh->GetStaticResource()->StreamOutVertex();
foliageMesh->PostStreamOut();
}
root = root->nextRender;
}
}
}
void hleEnterVblank(u64 userdata, int cyclesLate)
{
int vbCount = userdata;
DEBUG_LOG(HLE, "Enter VBlank %i", vbCount);
isVblank = 1;
// Wake up threads waiting for VBlank
__KernelTriggerWait(WAITTYPE_VBLANK, 0, true);
// Trigger VBlank interrupt handlers.
__TriggerInterrupt(PSP_VBLANK_INTR);
CoreTiming::ScheduleEvent(msToCycles(vblankMs) - cyclesLate, leaveVblankEvent, vbCount+1);
// TODO: Should this be done here or in hleLeaveVblank?
if (framebufIsLatched)
{
DEBUG_LOG(HLE, "Setting latched framebuffer %08x (prev: %08x)", latchedFramebuf.topaddr, framebuf.topaddr);
framebuf = latchedFramebuf;
framebufIsLatched = false;
}
// Yeah, this has to be the right moment to end the frame. Should possibly blit the right buffer
// depending on what's set in sceDisplaySetFramebuf, in order to support half-framerate games -
// an initial hack could be to NOT end the frame if the buffer didn't change? that should work okay.
{
host->EndFrame();
host->BeginFrame();
if (g_Config.bDisplayFramebuffer)
{
INFO_LOG(HLE, "Drawing the framebuffer");
DisplayDrawer_DrawFramebuffer(framebuf.pspframebuf, framebuf.pspFramebufFormat, framebuf.pspFramebufLinesize);
}
shaderManager.DirtyShader();
shaderManager.DirtyUniform(DIRTY_ALL);
}
// TODO: Find a way to tell the CPU core to stop emulating here, when running on Android.
}
LODManager::LODManager() {
if (!EnabledLOD.Get())
return;
WorldSpace = 0;
memset(Meshes, 0, sizeof(Meshes));
memset(Colors, 0, sizeof(Colors));
memset(Normals, 0, sizeof(Normals));
memset(MeshIDs, 0xFE, sizeof(MeshIDs));
memset(ColrIDs, 0xFE, sizeof(ColrIDs));
memset(NormIDs, 0xFE, sizeof(NormIDs));
ShaderManager *sm = ShaderManager::GetSingleton();
/* look-ups will always be done with the original shader-address */
if ((vNear = sm->GetBuiltInShader("LODNEAR.vso"))) {
vNear->GetBinary(); vNear->ConstructDX9Shader(SHADER_REPLACED);
vShader[GRID_FARNEAR] = vNear->pDX9VertexShader; }
if ((pNear = sm->GetBuiltInShader("LODNEAR.pso"))) {
pNear->GetBinary(); pNear->ConstructDX9Shader(SHADER_REPLACED);
pShader[GRID_FARNEAR] = pNear->pDX9PixelShader; }
/* look-ups will always be done with the original shader-address */
if ((vFar = sm->GetBuiltInShader("LODFAR.vso"))) {
vFar->GetBinary(); vFar->ConstructDX9Shader(SHADER_REPLACED);
vShader[GRID_FARFAR] = vFar->pDX9VertexShader; }
if ((pFar = sm->GetBuiltInShader("LODFAR.pso"))) {
pFar->GetBinary(); pFar->ConstructDX9Shader(SHADER_REPLACED);
pShader[GRID_FARFAR] = pFar->pDX9PixelShader; }
/* look-ups will always be done with the original shader-address */
if ((vInf = sm->GetBuiltInShader("LODINF.vso"))) {
vInf->GetBinary(); vInf->ConstructDX9Shader(SHADER_REPLACED);
vShader[GRID_FARINF] = vInf->pDX9VertexShader; }
if ((pInf = sm->GetBuiltInShader("LODINF.pso"))) {
pInf->GetBinary(); pInf->ConstructDX9Shader(SHADER_REPLACED);
pShader[GRID_FARINF] = pInf->pDX9PixelShader; }
/* look-ups will always be done with the original shader-address */
if ((vWater = sm->GetBuiltInShader("LODWATER.vso"))) {
vWater->GetBinary(); vWater->ConstructDX9Shader(SHADER_REPLACED);
vShaderW = vWater->pDX9VertexShader; }
if ((pWater = sm->GetBuiltInShader("LODWATER.pso"))) {
pWater->GetBinary(); pWater->ConstructDX9Shader(SHADER_REPLACED);
pShaderW = pWater->pDX9PixelShader; }
}
bool PSP_Init(const CoreParameter &coreParam, std::string *error_string)
{
coreParameter = coreParam;
currentCPU = &mipsr4k;
numCPUs = 1;
Memory::Init();
mipsr4k.Reset();
mipsr4k.pc = 0;
if (coreParameter.enableSound)
{
host->InitSound(new PSPMixer());
}
// Init all the HLE modules
HLEInit();
// TODO: Check Game INI here for settings, patches and cheats, and modify coreParameter accordingly
if (!LoadFile(coreParameter.fileToStart.c_str(), error_string))
{
pspFileSystem.UnmountAll();
CoreTiming::ClearPendingEvents();
CoreTiming::UnregisterAllEvents();
__KernelShutdown();
HLEShutdown();
host->ShutdownSound();
Memory::Shutdown();
coreParameter.fileToStart = "";
return false;
}
shaderManager.DirtyShader();
shaderManager.DirtyUniform(DIRTY_ALL);
// Setup JIT here.
if (coreParameter.startPaused)
coreState = CORE_STEPPING;
else
coreState = CORE_RUNNING;
return true;
}
void InvertEffect::drawWindow(EffectWindow* w, int mask, QRegion region, WindowPaintData& data)
{
// Load if we haven't already
if (m_valid && !m_inited)
m_valid = loadData();
bool useShader = m_valid && (m_allWindows != m_windows.contains(w));
if (useShader) {
ShaderManager *shaderManager = ShaderManager::instance();
shaderManager->pushShader(m_shader);
data.shader = m_shader;
}
effects->drawWindow(w, mask, region, data);
if (useShader) {
ShaderManager::instance()->popShader();
}
}
void ExplosionEffect::paintWindow(EffectWindow* w, int mask, QRegion region, WindowPaintData& data)
{
// Make sure we have OpenGL compositing and the window is vidible and not a
// special window
bool useshader = (mValid && mWindows.contains(w));
if (useshader) {
double maxscaleadd = 1.5f;
double scale = 1 + maxscaleadd * mWindows[w];
data.setXScale(scale);
data.setYScale(scale);
data.translate(int(w->width() / 2 * (1 - scale)), int(w->height() / 2 * (1 - scale)));
data.multiplyOpacity(0.99); // Force blending
ShaderManager *manager = ShaderManager::instance();
GLShader *shader = manager->pushShader(ShaderManager::GenericShader);
QMatrix4x4 screenTransformation = shader->getUniformMatrix4x4("screenTransformation");
manager->popShader();
ShaderManager::instance()->pushShader(mShader);
mShader->setUniform("screenTransformation", screenTransformation);
mShader->setUniform("factor", (float)mWindows[w]);
mShader->setUniform("scale", (float)scale);
mShader->setUniform("windowSize", QVector2D(w->width(), w->height()));
glActiveTexture(GL_TEXTURE4);
mStartOffsetTex->bind();
glActiveTexture(GL_TEXTURE5);
mEndOffsetTex->bind();
glActiveTexture(GL_TEXTURE0);
data.shader = mShader;
}
// Call the next effect.
effects->paintWindow(w, mask, region, data);
if (useshader) {
ShaderManager::instance()->popShader();
glActiveTexture(GL_TEXTURE4);
mStartOffsetTex->unbind();
glActiveTexture(GL_TEXTURE5);
mEndOffsetTex->unbind();
glActiveTexture(GL_TEXTURE0);
}
}
void Init()
{
camera.Init(SCREEN_WIDTH, SCREEN_HEIGHT);
shaderManager.Init();
raycaster.Init(SCREEN_WIDTH, SCREEN_HEIGHT);
fluid.Init();
rawDataSize = gridXRes * gridYRes * gridZRes * sizeof(float);
buffer = new char[rawDataSize];
pixelBuffer = new char[SCREEN_WIDTH * SCREEN_HEIGHT * 4];
}
void Skybox::preRender( const RenderData* pData )
{
ShaderManager* pShaderManager = GraphicsManager::GetInstance()->getShaderManager();
pShaderManager->useProgram("skybox");
glm::mat4x4 mModel = mat4(1.0f);
glm::mat4x4 mViewProj, mModelViewProj;
mModel = glm::translate(mModel, vec3(m_Pos.x, m_Pos.y, m_Pos.z));
mModel = glm::scale(mModel, vec3(m_Scale.x, m_Scale.y, m_Scale.z));
mModel = glm::rotate(mModel, m_Rot.x, vec3(1.0f, 0.0f, 0.0f));
mModel = glm::rotate(mModel, m_Rot.y, vec3(0.0f, 1.0f, 0.0f));
mModel = glm::rotate(mModel, m_Rot.z, vec3(0.0f, 0.0f, 1.0f));
static GLint m4ModelViewProjLoc = pShaderManager->getUniformLocation("uModelViewProj");
mModelViewProj = pData->ViewProj * mModel;
pShaderManager->setUniformMatrix4fv(m4ModelViewProjLoc, 1, &mModelViewProj);
static GLint uTexLoc = pShaderManager->getUniformLocation("uTex");
pShaderManager->setUniform1i(uTexLoc, 0);
glActiveTexture(GL_TEXTURE0);
mp_Tex->bind();
}
void GLES_GPU::CopyDisplayToOutput()
{
if (!g_Config.bBufferedRendering)
return;
VirtualFramebuffer *vfb = GetDisplayFBO();
fbo_unbind();
glViewport(0, 0, PSP_CoreParameter().pixelWidth, PSP_CoreParameter().pixelHeight);
currentRenderVfb_ = 0;
if (!vfb) {
DEBUG_LOG(HLE, "Found no FBO! displayFBPtr = %08x", displayFramebufPtr_);
// No framebuffer to display! Clear to black.
glClearColor(0,0,0,1);
glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
return;
}
DEBUG_LOG(HLE, "Displaying FBO %08x", vfb->fb_address);
glDisable(GL_BLEND);
glDisable(GL_CULL_FACE);
glDisable(GL_DEPTH_TEST);
fbo_bind_color_as_texture(vfb->fbo, 0);
// These are in the output pixel coordinates
DrawActiveTexture(480, 272, true);
shaderManager.DirtyShader();
shaderManager.DirtyUniform(DIRTY_ALL);
gstate_c.textureChanged = true;
// Restore some state
ExecuteOp(gstate.cmdmem[GE_CMD_ALPHABLENDENABLE], 0xFFFFFFFF);
ExecuteOp(gstate.cmdmem[GE_CMD_CULLFACEENABLE], 0xFFFFFFFF);
ExecuteOp(gstate.cmdmem[GE_CMD_ZTESTENABLE], 0xFFFFFFFF);
}
void render()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glUseProgram(sm.getDefaultShader());
glBindVertexArray(vao);
glDrawArrays(GL_TRIANGLES, 0, 3);
//glDisableVertexAttribArray(0);
glFlush();
}
void C2DPrimitiveRenderer_GL::RenderRect( ShaderManager& rShaderManager, C2DRect& rect )
{
rShaderManager.Begin();
// glUseProgram( 0 );
glDisable( GL_CULL_FACE );
// ushort triangle_fan[] = {0,1,2,3};
// GLsizei num_indices = 4;
// RenderViaVertexAttribArray( &(rect.GetVertex(0)), 4, triangle_fan, num_indices, GL_TRIANGLE_FAN );
RenderViaVertexAttribArray( &(rect.GetVertex(0)), 4, NULL, 0, GL_TRIANGLE_FAN );
}
static void SetOffsetWorldTransform( ShaderManager& rShaderManager, Vector3& vWorldCameraPos )
{
Matrix44 matWorld, matView;
rShaderManager.GetWorldTransform( matWorld );
rShaderManager.GetViewTransform( matView );
s_OrigWorldPos = Vector3( matWorld(0,3), matWorld(1,3), matWorld(2,3) );
s_OrigViewTrans = Vector3( matView(0,3), matView(1,3), matView(2,3) );
// if( !pCamera )
// return;
matView(0,3) = matView(1,3) = matView(2,3) = 0;
Vector3 cam_pos = vWorldCameraPos;//pCamera->GetPosition();
matWorld(0,3) = s_OrigWorldPos.x - cam_pos.x;
matWorld(1,3) = s_OrigWorldPos.y - cam_pos.y;
matWorld(2,3) = s_OrigWorldPos.z - cam_pos.z;
// MsgBoxFmt( "world pos offset: ( %f, %f, %f )", matWorld._41, matWorld._42, matWorld._43 );
rShaderManager.SetWorldTransform( matWorld );
rShaderManager.SetViewTransform( matView );
}
vector<Shader> parseShaders(YAML::Node const *node, vector<Shader> &defaultShaders, string const &directory, ShaderManager &shaderRes)
{
if(node == 0)
return defaultShaders;
vector<Shader> shaders;
for(YAML::Iterator it = node->begin(); it != node->end(); ++it)
{
string shaderFile;
(*it)["file"] >> shaderFile;
shaders.push_back(shaderRes.request(directory + shaderFile));
}
return shaders;
}
