void CRectangleSymbol::configure()
{
m_vertices[0].vertex = glm::vec2(m_size.x, m_size.y);
m_vertices[1].vertex = glm::vec2(m_size.x + m_size.z, m_size.y);
m_vertices[2].vertex = glm::vec2(m_size.x + m_size.z, m_size.y + m_size.w);
m_vertices[3].vertex = glm::vec2(m_size.x, m_size.y + m_size.w);
m_vertices[0].uv = glm::vec2(0.0f, 1.0f - 0.0f);
m_vertices[1].uv = glm::vec2(1.0f, 1.0f - 0.0f);
m_vertices[2].uv = glm::vec2(1.0f, 1.0f - 1.0f);
m_vertices[3].uv = glm::vec2(0.0f, 1.0f - 1.0f);
CShader *shader = CShaderFactory::getInstance()->getShader("text");
if (shader) {
m_vao.genBuffer();
m_vao.bind();
m_vertexVBO.genBuffer();
m_vertexVBO.setData(&m_vertices);
shader->setAttribute("a_position", 2, 0, sizeof(CVertex2D));
shader->setAttribute("a_uv", 2, 8, sizeof(CVertex2D));
// shader->setAttribute("a_color", 3, 16, sizeof(CVertex2D));
m_vao.disable();
}
}
IShader *WINAPI QERApp_Shader_ForName (const char *name)
{
if (name == NULL || strlen (name) == 0)
{
// Hydra: This error can occur if the user loaded a map with/dropped an entity that
// did not set a texture name "(r g b)" - check the entity definition loader
g_FuncTable.m_pfnSysFPrintf (SYS_ERR, "FIXME: name == NULL || strlen(name) == 0 in QERApp_Shader_ForName\n");
return QERApp_Shader_ForName (SHADER_NOT_FOUND);
}
// entities that should be represented with plain colors instead of textures
// request a texture name with (r g b) (it's stored in their class_t)
if (name[0] == '(')
{
return QERApp_ColorShader_ForName (name);
}
CShader *pShader = static_cast < CShader * >(QERApp_Try_Shader_ForName (name));
if (pShader)
{
pShader->SetDisplayed (true);
return pShader;
}
return QERApp_CreateShader_ForTextureName (name);
}
void CScene::BuildObjects(ID3D11Device *pd3dDevice)
{
CShader *pShader = new CShader();
pShader->CreateShader(pd3dDevice);
m_nObjects = 51;
m_ppObjects = new CGameObject*[m_nObjects];
//가로x세로x높이가 15x15x15인 정육면체 메쉬를 생성한다.
CCubeMesh *pMesh = new CCubeMesh(pd3dDevice, 50.0f, 50.0f, 50.0f); // random color cube draw
CRotatingObject *pObject = new CRotatingObject();
//pObject->SetPosition(0, 0, 0);
pObject->SetMesh(pMesh);
pObject->SetShader(pShader);
m_ppObjects[0] = pObject;
for (int i = 1; i <= 50; ++i)
{
CCubeMesh *pMesh = new CCubeMesh(pd3dDevice, 5.0f, 5.0f, 5.0f); // random color cube draw
CRotatingObject *pObject = new CRotatingObject();
pObject->SetPosition(-10.0f, 0, 0);
pObject->SetMovingDirection(D3DXVECTOR3(float(rand() % 10) / 100.f, float(rand() % 10) / 100.f, float(rand() % 10) / 100.f));
pObject->SetMovingSpeed(0.03f);
pObject->SetMesh(pMesh);
pObject->SetShader(pShader);
m_ppObjects[i] = pObject;
}
}
GfxContext::GfxContext()
: m_TriangleProgram(nullptr)
{
// TODO: Shouldn't be done in here! Move to client's code!
auto cubeGeom = LoadGeometryFromObj("resources\\cube.obj", "cube");
auto cube = shared_ptr<SceneObject>(new SceneObject());
auto cube2 = shared_ptr<SceneObject>(new SceneObject());
cube->Attributes.Geometry = cubeGeom;
cube2->Attributes.Geometry = cubeGeom;
cube2->Move(float3(0.0f, 3.0f, 0.0f));
m_Scene.Add(cube);
m_Scene.Add(cube2);
CShader* fShader = new CShader(GL_FRAGMENT_SHADER, "resources/shaders/mvp.frag");
CShader* vShader = new CShader(GL_VERTEX_SHADER, "resources/shaders/mvp.vert");
fShader->Compile();
vShader->Compile();
m_TriangleProgram = new CProgram();
m_TriangleProgram->Attach(fShader);
m_TriangleProgram->Attach(vShader);
m_TriangleProgram->Link();
m_Textures["grass"] = LoadTextureDDS("resources/textures/test-rgb8-256b.dds");
glEnable(GL_DEPTH_TEST);
}
int WINAPI QERApp_LoadShadersFromDir (const char *path)
{
int count = 0;
// scan g_Shaders, and call QERApp_Shader_ForName for each in the given path
// this will load the texture if needed and will set it in use..
int nSize = g_Shaders.GetSize ();
for (int i = 0; i < nSize; i++)
{
CShader *pShader = reinterpret_cast < CShader * >(g_Shaders[i]);
if (strstr (pShader->getShaderFileName (), path) || strstr (pShader->getName (), path))
{
count++;
// request the shader, this will load the texture if needed and set "inuse"
//++timo FIXME: should we put an Activate member on CShader?
// this QERApp_Shader_ForName call is a kind of hack
IShader *pFoo = QERApp_Shader_ForName (pShader->getName ());
#ifdef _DEBUG
// check we activated the right shader
// NOTE: if there was something else loaded, the size of g_Shaders may have changed and strange behaviours are to be expected
if (pFoo != pShader)
Sys_Printf ("WARNING: unexpected pFoo != pShader in QERApp_LoadShadersFromDir\n");
#else
pFoo = NULL; // leo: shut up the compiler
#endif
}
}
return count;
}
HRESULT CShaderManager::CreateShader(const SHADER_TYPE& eShader, const LPCTSTR pFileName)
{
CShader* pShader = FindShader(eShader);
if(pShader)
{
return S_OK;
}
switch(eShader)
{
case SHADER_DEFAULT:
pShader = new CDefaultShader;
break;
default:
break;
}
if(FAILED(pShader->Init(pFileName)))
{
return E_FAIL;
}
m_mapShader.insert(map<SHADER_TYPE, CShader*>::value_type(eShader, pShader));
return S_OK;
}
CShader* CCacheResourceManager::LoadShader(const std::string& name)
{
if(shaderResources.find(name) != shaderResources.end())
{
#ifdef DEBUG
std::cerr<<"CCacheResourceManager: [INFO] "<< name<<" loaded from cache.\n";
#endif
return shaderResources.find(name)->second;
}
CShader* ptr = new CShader();
string vshader = name;
string pshader = name;
StringManipulator::AddCharArrayToString(vshader, ".vsh");
StringManipulator::AddCharArrayToString(pshader, ".fsh");
if(!ptr->LoadShadersFromMemory(getContentFromPath(getPath(vshader)).c_str(),
getContentFromPath(getPath(pshader)).c_str()))
{
std::cerr<< "CCacheResourceManager: [ERROR] failed to load shader: "<< name << "...<\n";
delete ptr;
return NULL;
}
shaderResources[name] = ptr;
#ifdef DEBUG
std::cerr<< "CCacheResourceManager: [SUCCESS] "<<name <<" shader loaded...\n";
#endif
return ptr;
}
//---------------------------------------------------------------
// Purpose:
//---------------------------------------------------------------
void CEntityTypeLight::Render( void )
{
BaseClass::Render();
if( IsSelected() )
{
CBaseGeometry *geom = GetRenderInterfaces()->GetRendererInterf()->GetLightList()->GetUnitSphere();
CPointLight *light = GetRenderInterfaces()->GetRendererInterf()->GetLightList()->GetPointLight(m_lightIndex);
//calculate light geometry scales
float fMaxDist = light->GetDist();
geom->SetScale(fMaxDist);
geom->SetAbsPos(GetAbsCenter());
geom->SetAbsAngles(GetAbsAngles());
CShader *pShd = GetShaderManager()->GetActiveShader();
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
GetGLStateSaver()->Disable(GL_CULL_FACE);
pShd->EnableTexturing(false);
pShd->SetDrawColor(1, 1, 0, 1);
geom->RenderNoTextureBufferOnly(false);
pShd->SetDrawColor(1, 1, 1, 1);
GetGLStateSaver()->Enable(GL_CULL_FACE);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
}
}
IShader *WINAPI QERApp_ColorShader_ForName( const char *name ){
CShader *pShader = new CShader();
pShader->CreateColor( name );
// hook it into the shader list
pShader->IncRef();
g_Shaders.Add( (void *) pShader );
return pShader;
}
bool CScene::RenderShadow()
{
std::list<axelynx::Camera *>::const_iterator ci = camlist.begin();
std::list<axelynx::Camera *>::const_iterator ei = camlist.end();
CShadowPass::SetShadowShader(defShader_);
CShadowPass::StartPass();
for(;ci!=ei;++ci)
{
if((*ci)->isEnabled())
{
frame_++;
(*ci)->Bind(zpassed?-1:0);
CMaterial::Free(); //материал зависит от камеры
if(zpassed)
{
CEarlyZ::StartRenderPass();
}
else
{
glDepthFunc(GL_LESS);
glDepthMask(GL_TRUE);
}
for(int i=0;i<256;++i)
{
if(visible_groups_[i])
scenegraph_[i]->Render(*ci);
}
(*ci)->UnBind();
CMaterial::Free(); //материал зависит от камеры
}
}
CShader *cs = CShader::Current();
if(cs)
cs->UnBind();
for(int i=0;i<16;++i)
{
CTexture *ct = CTexture::Current(i);
if(ct)
ct->UnBind();
}
if(zpassed)
CEarlyZ::EndRenderPass();
zpassed = false;
glDisable(GL_DEPTH_TEST);
glDisable(GL_CULL_FACE);
glDepthMask(GL_TRUE);
CShadowPass::EndPass();
return true;
}
ERRCODE CRenderer::ProcessBufferQueue()
{
if(!queueMeshes->empty()) //В очереди ждет один или более мешей
{
//Пишем буферы меша (RAM) в видеопамять
PAIR_UINT pair = vbContainer->Write(queueMeshes->front()->GetBuffer(BUFFER_V)->GetType(),
queueMeshes->front()->GetBuffer(BUFFER_V)->GetSize(),
queueMeshes->front()->GetBuffer(BUFFER_V)->GetBuffer());
PAIR_UINT indpair = vbContainer->Write(queueMeshes->front()->GetBuffer(BUFFER_I)->GetType(),
queueMeshes->front()->GetBuffer(BUFFER_I)->GetSize(),
queueMeshes->front()->GetBuffer(BUFFER_I)->GetBuffer());
//Записываем координаты данных в видеопамяти
queueMeshes->front()->SetBufferCoords(BUFFER_V, pair.x, pair.y, queueMeshes->front()->GetBuffer(BUFFER_V)->GetSize());
queueMeshes->front()->SetBufferCoords(BUFFER_I, indpair.x, indpair.y, queueMeshes->front()->GetBuffer(BUFFER_I)->GetSize());
//Меш готов для рендера, записываем ссылку на него в массив мешей
CMesh* msh = queueMeshes->front();
queueMeshes->pop();
vecMeshes->push_back(msh);
//Удаляем указатель на меш из очереди
char* str = new char[50];
sprintf(str, "Written vertex data into VBO\n");
Log(str);
delete [] str;
}
if(!queueTextures2D->empty())
{
//TODO: Сохранить текстуру в опенгл и отдать CTexture2D хендл(ID) на сохраненную текстуру
CTexture2D* tex2D = queueTextures2D->front();
GLuint iT;
glGenTextures(1, &iT);
glBindTexture(GL_TEXTURE_2D, iT);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, tex2D->GetWidth(), tex2D->GetHeight(), 0, GL_RGB, GL_UNSIGNED_BYTE, tex2D->GetPixels());
glBindTexture(GL_TEXTURE_2D, 0);
tex2D->SetTexture2Did(iT);
queueTextures2D->pop();
vecTextures2D->push_back(tex2D);
}
if(!queueShaders->empty())
{
CShader* shader = queueShaders->front();
//TODO: Компилируем шейдер, отправляем ID в CShader
shader->Compile();
queueShaders->pop();
vecShaders->push_back(shader);
Log("Compiled shader program.\n");
}
return ERR_OK;
}
// NOTE: case sensitivity
// although we store shader names with case information, Radiant does case insensitive searches
// (we assume there's no case conflict with the names)
CShader* CShaderArray::Shader_ForName( const char * name) const
{
int i;
for ( i = 0; i < CPtrArray::GetSize(); i++ )
{
CShader *pShader = static_cast<CShader*>(CPtrArray::GetAt(i));
if (_stricmp(pShader->getName(), name) == 0)
return pShader;
}
return NULL;
}
void CRenderer::ProcessNode(CNode* node)
{
std::vector<CNode*> *vec = node->GetNodeVector();
//Обновляем нод, рендерим сущности
//Log("Node is updated\n");
glTranslatef(node->GetPosX(), node->GetPosY(), node->GetPosZ());
for(int i = 0; i < node->GetObjVector()->size(); i++)
{
if(node->GetObjVector()->at(i)->GetType()==OBJECT_ENTITY)
{
//TO DO:
//Берем шейдер, соотвутствующий сущности и активируем его
//-----
CMaterial* mat;
CShader* sh;
if((mat = ((CEntity*)node->GetObjVector()->at(i))->GetMaterial())!=0)
{
if((sh = mat->GetShader())!=0)
{
if(sh->IsCompiled())
{
glUseProgram(sh->GetProgramId());
}
}
}
DrawMesh(((CEntity*)node->GetObjVector()->at(i))->GetMesh());
glUseProgram(0);
}
}
glDisable(GL_DEPTH_TEST);
glBegin(GL_LINES);
glColor3f(0.5, 1, 0.5);
glVertex3f(0, 0, 0);
glVertex3f(0, 1, 0);
glColor3f(1, 0.5, 0.5);
glVertex3f(0, 0, 0);
glVertex3f(1, 0, 0);
glColor3f(0.5, 0.5, 1);
glVertex3f(0, 0, 0);
glVertex3f(0, 0, 1);
glColor3f(1,1,1);
glEnd();
glEnable(GL_DEPTH_TEST);
for(int i = 0; i < vec->size(); i++)
{
ProcessNode(vec->at(i));
}
glTranslatef(-node->GetPosX(), -node->GetPosY(), -node->GetPosZ());
}
IShader* WINAPI QERApp_Try_Shader_ForName(const char* name)
{
// look for the shader
CShader* pShader = g_Shaders.Shader_ForName( name );
if (!pShader)
// not found
return NULL;
// we may need to load the texture or use the "shader without texture" one
pShader->Activate();
pShader->SetDisplayed( true );
return pShader;
}
// 深度优先递归遍历目录中所有的文件
BOOL DirectoryList(LPCSTR Path, int nRenderType)
{
WIN32_FIND_DATA FindData;
HANDLE hError;
int FileCount = 0;
char FilePathName[LEN];
// 构造路径
char FullPathName[LEN];
strcpy(FilePathName, Path);
strcat(FilePathName, "\\*.*");
hError = FindFirstFile(FilePathName, &FindData);
if (hError == INVALID_HANDLE_VALUE)
{
return 0;
}
while(::FindNextFile(hError, &FindData))
{
// 过虑.和..
if (strcmp(FindData.cFileName, ".") == 0
|| strcmp(FindData.cFileName, "..") == 0 )
{
continue;
}
// 构造完整路径
wsprintf(FullPathName, "%s\\%s", Path,FindData.cFileName);
FileCount++;
// 输出本级的文件
//printf("\n%d %s ", FileCount, FullPathName);
char szName[255];
strcpy(szName,FindData.cFileName);
int nLen = strlen(szName);
if (nLen>3 && strcmp(szName+nLen-3,".fx")==0)
{
szName[nLen-3]=0;
CShader* pShader = CRenderSystem::getSingleton().registerShader(szName,FullPathName);
if (pShader)
{
pShader->setRenderType(nRenderType);
}
}
// if (FindData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
// {
// printf("<Dir>");
// DirectoryList(FullPathName);
// }
}
return 0;
}
void CSDLOpenGLWindow::ReleaseScene()
{
for (int i = 0; i < 4; i++)
tTextures[i].DeleteTexture();
spDirectionalLight.DeleteProgram();
shFragment.DeleteShader();
shVertex.DeleteShader();
glDeleteVertexArrays(1, uiVAOs);
vboSceneObjects.DeleteVBO();
}
DLLEXPORT CShader* CRenderer::CreateShaderFromFile(char* path)
{
CShader* shader = new CShader();
Log("Creating shader from \""); Log(path); Log("\"\n");
GLchar* text = new GLchar[256];
strcpy(text, "void main(){ gl_FragColor = vec4(0.4,0.0,0.1,1.0); }");
shader->WritePixelShader(strlen(text), text);
delete text;
queueShaders->push(shader);
return shader;
}
void CSDLOpenGLWindow::ReleaseScene()
{
spTextured.DeleteProgram();
spColored.DeleteProgram();
shFragmentTex.DeleteShader();
shFragmentCol.DeleteShader();
shVertexTex.DeleteShader();
shVertexCol.DeleteShader();
glDeleteVertexArrays(2, uiVAOs);
vboSceneObjects.DeleteVBO();
tBox.DeleteTexture();
tBlueIce.DeleteTexture();
}
/**********************
* void BasicAS::setGPUParameters( CShader& l_Shader )
*
* sets shader parameters for the BasicAS
***********************/
void BasicAS::setGPUParameters( CShader& l_Shader, GPUAccelerationStructureData& l_ASD )
{
#ifndef STUB
CGparameter& cell_info = l_Shader.GetNamedParameter("cellData0", true);
cgGLSetTextureParameter(cell_info, l_ASD.m_CellTexture[0]);
CGparameter& v0 = l_Shader.GetNamedParameter("v0t", true);
cgGLSetTextureParameter(v0, l_ASD.m_VertexTexture[0]);
CGparameter& v1 = l_Shader.GetNamedParameter("v1t", true);
cgGLSetTextureParameter(v1, l_ASD.m_VertexTexture[1]);
CGparameter& v2 = l_Shader.GetNamedParameter("v2t", true);
cgGLSetTextureParameter(v2, l_ASD.m_VertexTexture[2]);
#endif
}
void RenderScene()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Clear The Screen And The Depth Buffer
glLoadIdentity(); // Reset The matrix
/////// * /////////// * /////////// * NEW * /////// * /////////// * /////////// * ///////
// In our RenderScene() function we will now start using the shader. We added support
// to create quadrics so we don't have to load any models, which makes the tutorials easy.
// What we do is create a sphere and then have our shader make it wave. When we loaded
// the shader files it turned ON the shader, so we don't need to turn it on every frame.
// Notice that we pass in our g_TimeLoc variable that we got in the Init() function above
// to change the "time" variable in the vertex shader. We also pass in a new waveChange
// value to vary the wave.
// Create a static float to hold our current wave value, then update and change it each frame.
static float waveChange = 0.0f;
g_Shader.SetFloat(g_TimeLoc, waveChange);
waveChange += 0.06f;
GLUquadricObj *pObj = gluNewQuadric(); // Get a Quadric off the stack
gluQuadricDrawStyle(pObj, GLU_LINE); // Draw the sphere in wireframe
glTranslatef(0.0f, 0.0f, -6.5f); // Move the sphere backwards from the camera
gluSphere(pObj, 2.5f, 75, 75); // Draw a decent poly sphere with a radius of 2.5
gluDeleteQuadric(pObj); // Free the Quadric
/////// * /////////// * /////////// * NEW * /////// * /////////// * /////////// * ///////
SwapBuffers(g_hDC); // Swap the backbuffers to the foreground
}
CShader* CShaderArray::Shader_ForTextureName( const char * name) const
{
#ifdef _DEBUG
// check we were given a texture name that fits the qtexture_t naming conventions
if (strcmp( name, CleanTextureName( name ) ) != 0)
Sys_Printf("WARNING: texture name %s doesn't fit qtexture_t conventions in CShaderArray::Shader_ForTextureName\n", name);
#endif
int i;
for ( i = 0; i < CPtrArray::GetSize(); i++ )
{
CShader *pShader = static_cast<CShader*>(CPtrArray::GetAt(i));
if (strcmp( name, CleanTextureName( pShader->getTextureName() ) ) == 0)
return pShader;
}
return NULL;
}
// -----------------------------------------------------
void CGraphicsRenderer::RenderScene()
{
// render scene to diffuse RT
CRenderer::cGraphicsDevice()->BeginRendering(1, m_mrt_diffuse);
//CRenderer::cGraphicsDevice()->Clear(ColorRGB(0,1,1));
for (unsigned int i=0; i<m_chunks.Size(); i++)
{
const GeometryChunk& chunk = m_chunks[i];
CIndexBuffer* ib = CRenderer::cGraphicsManager()->GetCachedIndexBuffer(chunk.Data->ibId);
CVertexBuffer* vb = CRenderer::cGraphicsManager()->GetCachedVertexBuffer(chunk.Data->vbId);
ib->Use();
vb->Use();
// OPTIM: if we ensure valid pointer every time, remove this if-s
if (chunk.Subset->materialPtr)
{
CShader *vs = (CShader*)chunk.Subset->materialPtr->vsPtr;
CShader *ps = (CShader*)chunk.Subset->materialPtr->psPtr;
if (ps)
ps->Use();
if (vs)
{
vs->Use();
}
}
vb->RenderIndexed(P3DPT_TRIANGLELIST, chunk.Subset->StartIndex, chunk.Subset->NumTriangles);
}
CRenderer::cGraphicsDevice()->EndRendering();
// render diffuse RT on standard backbuffer
CRenderer::cGraphicsDevice()->BeginRendering();
CRenderer::cPrimitiveRenderer()->AddRectangleRel(Vec2(0.0f, 0.0f), Vec2(1.0f, -1.0f), ColorRGBA(1.0f, 1.0f, 1.0f, 1.0f), m_mrt_diffuse);
CRenderer::cPrimitiveRenderer()->Render();
CRenderer::cGraphicsDevice()->EndRendering();
}
Void CWidgetCanvas::Render(CRenderer& renderer, CShader& shader)
{
CGuiRenderPass& uiPass = *renderer.GetGuiRenderPass();
if( m_NinePatch )
{
shader.GetParameter("UseTexture")->SetValue( (Bool) TRUE );
// shader.GetParameter("Texture")->SetValue( *m_NinePatch );
}
else
{
shader.GetParameter("UseTexture")->SetValue( (Bool) FALSE );
}
const CColor& col = m_Color;
uiPass.DrawQuad(shader, GetRect(), col);
CWidget::Render(renderer, shader);
}
// -----------------------------------------------------
void CGraphicsRenderer::RenderScene(sFrameBufferUnit *FBUnits, UINT numUnits)
{
if(FBUnits != NULL)
{
//TODO: setup the appropriate render targets
CRenderer::cGraphicsDevice()->BeginRendering(1, m_mrt_diffuse);
//CRenderer::cGraphicsDevice()->Clear(ColorRGB(0,1,1));
}
else CRenderer::cGraphicsDevice()->BeginRendering(); //render to back buffer
for (unsigned int i=0; i<m_chunks.Size(); i++)
{
const GeometryChunk& chunk = m_chunks[i];
CIndexBuffer* ib = CRenderer::cGraphicsManager()->GetCachedIndexBuffer(chunk.Data->ibId);
CVertexBuffer* vb = CRenderer::cGraphicsManager()->GetCachedVertexBuffer(chunk.Data->vbId);
ib->Use();
vb->Use();
// OPTIM: if we ensure valid pointer every time, remove this if-s
if (chunk.Subset->materialPtr)
{
CShader *vs = (CShader*)chunk.Subset->materialPtr->vsPtr;
CShader *ps = (CShader*)chunk.Subset->materialPtr->psPtr;
if (ps)
ps->Use();
if (vs)
{
vs->Use();
}
}
vb->RenderIndexed(P3DPT_TRIANGLELIST, chunk.Subset->StartIndex, chunk.Subset->NumTriangles);
}
CRenderer::cGraphicsDevice()->EndRendering();
}
Void CScreenQuad::Render( CRenderer& renderer, const CVector2f& pos, const CVector2f& size, CShader& shader )
{
DebugGraphicCommandGroup( "CScreenQuad::Render" );
CShaderParameter* p;
p = shader.GetParameter( "Size" );
if( p )
p->SetValue( CShaderParameterData( size ) );
p = shader.GetParameter( "Position" );
if( p )
p->SetValue( CShaderParameterData( pos ) );
renderer.Activate( m_VertexBuffer, 0 );
renderer.Activate( m_VertexLayout );
renderer.Activate( m_IndexBuffer );
renderer.Activate( shader );
GraphicsManager.GetImpl().DrawIndexed( nPrimitiveType_TriangleList, 6, 0, 0 );
}
IShader* WINAPI QERApp_Shader_ForName(const char* name)
{
//++timo FIXME: do we allow NULL and "" calling?
// how does it deal with notexture? can we simply replace by "textures/radiant/notex"?
if (name == NULL || strlen(name) == 0)
{
Sys_Printf("FIXME: name == NULL || strlen(name) == 0 in QERApp_Shader_ForName\n");
return QERApp_Shader_ForName("radiant/notex"); //++timo ???
}
// entities that should be represented with plain colors instead of textures
// request a texture name with (r g b) (it's stored in their class_t)
if (name[0]=='(')
{
return QERApp_ColorShader_ForName(name);
}
CShader* pShader = static_cast<CShader*>(QERApp_Try_Shader_ForName( name ));
if (pShader)
{
pShader->SetDisplayed( true );
return pShader;
}
// we don't know this shader, maybe it's a straight texture
pShader = new CShader;
pShader->CreateDefault( name );
// hook it into the shader list
g_Shaders.Add( (LPVOID)pShader );
pShader->IncRef();
// if it can't find the texture, "textures/radiant/notex" will be used
pShader->Activate();
pShader->SetDisplayed( true );
return pShader;
}
bool CScene::ZPassRender()
{
std::list<axelynx::Camera *>::const_iterator ci = camlist.begin();
std::list<axelynx::Camera *>::const_iterator ei = camlist.end();
CEarlyZ::StartEarlyZPass();
for(;ci!=ei;++ci)
{
if((*ci)->isEnabled())
{
frame_++;
(*ci)->Bind();
CMaterial::Free(); //материал зависит от камеры
OPENGL_CHECK_FOR_ERRORS();
for(int i=0;i<256;++i)
{
if(visible_groups_[i])
scenegraph_[i]->Render(*ci);
}
(*ci)->UnBind();
CMaterial::Free(); //материал зависит от камеры
}
}
CShader *cs = CShader::Current();
if(cs)
cs->UnBind();
for(int i=0;i<16;++i)
{
CTexture *ct = CTexture::Current(i);
if(ct)
ct->UnBind();
}
CEarlyZ::EndEarlyZPass();
zpassed = true;
return true;
}
void CWin32Renderer::draw(CRenderable* pRenderable)
{
if (pRenderable && pRenderable->canBeRendered())
{
const GLuint vboId = (GLuint)pRenderable->get1DParam(VBO0_ID);
const GLuint iboId = (GLuint)pRenderable->get1DParam(IBO0_ID);
if (vboId && iboId)
{
glBindBuffer(GL_ARRAY_BUFFER, vboId);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, iboId);
///@todo: implement in renderable, add the argument that defines the environment
pRenderable->setEnvironment(); // Renderable-specific changes of the OpenGL environment: switch depth on/off etc.
CGeometry* pGeometry = pRenderable->getGeometry();
CShader* pShader = pRenderable->getShader();
if (pGeometry && pShader)
{
pShader->setup(*pRenderable);
if (mIsDebugMode && pRenderable->getFlag(eShaderFlags::DRAW_LINES))
{
glLineWidth(pRenderable->get1DParam(eShader1DParams::LINE_WIDTH));
glDrawElements(GL_LINES, pGeometry->getNumOfIndices(), GL_UNSIGNED_INT, 0);
}
else
{
glDrawElements(GL_TRIANGLE_STRIP, pGeometry->getNumOfIndices(), GL_UNSIGNED_INT, 0);
}
}
// Return to the initial OpenGL state.
pRenderable->resetEnvironment();
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glBindTexture(GL_TEXTURE_2D, 0);
}
}
}
void Init(HWND hWnd)
{
g_hWnd = hWnd; // Assign the window handle to a global window handle
GetClientRect(g_hWnd, &g_rRect); // Assign the windows rectangle to a global RECT
InitializeOpenGL(g_rRect.right, g_rRect.bottom); // Init OpenGL with the global rect
/////// * /////////// * /////////// * NEW * /////// * /////////// * /////////// *
// Let's init our GLSL functions and make sure this computer can run the program.
InitGLSL();
// Here we pass in our vertex and fragment shader files to our shader object.
g_Shader.InitShaders("morph.vert", "morph.frag");
// Now we want to get the variable "time" in the morph.vert file so we can update it.
g_TimeLoc = g_Shader.GetVariable("time");
/////// * /////////// * /////////// * NEW * /////// * /////////// * /////////// *
}
void CNormalGenerator::SetNormalTexture(size_t iMaterial)
{
// Materials not loaded yet?
if (iMaterial >= SMAKWindow()->GetMaterials().size())
return;
CMaterialHandle hMaterial = SMAKWindow()->GetMaterials()[iMaterial];
CShader* pShader = CShaderLibrary::GetShader(hMaterial->m_sShader);
size_t iDiffuse = pShader->FindTextureByUniform("iDiffuse");
if (iDiffuse >= hMaterial->m_ahTextures.size())
return;
CTextureHandle hDiffuseTexture = hMaterial->m_ahTextures[iDiffuse];
if (!hDiffuseTexture.IsValid())
return;
m_iMaterial = iMaterial;
// Don't let the listeners know yet, we want to generate the new one first so there is no lapse in displaying.
// m_bNewNormal2Available = true;
m_avecTextureTexels.resize(hDiffuseTexture->m_iWidth*hDiffuseTexture->m_iHeight);
CRenderer::ReadTextureFromGL(hDiffuseTexture, m_avecTextureTexels.data());
m_iNormal2Width = hDiffuseTexture->m_iWidth;
m_iNormal2Height = hDiffuseTexture->m_iHeight;
m_aflLowPassTexels.resize(hDiffuseTexture->m_iWidth*hDiffuseTexture->m_iHeight);
m_aflMidPassTexels.resize(hDiffuseTexture->m_iWidth*hDiffuseTexture->m_iHeight);
m_avecNormal2Texels.resize(hDiffuseTexture->m_iWidth*hDiffuseTexture->m_iHeight);
Setup();
UpdateNormal2();
}
