ShaderProgram::ShaderProgram(std::string vertexshader,std::string fragmentshader)
{
// Initially, we have zero shaders attached to the program
m_shadercount = 0;
m_shaderProgramHandle = glCreateProgram();
//set up shaders
Shader vertexShader(GL_VERTEX_SHADER);
vertexShader.loadFromFile(SHADERS_PATH + vertexshader);
vertexShader.compile();
Shader fragmentShader(GL_FRAGMENT_SHADER);
fragmentShader.loadFromFile(SHADERS_PATH + fragmentshader);
fragmentShader.compile();
//set up shaderprogram
attachShader(vertexShader);
attachShader(fragmentShader);
link();
}
bool GLProgram::load(InputStream* input)
{
Z_LOG("Loading OpenGL program \"" << input->name() << "\".");
std::vector<std::string> vertex;
std::vector<std::string> fragment;
bool success = parseProgramSource(input, vertex, fragment);
GLShader vertexShader(GL::VERTEX_SHADER);
vertexShader.setSource(vertex);
success = vertexShader.compile() && success;
gl::AttachShader(m_Handle, vertexShader.handle());
GLShader fragmentShader(GL::FRAGMENT_SHADER);
fragmentShader.setSource(fragment);
success = fragmentShader.compile() && success;
gl::AttachShader(m_Handle, fragmentShader.handle());
bindAttribLocations();
return success && link() && enumerateStandardUniforms();
}
ShearEffect ShearEffect::New()
{
// append the default version
std::string vertexShader(
"uniform mediump vec2 uCenter;\n"
"uniform mediump float uAngleXAxis;\n"
"uniform mediump float uAngleYAxis;\n"
"\n"
"void main()\n"
"{\n"
"mediump vec4 world = uModelView * vec4(aPosition,1.0);\n"
"\n"
"world.x = world.x + tan(radians(uAngleXAxis)) * (world.y - uCenter.y * world.w);\n"
"world.y = world.y + tan(radians(uAngleYAxis)) * (world.x - uCenter.x * world.w);\n"
"\n"
"gl_Position = uProjection * world;\n"
"\n"
"vTexCoord = aTexCoord;\n"
"}" );
// Create the implementation, temporarily owned on stack,
ShaderEffect shaderEffectCustom = Dali::ShaderEffect::New(
vertexShader,
"",
GeometryType( GEOMETRY_TYPE_IMAGE | GEOMETRY_TYPE_TEXT ),
GeometryHints( HINT_GRID ));
// Pass ownership to ShearEffect through overloaded constructor, So that it now has access to the
// Dali::ShaderEffect implementation
Dali::Toolkit::ShearEffect handle( shaderEffectCustom );
handle.SetUniform( CENTER_PROPERTY_NAME, Vector2(0.0f, 0.0f), COORDINATE_TYPE_VIEWPORT_POSITION );
handle.SetUniform( ANGLE_X_AXIS_PROPERTY_NAME, 0.0f);
handle.SetUniform( ANGLE_Y_AXIS_PROPERTY_NAME, 0.0f);
return handle;
}
GLuint CompileShaders(const GLchar** vertexShaderSource, const GLchar** fragmentShaderSource )
{
//Compile vertex shader
GLuint vertexShader( glCreateShader( GL_VERTEX_SHADER ) );
glShaderSource( vertexShader, 1, vertexShaderSource, NULL );
glCompileShader( vertexShader );
//Compile fragment shader
GLuint fragmentShader( glCreateShader( GL_FRAGMENT_SHADER ) );
glShaderSource( fragmentShader, 1, fragmentShaderSource, NULL );
glCompileShader( fragmentShader );
//Link vertex and fragment shader together
GLuint program( glCreateProgram() );
glAttachShader( program, vertexShader );
glAttachShader( program, fragmentShader );
glLinkProgram( program );
//Delete shaders objects
glDeleteShader( vertexShader );
glDeleteShader( fragmentShader );
return program;
}
void canAssignProgram()
{
ShaderProgram shaderProgram;
Shader fragmentShader(Shader::FRAGMENT_SHADER);
fragmentShader.compile(VALID_FRAGMENT_SHADER_SOURCE);
shaderProgram.attach(fragmentShader);
Shader vertexShader(Shader::VERTEX_SHADER);
vertexShader.compile(VALID_VERTEX_SHADER_SOURCE);
shaderProgram.attach(vertexShader);
ShaderProgram copy;
Shader anotherShader(Shader::VERTEX_SHADER);
copy.attach(anotherShader);
QVERIFY(copy.has(anotherShader));
copy = shaderProgram;
QVERIFY(copy.has(fragmentShader));
QVERIFY(copy.has(vertexShader));
QVERIFY(!copy.has(anotherShader));
QVERIFY(copy.link());
}
const char* sipQSGMaterialShader::sipProtectVirt_vertexShader(bool sipSelfWasArg) const
{
return (sipSelfWasArg ? QSGMaterialShader::vertexShader() : vertexShader());
}
void World::Init(int argc, char** argv)
{
cout << "Initializing display.. " << endl;
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_DEPTH);
glutInitWindowSize(500,500);
glutCreateWindow("Inphlexion DLO integration playgoround");
glEnable(GL_DEPTH_TEST);
//! initialize shader stuff
glewInit();
if (glewIsSupported("GL_VERSION_2_0"))
printf("Ready for OpenGL 2.0\n");
else {
printf("OpenGL 2.0 not supported\n");
exit(1);
}
mainShaderProgram.reset(new FXZProgram());
shared_ptr<FXZShader> vertexShader(new FXZShader(GL_VERTEX_SHADER));
vertexShader->setSource("vshader.vert");
vertexShader->compileShader();
vertexShader->infoLog();
shared_ptr<FXZShader> fragmentShader(new FXZShader(GL_FRAGMENT_SHADER));
fragmentShader->setSource("fshader.frag");
fragmentShader->compileShader();
fragmentShader->infoLog();
mainShaderProgram->attachShader(vertexShader.get());
mainShaderProgram->attachShader(fragmentShader.get());
mainShaderProgram->linkProgram();
mainShaderProgram->infoLog();
mainShaderProgram->useProgram();
mainShaderProgram->addUniform("lightDir", UNIFORM3);
mainShaderProgram->setUniform("lightDir", 1, 0 , 0);
vector<vec3<Real> > positions;
int n = 50;
for (int i = 0; i < n; ++i)
{
positions.push_back(vec3<Real>(5 * cos(i/4.),5 * sin(i/4.),i/4.));
}
IPhysicalObject* dlo = new TorsionDLO(positions, .3, 50 * 0.05);
dlo->SetDampingCoefficient(5);
dlo->SetKl(100);
dlo->SetKd(5);
#define MAG 0.01
dlo->SetKts(MAG * 80);
dlo->SetKtd(MAG * 15);
dlo->SetKsw(MAG * 15);
dlo->SetLengthConstraintFraction(0.2);
dlo->SetIntegrationMethod(IPhysicalObject::IntegrationMethod::HALF_STEP);
this->objects.push_back(dlo);
camPos = vec3<Real>(100,0,50);
lookAt = vec3<Real>(0,0,0);
upVector = vec3<Real>(0,0,1);
}
Renderer() {
Program program;
std::shared_ptr<Shader> vertexShader(new Shader(ShaderType::VERTEX));
vertexShader->source("void main(void) {\nvec4 a = gl_Vertex;\ngl_Position = gl_ModelViewProjectionMatrix * a;\n}");
program.addShader(vertexShader);
}
void Setup(CPlatform * const pPlatform)
{
int utex = 0;
unsigned char * pTexture = 0;
WRender::Texture::SDescriptor desc = {WRender::Texture::TEX_3D, WRender::Texture::RGB8, WIDTH, HEIGHT, DEPTH, 0, WRender::Texture::DONT_GEN_MIPMAP};
WRender::Texture::SParam param[] ={
//tex 0
{ WRender::Texture::MIN_FILTER, WRender::Texture::NEAREST},
{ WRender::Texture::MAG_FILTER, WRender::Texture::NEAREST},
{ WRender::Texture::WRAP_S, WRender::Texture::REPEAT},
{ WRender::Texture::WRAP_T, WRender::Texture::REPEAT},
// tex 1
{ WRender::Texture::MIN_FILTER, WRender::Texture::LINEAR},
{ WRender::Texture::MAG_FILTER, WRender::Texture::LINEAR},
{ WRender::Texture::WRAP_S, WRender::Texture::REPEAT},
{ WRender::Texture::WRAP_T, WRender::Texture::REPEAT},
// tex 2
{ WRender::Texture::MIN_FILTER, WRender::Texture::LINEAR},
{ WRender::Texture::MAG_FILTER, WRender::Texture::LINEAR},
{ WRender::Texture::WRAP_S, WRender::Texture::REPEAT},
{ WRender::Texture::WRAP_T, WRender::Texture::CLAMP_TO_EDGE},
// tex 3
{ WRender::Texture::MIN_FILTER, WRender::Texture::LINEAR},
{ WRender::Texture::MAG_FILTER, WRender::Texture::LINEAR},
{ WRender::Texture::WRAP_S, WRender::Texture::CLAMP_TO_EDGE},
{ WRender::Texture::WRAP_T, WRender::Texture::CLAMP_TO_EDGE},
// tex 4
{ WRender::Texture::MIN_FILTER, WRender::Texture::NEAREST},
{ WRender::Texture::MAG_FILTER, WRender::Texture::NEAREST},
{ WRender::Texture::WRAP_S, WRender::Texture::CLAMP_TO_EDGE},
{ WRender::Texture::WRAP_T, WRender::Texture::CLAMP_TO_EDGE},
};
CShader vertexShader(CShader::VERT, &pVertexShader, 1);
CShader fragmentShader(CShader::FRAG, &pFragmentShader, 1);
WRender::Pixel::Data pixelData = {WRender::Pixel::RGB, WRender::Pixel::UCHAR, 0, 0};
// - - - - - - - - - -
// create textures
pTexture = new unsigned char[WIDTH * HEIGHT * DEPTH * 3];
for(unsigned int d=0;d<DEPTH;d++)
for(unsigned int h=0;h<HEIGHT;h++)
for(unsigned int w=0;w<WIDTH;w++)
{
int depth_index = d*HEIGHT*WIDTH*3;
int height_index = h*WIDTH*3;
int width_index = w*3;
pTexture[depth_index + height_index + width_index + 0] = (255*w)/(WIDTH); //R
pTexture[depth_index + height_index + width_index + 1] = (255*h)/(HEIGHT); //G
pTexture[depth_index + height_index + width_index + 2] = (255*d)/(DEPTH);//(255*(w+h))/(WIDTH+HEIGHT); //B
}
pixelData.pData = (void*)pTexture;
WRender::ActiveTexture(WRender::Texture::UNIT_4);
//tex 0
if(WRender::CreateBaseTexture(tex[0], desc))
{
WRender::UpdateTextureData(tex[0], pixelData);
WRender::SetTextureParams(tex[0], param, 4);
}
//tex 1
if(WRender::CreateBaseTextureData(tex[1], desc, pixelData))
WRender::SetTextureParams(tex[1], param+4, 4);
//tex 2
if(WRender::CreateBaseTextureData(tex[2], desc, pixelData))
WRender::SetTextureParams(tex[2], param+8, 4);
//tex 3
if(WRender::CreateBaseTextureData(tex[3], desc, pixelData))
WRender::SetTextureParams(tex[3], param+12, 4);
//tex 4
if(WRender::CreateBaseTextureData(tex[4], desc, pixelData))
WRender::SetTextureParams(tex[4], param+16, 4);
delete [] pTexture;
// - - - - - - - - - -
//setup the shaders
program.Initialise();
program.AddShader(&vertexShader);
program.AddShader(&fragmentShader);
program.Link();
utex = program.GetUniformLocation("tex");
// - - - - - - - - - -
// setup vertex buffers etc
vao = WRender::CreateVertexArrayObject();
eab = WRender::CreateBuffer(WRender::ELEMENTS, WRender::STATIC, sizeof(indices), indices);
ab = WRender::CreateBuffer(WRender::ARRAY, WRender::STATIC, sizeof(vertices), vertices);
WRender::BindVertexArrayObject(vao);
WRender::BindBuffer(WRender::ELEMENTS, eab);
WRender::VertexAttribute va[] = {
{ab, 0, 3, WRender::FLOAT, 0, sizeof(float)*5, 0, 0},
{ab, 3, 2, WRender::FLOAT, 0, sizeof(float)*5, sizeof(float)*3, 0}
};
WRender::SetAttributeFormat( va, 2, 0);
program.Start();
//program.SetTextureUnit(utex, 4);
glEnable(GL_CULL_FACE);
WRender::BindTexture(tex[activeTexture]);
}
//[-------------------------------------------------------]
//[ Public virtual IApplication methods ]
//[-------------------------------------------------------]
void FirstPostProcessing::onInitialization()
{
// Call the base implementation
IApplicationRenderer::onInitialization();
// Get and check the renderer instance
Renderer::IRendererPtr renderer(getRenderer());
if (nullptr != renderer)
{
// Begin debug event
RENDERER_BEGIN_DEBUG_EVENT_FUNCTION(renderer)
// Create the framebuffer object (FBO) instance by using the current window size
recreateFramebuffer();
{ // Create sampler state
// -> Our texture does not have any mipmaps, set "Renderer::SamplerState::maxLOD" to zero
// in order to ensure a correct behaviour across the difference graphics APIs
// -> When not doing this you usually have no issues when using OpenGL, OpenGL ES 2, Direct 10,
// Direct3D 11 or Direct3D 9 with the "ps_2_0"-profile, but when using Direct3D 9 with the
// "ps_3_0"-profile you might get into trouble due to another internal graphics API behaviour
Renderer::SamplerState samplerState = Renderer::ISamplerState::getDefaultSamplerState();
samplerState.maxLOD = 0.0f; // We don't use mipmaps
mSamplerState = renderer->createSamplerState(samplerState);
}
{ // Depth stencil state
// -> By default depth test is enabled
// -> In this simple example we don't need depth test, so, disable it so we don't need to care about the depth buffer
// Create depth stencil state
Renderer::DepthStencilState depthStencilState = Renderer::IDepthStencilState::getDefaultDepthStencilState();
depthStencilState.depthEnable = false;
mDepthStencilState = renderer->createDepthStencilState(depthStencilState);
// Set the depth stencil state directly within this initialization phase, we don't change it later on
renderer->omSetDepthStencilState(mDepthStencilState);
}
// Decide which shader language should be used (for example "GLSL", "HLSL" or "Cg")
Renderer::IShaderLanguagePtr shaderLanguage(renderer->getShaderLanguage());
if (nullptr != shaderLanguage)
{
{ // Create the programs
// Get the shader source code (outsourced to keep an overview)
const char *vertexShaderSourceCode = nullptr;
const char *fragmentShaderSourceCode_SceneRendering = nullptr;
const char *fragmentShaderSourceCode_PostProcessing = nullptr;
#include "FirstPostProcessing_Cg.h"
#include "FirstPostProcessing_GLSL_110.h"
#include "FirstPostProcessing_GLSL_ES2.h"
#include "FirstPostProcessing_HLSL_D3D9.h"
#include "FirstPostProcessing_HLSL_D3D10_D3D11.h"
#include "FirstPostProcessing_Null.h"
// In order to keep this example simple and to show that it's possible, we use the same vertex shader for both programs
// -> Depending on the used graphics API and whether or not the shader compiler & linker is clever,
// the unused texture coordinate might get optimized out
// -> In a real world application you shouldn't rely on shader compiler & linker behaviour assumptions
Renderer::IVertexShaderPtr vertexShader(shaderLanguage->createVertexShader(vertexShaderSourceCode));
mProgramSceneRendering = shaderLanguage->createProgram(vertexShader, shaderLanguage->createFragmentShader(fragmentShaderSourceCode_SceneRendering));
mProgramPostProcessing = shaderLanguage->createProgram(vertexShader, shaderLanguage->createFragmentShader(fragmentShaderSourceCode_PostProcessing));
}
// Is there a valid program for scene rendering?
if (nullptr != mProgramSceneRendering)
{
// Create the vertex buffer object (VBO)
// -> Clip space vertex positions, left/bottom is (-1,-1) and right/top is (1,1)
static const float VERTEX_POSITION[] =
{ // Vertex ID Triangle on screen
0.0f, 1.0f, // 0 0
1.0f, 0.0f, // 1 . .
-0.5f, 0.0f // 2 2.......1
};
Renderer::IVertexBufferPtr vertexBuffer(renderer->createVertexBuffer(sizeof(VERTEX_POSITION), VERTEX_POSITION, Renderer::BufferUsage::STATIC_DRAW));
// Create vertex array object (VAO)
// -> The vertex array object (VAO) keeps a reference to the used vertex buffer object (VBO)
// -> This means that there's no need to keep an own vertex buffer object (VBO) reference
// -> When the vertex array object (VAO) is destroyed, it automatically decreases the
// reference of the used vertex buffer objects (VBO). If the reference counter of a
// vertex buffer object (VBO) reaches zero, it's automatically destroyed.
const Renderer::VertexArrayAttribute vertexArray[] =
{
{ // Attribute 0
// Data destination
Renderer::VertexArrayFormat::FLOAT_2, // vertexArrayFormat (Renderer::VertexArrayFormat::Enum)
"Position", // name[64] (char)
"POSITION", // semantic[64] (char)
0, // semanticIndex (unsigned int)
// Data source
vertexBuffer, // vertexBuffer (Renderer::IVertexBuffer *)
0, // offset (unsigned int)
sizeof(float) * 2, // stride (unsigned int)
// Data source, instancing part
0 // instancesPerElement (unsigned int)
}
};
mVertexArraySceneRendering = mProgramSceneRendering->createVertexArray(sizeof(vertexArray) / sizeof(Renderer::VertexArrayAttribute), vertexArray);
}
// Is there a valid program for post-processing?
if (nullptr != mProgramPostProcessing)
{
// Create the vertex buffer object (VBO)
// -> Clip space vertex positions, left/bottom is (-1,-1) and right/top is (1,1)
static const float VERTEX_POSITION[] =
{ // Vertex ID Triangle strip on screen
-1.0f, -1.0f, // 0 1.......3
-1.0f, 1.0f, // 1 . . .
1.0f, -1.0f, // 2 0.......2
1.0f, 1.0f // 3
};
Renderer::IVertexBufferPtr vertexBuffer(renderer->createVertexBuffer(sizeof(VERTEX_POSITION), VERTEX_POSITION, Renderer::BufferUsage::STATIC_DRAW));
// Create vertex array object (VAO)
// -> The vertex array object (VAO) keeps a reference to the used vertex buffer object (VBO)
// -> This means that there's no need to keep an own vertex buffer object (VBO) reference
// -> When the vertex array object (VAO) is destroyed, it automatically decreases the
// reference of the used vertex buffer objects (VBO). If the reference counter of a
// vertex buffer object (VBO) reaches zero, it's automatically destroyed.
const Renderer::VertexArrayAttribute vertexArray[] =
{
{ // Attribute 0
// Data destination
Renderer::VertexArrayFormat::FLOAT_2, // vertexArrayFormat (Renderer::VertexArrayFormat::Enum)
"Position", // name[64] (char)
"POSITION", // semantic[64] (char)
0, // semanticIndex (unsigned int)
// Data source
vertexBuffer, // vertexBuffer (Renderer::IVertexBuffer *)
0, // offset (unsigned int)
sizeof(float) * 2, // stride (unsigned int)
// Data source, instancing part
0 // instancesPerElement (unsigned int)
}
};
mVertexArrayPostProcessing = mProgramSceneRendering->createVertexArray(sizeof(vertexArray) / sizeof(Renderer::VertexArrayAttribute), vertexArray);
}
}
// End debug event
RENDERER_END_DEBUG_EVENT(renderer)
}
// The address returned here will only be valid until next time this function is called.
// The program is return bound.
QGLEngineShaderProg *QGLEngineSharedShaders::findProgramInCache(const QGLEngineShaderProg &prog)
{
for (int i = 0; i < cachedPrograms.size(); ++i) {
QGLEngineShaderProg *cachedProg = cachedPrograms[i];
if (*cachedProg == prog) {
// Move the program to the top of the list as a poor-man's cache algo
cachedPrograms.move(i, 0);
cachedProg->program->bind();
return cachedProg;
}
}
QScopedPointer<QGLEngineShaderProg> newProg;
do {
QByteArray fragSource;
// Insert the custom stage before the srcPixel shader to work around an ATI driver bug
// where you cannot forward declare a function that takes a sampler as argument.
if (prog.srcPixelFragShader == CustomImageSrcFragmentShader)
fragSource.append(prog.customStageSource);
fragSource.append(qShaderSnippets[prog.mainFragShader]);
fragSource.append(qShaderSnippets[prog.srcPixelFragShader]);
if (prog.compositionFragShader)
fragSource.append(qShaderSnippets[prog.compositionFragShader]);
if (prog.maskFragShader)
fragSource.append(qShaderSnippets[prog.maskFragShader]);
QByteArray vertexSource;
vertexSource.append(qShaderSnippets[prog.mainVertexShader]);
vertexSource.append(qShaderSnippets[prog.positionVertexShader]);
QScopedPointer<QGLShaderProgram> shaderProgram(new QGLShaderProgram);
CachedShader shaderCache(fragSource, vertexSource);
bool inCache = shaderCache.load(shaderProgram.data(), QGLContext::currentContext());
if (!inCache) {
QScopedPointer<QGLShader> fragShader(new QGLShader(QGLShader::Fragment));
QByteArray description;
#if defined(QT_DEBUG)
// Name the shader for easier debugging
description.append("Fragment shader: main=");
description.append(snippetNameStr(prog.mainFragShader));
description.append(", srcPixel=");
description.append(snippetNameStr(prog.srcPixelFragShader));
if (prog.compositionFragShader) {
description.append(", composition=");
description.append(snippetNameStr(prog.compositionFragShader));
}
if (prog.maskFragShader) {
description.append(", mask=");
description.append(snippetNameStr(prog.maskFragShader));
}
fragShader->setObjectName(QString::fromLatin1(description));
#endif
if (!fragShader->compileSourceCode(fragSource)) {
qWarning() << "Warning:" << description << "failed to compile!";
break;
}
QScopedPointer<QGLShader> vertexShader(new QGLShader(QGLShader::Vertex));
#if defined(QT_DEBUG)
// Name the shader for easier debugging
description.clear();
description.append("Vertex shader: main=");
description.append(snippetNameStr(prog.mainVertexShader));
description.append(", position=");
description.append(snippetNameStr(prog.positionVertexShader));
vertexShader->setObjectName(QString::fromLatin1(description));
#endif
if (!vertexShader->compileSourceCode(vertexSource)) {
qWarning() << "Warning:" << description << "failed to compile!";
break;
}
shaders.append(vertexShader.data());
shaders.append(fragShader.data());
shaderProgram->addShader(vertexShader.take());
shaderProgram->addShader(fragShader.take());
// We have to bind the vertex attribute names before the program is linked:
shaderProgram->bindAttributeLocation("vertexCoordsArray", QT_VERTEX_COORDS_ATTR);
if (prog.useTextureCoords)
shaderProgram->bindAttributeLocation("textureCoordArray", QT_TEXTURE_COORDS_ATTR);
if (prog.useOpacityAttribute)
shaderProgram->bindAttributeLocation("opacityArray", QT_OPACITY_ATTR);
if (prog.usePmvMatrixAttribute) {
shaderProgram->bindAttributeLocation("pmvMatrix1", QT_PMV_MATRIX_1_ATTR);
shaderProgram->bindAttributeLocation("pmvMatrix2", QT_PMV_MATRIX_2_ATTR);
shaderProgram->bindAttributeLocation("pmvMatrix3", QT_PMV_MATRIX_3_ATTR);
}
}
newProg.reset(new QGLEngineShaderProg(prog));
newProg->program = shaderProgram.take();
newProg->program->link();
if (newProg->program->isLinked()) {
if (!inCache)
shaderCache.store(newProg->program, QGLContext::currentContext());
} else {
QLatin1String none("none");
QLatin1String br("\n");
QString error;
error = QLatin1String("Shader program failed to link,");
#if defined(QT_DEBUG)
error += QLatin1String("\n Shaders Used:\n");
for (int i = 0; i < newProg->program->shaders().count(); ++i) {
QGLShader *shader = newProg->program->shaders().at(i);
error += QLatin1String(" ") + shader->objectName() + QLatin1String(": \n")
+ QLatin1String(shader->sourceCode()) + br;
}
#endif
error += QLatin1String(" Error Log:\n")
+ QLatin1String(" ") + newProg->program->log();
qWarning() << error;
break;
}
newProg->program->bind();
if (newProg->maskFragShader != QGLEngineSharedShaders::NoMaskFragmentShader) {
GLuint location = newProg->program->uniformLocation("maskTexture");
newProg->program->setUniformValue(location, QT_MASK_TEXTURE_UNIT);
}
if (cachedPrograms.count() > 30) {
// The cache is full, so delete the last 5 programs in the list.
// These programs will be least used, as a program us bumped to
// the top of the list when it's used.
for (int i = 0; i < 5; ++i) {
delete cachedPrograms.last();
cachedPrograms.removeLast();
}
}
cachedPrograms.insert(0, newProg.data());
} while (false);
return newProg.take();
}
bool TessMeshApp::Init(){
bool res = App::Init();
if (!res) { return res; }
initMeshShader();
meshShaderProgram->use();
initMesh();
//mouse:
{
Shader vertexShader(GL_VERTEX_SHADER);
vertexShader.loadFromFile("shaders/mouse.vert");
vertexShader.compile();
Shader fragmentShader(GL_FRAGMENT_SHADER);
fragmentShader.loadFromFile("shaders/mouse.frag");
fragmentShader.compile();
// Shader geometryShader(GL_GEOMETRY_SHADER);
// geometryShader.loadFromFile("shaders/mouse.geom");
// geometryShader.compile();
mouseShaderProgram = new ShaderProgram();
mouseShaderProgram->attachShader(vertexShader);
mouseShaderProgram->attachShader(fragmentShader);
// mouseShaderProgram->attachShader(geometryShader);
mouseShaderProgram->linkProgram();
mouse = new Mesh();
vector<vec3> vertices;
vertices.push_back(vec3(0.0f, 0.0f, -5.0f));
vector<vec3> colors;
colors.push_back(vec3(1.0f, 0.0f, 0.0f));
vector<GLuint> indices;
indices.push_back(0);
mouse->addIndices(indices);
// position
{
Attribute positionAttrib;
positionAttrib.name = "position";
positionAttrib.num_of_components = 3;
positionAttrib.data_type = GL_FLOAT;
positionAttrib.buffer_type = GL_ARRAY_BUFFER;
mouse->addVBO(vertices, positionAttrib);
mouseShaderProgram->use();
positionAttrib.id = mouseShaderProgram->addAttribute(positionAttrib.name);
glEnableVertexAttribArray(positionAttrib.id);
glVertexAttribPointer(positionAttrib.id, positionAttrib.num_of_components, GL_FLOAT, GL_FALSE, 0, 0);
mouseShaderProgram->disable();
mouse->attributes.push_back(positionAttrib);
}
// color:
{
Attribute colorAttrib;
colorAttrib.name = "color";
colorAttrib.num_of_components = 3;
colorAttrib.data_type = GL_FLOAT;
colorAttrib.buffer_type = GL_ARRAY_BUFFER;
mouse->addVBO(colors, colorAttrib);
mouseShaderProgram->use();
colorAttrib.id = mouseShaderProgram->addAttribute(colorAttrib.name);
glEnableVertexAttribArray(colorAttrib.id);
glVertexAttribPointer(colorAttrib.id, colorAttrib.num_of_components, GL_FLOAT, GL_FALSE, 0, 0);
mouseShaderProgram->disable();
mouse->attributes.push_back(colorAttrib);
}
// uniforms:
{
mouseShaderProgram->use();
GLuint model = mouseShaderProgram->addUniform("model");
glUniformMatrix4fv(model, 1, GL_FALSE, glm::value_ptr(mesh->modelMatrix));
GLuint view = mouseShaderProgram->addUniform("view");
glUniformMatrix4fv(view, 1, GL_FALSE, glm::value_ptr(camera.view));
GLuint projection = mouseShaderProgram->addUniform("projection");
glUniformMatrix4fv(projection, 1, GL_FALSE, glm::value_ptr(camera.projection));
GLuint mousePosition = mouseShaderProgram->addUniform("mousePosition");
vec3 mouse_pos(1.0f, 0.0f, -5.0f);
glUniform3fv(mousePosition, 1, glm::value_ptr(mouse_pos));
mouseShaderProgram->disable();
}
}
return res;
}
int Main() {
run = true;
//Peanuts::WindowOptions windowOptions("GL test", Peanuts::Windowed(Peanuts::size(640,480), Peanuts::position(100,100)), Peanuts::OpenGLVersion(3, 1));
Peanuts::WindowOptions windowOptions("GL test", Peanuts::Windowed(Peanuts::size(640,480), Peanuts::Centered()), Peanuts::OpenGLVersion(3, 1));
//Peanuts::WindowOptions windowOptions("GL test", Peanuts::Windowed(Peanuts::size(640,480), Peanuts::Centered(), Peanuts::Borders::Off), Peanuts::OpenGLVersion(3, 1));
//Peanuts::WindowOptions windowOptions("GL test", Peanuts::Windowed(Peanuts::Maximised()), Peanuts::OpenGLVersion(3, 1));
//Peanuts::WindowOptions windowOptions("GL test", Peanuts::Windowed(Peanuts::Maximised(), Peanuts::Borders::Off), Peanuts::OpenGLVersion(3, 1));
//Peanuts::WindowOptions windowOptions("GL test", Peanuts::FullScreen(), Peanuts::OpenGLVersion(3, 1));
auto win = Peanuts::Window::create(windowOptions);
EventHandler eventHandler;
gl::ClearColor(1.0f, 0.0f, 0.0f, 0.0f);
gl::Enable(gl::GL_DEPTH_TEST);
gl::DepthFunc(gl::GL_LEQUAL);
gl::Enable(gl::GL_CULL_FACE);
gl::CullFace(gl::GL_BACK);
gl::PolygonMode(gl::GL_FRONT, gl::GL_FILL);
gldr::VertexArray vao;
vao.bind();
gldr::Texture2d tex;
gldr::Program program;
{
gldr::VertexShader vertexShader(util::loadShader("resource/shaders/basic.vert"));
gldr::FragmentShader fragmentShader(util::loadShader("resource/shaders/basic.frag"));
program.attach(vertexShader, fragmentShader);
program.link();
}
GLint modelview, projection;
gldr::indexVertexBuffer indexBuffer;
gldr::dataVertexBuffer vertexBuffer;
gldr::dataVertexBuffer colorBuffer;
gldr::dataVertexBuffer textureCoordBuffer;
{
std::vector<GLfloat> vertexData = {
-0.5, -0.5, -0.5,
0.5, -0.5, -0.5,
0.5, 0.5, -0.5,
-0.5, 0.5, -0.5,
};
std::vector<GLuint> indexdata = {
0, 1, 2,
2, 3, 0
};
std::vector<GLfloat> colors = {
1.0,0.0,0.0,
0.0,1.0,0.0,
0.0,0.0,1.0,
0.0,1.0,1.0
};
std::vector<GLfloat> textureCoord = {
0.0, 1.0,
1.0, 1.0,
1.0, 0.0,
0.0, 0.0,
};
vertexBuffer.bufferData(vertexData);
colorBuffer.bufferData(colors);
indexBuffer.bufferData(indexdata);
textureCoordBuffer.bufferData(textureCoord);
tex.setFiltering(gldr::textureOptions::FilterDirection::Minification, gldr::textureOptions::FilterMode::Linear);
tex.setFiltering(gldr::textureOptions::FilterDirection::Magnification, gldr::textureOptions::FilterMode::Linear);
auto image = loadImage("resource/images/pheonixflames.png");
tex.imageData(image.width, image.height,
gldr::textureOptions::Format::RGBA,
gldr::textureOptions::InternalFormat::RGB,
gldr::textureOptions::DataType::UnsignedByte,
image.data.data()
);
program.use();
GLint position_attribute = program.getAttribLocation("position");
GLint color_attribute = program.getAttribLocation("color");
GLint texture_coord_attribute = program.getAttribLocation("texture_coord");
modelview = program.getUniformLocation("ModelView");
projection = program.getUniformLocation("Projection");
vertexBuffer.bind();
gl::VertexAttribPointer(position_attribute, 3, gl::GL_FLOAT, gl::GL_FALSE, 0, 0);
gl::EnableVertexAttribArray(position_attribute);
colorBuffer.bind();
gl::VertexAttribPointer(color_attribute, 3, gl::GL_FLOAT, gl::GL_FALSE, 0, 0);
gl::EnableVertexAttribArray(color_attribute);
textureCoordBuffer.bind();
gl::VertexAttribPointer(texture_coord_attribute, 2, gl::GL_FLOAT, gl::GL_FALSE, 0, 0);
gl::EnableVertexAttribArray(texture_coord_attribute);
}
projectionMat = cam.projection();
cam.pos = glm::vec3(0.0f, 0.0f, -2.0f);
cam.dir = glm::vec3(0.0f, 0.0f, 1.0f);
Crate crate;
while (run) {
gl::Clear(gl::GL_COLOR_BUFFER_BIT);
gl::Clear(gl::GL_DEPTH_BUFFER_BIT);
gl::UniformMatrix4fv(modelview, 1, gl::GL_FALSE, glm::value_ptr(cam.modelView()));
gl::UniformMatrix4fv(projection, 1, gl::GL_FALSE, glm::value_ptr(projectionMat));
vao.bind();
tex.bind();
program.use();
gl::DrawElements(gl::GL_TRIANGLES, 6, gl::GL_UNSIGNED_INT, 0);
crate.projectWith(projectionMat);
crate.draw();
std::this_thread::sleep_for(std::chrono::milliseconds(100));
win->pumpEvents();
while(auto event = win->pollEvent()){
boost::apply_visitor(eventHandler, *event);
}
win->swapBuffers();
update();
}
return 0;
}
vpp::Pipeline createGraphicsPipeline(const vpp::Device& dev, vk::RenderPass rp,
vk::PipelineLayout layout)
{
// first load the shader modules and create the shader program for our pipeline
if(!vpp::fileExists("intro.vert.spv") || !vpp::fileExists("intro.frag.spv"))
throw std::runtime_error("Could not find shaders. Make sure to execute from binary dir");
vpp::ShaderModule vertexShader(dev, "intro.vert.spv");
vpp::ShaderModule fragmentShader(dev, "intro.frag.spv");
vpp::ShaderProgram shaderStages({
{vertexShader, vk::ShaderStageBits::vertex},
{fragmentShader, vk::ShaderStageBits::fragment}
});
vk::GraphicsPipelineCreateInfo pipelineInfo;
pipelineInfo.renderPass = rp;
pipelineInfo.layout = layout;
pipelineInfo.stageCount = shaderStages.vkStageInfos().size();
pipelineInfo.pStages = shaderStages.vkStageInfos().data();
constexpr auto stride = (2 + 4) * 4; // 2 pos floats, 4 color floats (4 byte floats)
vk::VertexInputBindingDescription bufferBinding {0, stride, vk::VertexInputRate::vertex};
// vertex position, color attributes
vk::VertexInputAttributeDescription attributes[2];
attributes[0].format = vk::Format::r32g32Sfloat;
attributes[1].location = 1;
attributes[1].format = vk::Format::r32g32b32a32Sfloat;
attributes[1].offset = 2 * 4; // pos: vec2f
vk::PipelineVertexInputStateCreateInfo vertexInfo;
vertexInfo.vertexBindingDescriptionCount = 1;
vertexInfo.pVertexBindingDescriptions = &bufferBinding;
vertexInfo.vertexAttributeDescriptionCount = 2;
vertexInfo.pVertexAttributeDescriptions = attributes;
pipelineInfo.pVertexInputState = &vertexInfo;
vk::PipelineInputAssemblyStateCreateInfo assemblyInfo;
assemblyInfo.topology = vk::PrimitiveTopology::triangleList;
pipelineInfo.pInputAssemblyState = &assemblyInfo;
vk::PipelineRasterizationStateCreateInfo rasterizationInfo;
rasterizationInfo.polygonMode = vk::PolygonMode::fill;
rasterizationInfo.cullMode = vk::CullModeBits::none;
rasterizationInfo.frontFace = vk::FrontFace::counterClockwise;
rasterizationInfo.depthClampEnable = false;
rasterizationInfo.rasterizerDiscardEnable = false;
rasterizationInfo.depthBiasEnable = false;
rasterizationInfo.lineWidth = 1.f;
pipelineInfo.pRasterizationState = &rasterizationInfo;
vk::PipelineMultisampleStateCreateInfo multisampleInfo;
multisampleInfo.rasterizationSamples = vk::SampleCountBits::e1;
pipelineInfo.pMultisampleState = &multisampleInfo;
vk::PipelineColorBlendAttachmentState blendAttachment;
blendAttachment.blendEnable = false;
blendAttachment.colorWriteMask =
vk::ColorComponentBits::r |
vk::ColorComponentBits::g |
vk::ColorComponentBits::b |
vk::ColorComponentBits::a;
vk::PipelineColorBlendStateCreateInfo blendInfo;
blendInfo.attachmentCount = 1;
blendInfo.pAttachments = &blendAttachment;
pipelineInfo.pColorBlendState = &blendInfo;
vk::PipelineViewportStateCreateInfo viewportInfo;
viewportInfo.scissorCount = 1;
viewportInfo.viewportCount = 1;
pipelineInfo.pViewportState = &viewportInfo;
constexpr auto dynStates = {vk::DynamicState::viewport, vk::DynamicState::scissor};
vk::PipelineDynamicStateCreateInfo dynamicInfo;
dynamicInfo.dynamicStateCount = dynStates.size();
dynamicInfo.pDynamicStates = dynStates.begin();
pipelineInfo.pDynamicState = &dynamicInfo;
// we also use the vpp::PipelienCache in this case
// we try to load it from an already existent cache
constexpr auto cacheName = "grapihcsPipelineCache.bin";
vpp::PipelineCache cache;
if(vpp::fileExists(cacheName)) cache = {dev, cacheName};
else cache = {dev};
auto vkPipeline = vk::createGraphicsPipelines(dev, cache, {pipelineInfo}).front();
// save the cache to the file we tried to load it from
vpp::save(cache, cacheName);
return {dev, vkPipeline};
}
bool initialize( char** argv )
{
// Load file data
FileIOHandler io( "../bin/bodies.info", READ_FROM_FILE );
std::vector<std::string> rawData = io.GetRawData();
//io.DisplayData(); // debugging
// Store file data as vector of cBody objects
unsigned int lineCtr;
for( lineCtr = 1; lineCtr < ( unsigned int )rawData.size(); ++lineCtr )
{
//std::cout << rawData[lineCtr] << std::endl;
cBody tmpBody( rawData[lineCtr] );
celestialBodies.push_back( tmpBody );
}
// Initialize meshes
for( lineCtr = 0; lineCtr < celestialBodies.size(); ++ lineCtr )
{
std::string tmpPath = "../bin/solar texture/";
tmpPath += celestialBodies[lineCtr].GetObjPath();
Mesh* tmpMesh = new Mesh();
if( !tmpMesh->LoadMesh( tmpPath ) )
{
std::cerr << "Failed to load scene properly from "
<< tmpPath << ".\n" << std::endl;
return false;
}
meshes.push_back( tmpMesh );
std::cout << "object " << tmpPath << " loaded into mesh vector.\n";
}
// Initialize shaders
// Vertex shader
Shader vertexShader(GL_VERTEX_SHADER);
vertexShader.loadFromFile("shader.vert");
vertexShader.compile();
// Fragment shader
Shader fragmentShader(GL_FRAGMENT_SHADER);
fragmentShader.loadFromFile("shader.frag");
fragmentShader.compile();
// set up shader program
program = new ShaderProgram();
program->attachShader(vertexShader);
program->attachShader(fragmentShader);
program->linkProgram();
//Now we set the locations of the attributes and uniforms
//this allows us to access them easily while rendering
program->addUniform("mvpMatrix");
projection = glm::perspective( 45.0f, //the FoV typically 90 degrees is good which is what this is set to
float(w)/float(h), //Aspect Ratio, so Circles stay Circular
0.01f, //Distance to the near plane, normally a small value like this
500.0f); //Distance to the far plane,
//enable depth testing
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);
//and its done
return true;
}
void Setup(CPlatform * const pPlatform)
{
unsigned int got = 0;
const char *pVertStr[3] = {0,0,0}, *pFragStr = 0;
unsigned int nSphereFloats;
float *pSphereVertices = 0;
unsigned int iterations = 7;
int nFacets = 0;
glswInit();
glswSetPath("../resources/", ".glsl");
WRender::SetClearColour(0,0,0,0);
WRender::EnableCulling(true);
got = glswGetShadersAlt("shaders.Version+shaders.Shared+shaders.FlatShading.Vertex", pVertStr, 3);
pFragStr = glswGetShaders("shaders.Version+shaders.FlatShading.Fragment");
CShader vertexShader(CShader::VERT, pVertStr, got);
CShader fragmentShader(CShader::FRAG, &pFragStr, 1);
pVertStr[0] = glswGetShaders("shaders.Version+shaders.Gamma.Vertex");
pFragStr = glswGetShaders("shaders.Version+shaders.Gamma.Fragment");
CShader vertexShaderStage2(CShader::VERT, &pVertStr[0], 1);
CShader fragmentShaderStage2(CShader::FRAG, &pFragStr, 1);
// - - - - - - - - - -
//setup the shaders
program[0].Initialise();
program[0].AddShader(&vertexShader);
program[0].AddShader(&fragmentShader);
program[0].Link();
program[1].Initialise();
program[1].AddShader(&vertexShaderStage2);
program[1].AddShader(&fragmentShaderStage2);
program[1].Link();
program[1].Start();
program[1].SetTextureUnit("src_image",0);
program[1].Stop();
// - - - - - - - - - -
//setup the textures
WRender::Texture::SDescriptor desc = {WRender::Texture::TEX_2D, WRender::Texture::RGB8, WIDTH_HEIGHT, WIDTH_HEIGHT, 0, 0, WRender::Texture::DONT_GEN_MIPMAP};
WRender::Texture::SParam param[] ={
{ WRender::Texture::MIN_FILTER, WRender::Texture::LINEAR},
{ WRender::Texture::MAG_FILTER, WRender::Texture::LINEAR},
{ WRender::Texture::WRAP_S, WRender::Texture::REPEAT},
{ WRender::Texture::WRAP_T, WRender::Texture::REPEAT},
};
WRender::CreateBaseTexture(texR, desc);
WRender::SetTextureParams(texR,param,4);
//setup Frame Buffer
WRender::CreateFrameBuffer(fbo);
WRender::AddTextureRenderBuffer(fbo, texR, WRender::ATT_CLR0, 0);
WRender::CheckFrameBuffer(fbo);
// - - - - - - - - - -
//set up shapes
//SPHERE
nSphereVertices = unsigned int(powl(4.0,long double(iterations)))*8*3;
nSphereFloats = nSphereVertices*3;
pSphereVertices = new float[nSphereFloats];
nFacets = CreateNSphere(pSphereVertices, iterations);
vaoSphere = WRender::CreateVertexArrayObject();
abSphere = WRender::CreateBuffer(WRender::ARRAY, WRender::STATIC, sizeof(float)*nSphereFloats, pSphereVertices);
WRender::BindVertexArrayObject(vaoSphere);
WRender::VertexAttribute vaSphere[1] = {
{abSphere, 0, 3, WRender::FLOAT, 0, sizeof(float)*3, 0, 0}
};
WRender::SetAttributeFormat( vaSphere, 1, 0);
delete[] pSphereVertices;
//square
sqVao = WRender::CreateVertexArrayObject();
sqEab = WRender::CreateBuffer(WRender::ELEMENTS, WRender::STATIC, sizeof(sqIndices), sqIndices);
sqAb = WRender::CreateBuffer(WRender::ARRAY, WRender::STATIC, sizeof(sqVertices), sqVertices);
WRender::BindVertexArrayObject(sqVao);
WRender::BindBuffer(WRender::ELEMENTS, sqEab);
WRender::VertexAttribute sqVa[2] = {
{sqAb, 0, 3, WRender::FLOAT, 0, sizeof(float)*5, 0, 0}, //vertices
{sqAb, 1, 2, WRender::FLOAT, 0, sizeof(float)*5, sizeof(float)*3, 0}, //texture coordinates
};
WRender::SetAttributeFormat( sqVa, 2, 0);
WRender::UnbindVertexArrayObject();
//ubo for cameras etc
ubo = WRender::CreateBuffer(WRender::UNIFORM, WRender::DYNAMIC, sizeof(Transforms), &transform);
WRender::BindBufferToIndex(WRender::UNIFORM, ubo, 1);
Transform::CreateProjectionMatrix(transforms.proj, -1.0f, 1.0f, -1.0f, 1.0f, 1.0f, 50.0f);
}
int main(int argc, char** argv)
{
--argc;
++argv;
const int WIDTH = 800;
const int HEIGHT = 600;
/*
* Create window
*/
sf::RenderWindow window(sf::VideoMode(WIDTH, HEIGHT), "Window", sf::Style::Default, sf::ContextSettings(32));
/*
* Initialize GLEW
*/
GLenum status = glewInit();
if(status != GLEW_OK)
{
std::cerr << "[F] GLEW NOT INITIALIZED: ";
std::cerr << glewGetErrorString(status) << std::endl;
window.close();
return -1;
}
glEnable(GL_TEXTURE_2D);
glEnable(GL_DEPTH_TEST);
glDepthMask(GL_TRUE);
//glFrontFace(GL_CW);
//glCullFace(GL_BACK);
//glEnable(GL_CULL_FACE);
glClearDepth(1.f);
glShadeModel(GL_SMOOTH);
/*
* Create GUI
*/
tgui::Gui gui(window);
tgui::Gui gui2(window);
gui.setGlobalFont("fonts/DejaVuSans.ttf");
loadWidgets(gui, gui2, window);
char* args[argc + 1];
/*
* load geometry
*/
Model cube;
getArgs(argc, argv, ".obj", args);
if (!args[0])
{
std::cerr << "[F] MUST SUPPLY 1+ OBJ FILES IN COMMAND LINE ARGS <filename.obj>" << std::endl;
exit(-1);
} //if
cube.mesh = loadMesh(args[0]);
if (!cube.mesh)
{
exit(-1);
} //if
getArgs(argc, argv, ".scale", args);
if (args[0])
{
cube.scale = glm::vec3(strtof(args[0], NULL));
} //if
else
{
cube.scale = glm::vec3(1.0f);
} //else
/*
* load shaders
*/
Shader vertexShader(GL_VERTEX_SHADER);
getArgs(argc, argv, ".vs", args);
vertexShader.loadFromFile(args[0]? args[0] : ".vs");
vertexShader.compile();
Shader fragmentShader(GL_FRAGMENT_SHADER);
getArgs(argc, argv, ".fs", args);
fragmentShader.loadFromFile(args[0]? args[0] : ".fs");
fragmentShader.compile();
/*
* create program
*/
ShaderProgram program;
program.attachShader(vertexShader);
program.attachShader(fragmentShader);
program.linkProgram();
program.addAttribute("vertexPosition_modelspace");
program.addAttribute("vertexUV");
//program.addAttribute("vertexNormal_modelspace");
program.addUniform("MVP");
program.addUniform("sampler");
Camera camera;
sf::Event event;
tgui::Callback callback;
Planet p(&cube);
/*
* main loop
*/
while (window.isOpen())
{
while (window.pollEvent(event))
{
switch (event.type)
{
case sf::Event::Closed:
window.close();
break;
case sf::Event::Resized:
glViewport(0, 0, event.size.width, event.size.height);
camera.projection = glm::perspective(45.0f, float(event.size.width)/float(event.size.height), 0.01f, 100.0f);
break;
default:
break;
} //switch
gui.handleEvent(event);
} //if
while (gui.pollCallback(callback))
{
gui.handleEvent(event);
} //if
window.clear();
guiDraw(window, gui2);
glClear(GL_DEPTH_BUFFER_BIT);
/*
* render OpenGL here
*/
//glValidateProgram(program.program);
for (Planet* planet : planets)
{
render(*planet, camera, program);
} //for
guiDraw(window, gui);
window.display();
} //while
// Clean up after ourselves
if (window.isOpen())
{
window.close();
} //if
return EXIT_SUCCESS;
} //main
void Setup(CPlatform * const pPlatform)
{
//for the shapes
unsigned int nTorusFloats;
float *pTorusVertices = 0;
float *pPlaneVertices = 0;
float colour[] = {1.0f,0.0f,0.0f, 0.0f,1.0f,0.0f, 0.0f,0.0f,1.0f};
unsigned int torusSegments = 36, torusTubeSegments = 36;
//for the shaders
const char *pVertStr[3] = {0,0,0}, *pFragStr = 0;
const char *pFragTexStr = 0, *pVertTexStr = 0;
//fbo stuff
WRender::Texture::SDescriptor descDepth = {WRender::Texture::TEX_2D, WRender::Texture::DEPTH_COMPONENT, TEX_DIMENSIONS, TEX_DIMENSIONS, 0, 0, WRender::Texture::DONT_GEN_MIPMAP};
WRender::Texture::SParam param[] ={
{ WRender::Texture::MIN_FILTER, WRender::Texture::LINEAR},
{ WRender::Texture::MAG_FILTER, WRender::Texture::LINEAR},
{ WRender::Texture::WRAP_S, WRender::Texture::CLAMP_TO_EDGE},
{ WRender::Texture::WRAP_T, WRender::Texture::CLAMP_TO_EDGE},
};
glswInit();
glswSetPath("../resources/", ".glsl");
WRender::SetClearColour(0,0,0,0);
WRender::EnableCulling(true);
// - - - - - - - - - -
//setup the shaders
// - - - - - - - - - -
//normal shader
glswGetShadersAlt("shaders.Version+shaders.Shared+shaders.SingleShadow.Vertex", pVertStr, 3);
pFragStr = glswGetShaders("shaders.Version+shaders.SingleShadow.Fragment");
CShader vertexShader(CShader::VERT, pVertStr, 3);
CShader fragmentShader(CShader::FRAG, &pFragStr, 1);
program.Initialise();
program.AddShader(&vertexShader);
program.AddShader(&fragmentShader);
program.Link();
uShadowMtx = program.GetUniformLocation("shadowMtx");
program.Start();
program.SetTextureUnit("shadowMap", 0);
program.Stop();
//debug shader for textures in screen space
pVertTexStr = glswGetShaders("shaders.Version+shaders.Dbg.ScreenSpaceTexture.Vertex");
pFragTexStr = glswGetShaders("shaders.Version+shaders.Dbg.ScreenSpaceTexture.Fragment");
CShader vTexShader(CShader::VERT, &pVertTexStr, 1);
CShader fTexShader(CShader::FRAG, &pFragTexStr, 1);
textureShader.Initialise();
textureShader.AddShader(&vTexShader);
textureShader.AddShader(&fTexShader);
textureShader.Link();
textureShader.Start();
textureShader.SetTextureUnit("texture",0);
textureShader.Stop();
// - - - - - - - - - -
//set up shapes
// - - - - - - - - - -
//shared colours
abColour = WRender::CreateBuffer(WRender::ARRAY, WRender::STATIC, sizeof(colour), colour);
//Torus
nTorusVertices = 2*torusTubeSegments*torusSegments*3;
nTorusFloats = nTorusVertices*3;
pTorusVertices = new float[nTorusFloats];
CreateTorus(pTorusVertices, torusSegments, 3.0f, torusTubeSegments, 1.0f);
vaoTorus = WRender::CreateVertexArrayObject();
abTorus = WRender::CreateBuffer(WRender::ARRAY, WRender::STATIC, sizeof(float)*nTorusFloats, pTorusVertices);
WRender::BindVertexArrayObject(vaoTorus);
WRender::VertexAttribute vaTorus[2] = {
{abTorus, 0, 3, WRender::FLOAT, 0, sizeof(float)*3, 0, 0},
{abColour, 1, 3, WRender::FLOAT, 0, sizeof(float)*9, sizeof(float)*6, 1},
};
WRender::SetAttributeFormat( vaTorus, 2, 0);
delete[] pTorusVertices;
//Plane
pPlaneVertices = new float[4*3*3];
CreatePlane(pPlaneVertices, 20.0f, 20.0f);
vaoPlane = WRender::CreateVertexArrayObject();
abPlane = WRender::CreateBuffer(WRender::ARRAY, WRender::STATIC, sizeof(float)*4*3*3, pPlaneVertices);
WRender::BindVertexArrayObject(vaoPlane);
WRender::VertexAttribute vaFrustum[2] = {
{abPlane, 0, 3, WRender::FLOAT, 0, sizeof(float)*3, 0, 0},
{abColour, 1, 3, WRender::FLOAT, 0, sizeof(float)*9, sizeof(float)*3, 1},
};
WRender::SetAttributeFormat( vaFrustum, 2, 0);
delete[] pPlaneVertices;
//for screen aligned texture
sqVao = WRender::CreateVertexArrayObject();
sqEab = WRender::CreateBuffer(WRender::ELEMENTS, WRender::STATIC, sizeof(sqIndices), sqIndices);
sqAb = WRender::CreateBuffer(WRender::ARRAY, WRender::STATIC, sizeof(sqVertices), sqVertices);
WRender::BindVertexArrayObject(sqVao);
WRender::BindBuffer(WRender::ELEMENTS, sqEab);
WRender::VertexAttribute sqVa[2] = {
{sqAb, 0, 3, WRender::FLOAT, 0, sizeof(float)*5, 0, 0}, //vertices
{sqAb, 1, 2, WRender::FLOAT, 0, sizeof(float)*5, sizeof(float)*3, 0}, //texture coordinates
};
WRender::SetAttributeFormat( sqVa, 2, 0);
WRender::UnbindVertexArrayObject();
// - - - - - - - - - -
//ubo for cameras etc
// - - - - - - - - - -
ubo = WRender::CreateBuffer(WRender::UNIFORM, WRender::DYNAMIC, sizeof(Transforms), &transform);
WRender::BindBufferToIndex(WRender::UNIFORM, ubo, 1);
//create the texture and FBO for rendering to when drawing
//during shadow stage
WRender::CreateBaseTexture(depthTexture, descDepth);
WRender::SetTextureParams(depthTexture,param,4);
WRender::CreateFrameBuffer(fbo);
WRender::AddTextureRenderBuffer(fbo, depthTexture, WRender::ATT_DEPTH, 0);
WRender::BindFrameBuffer(WRender::FrameBuffer::DRAW, fbo);
WRender::SetDrawBuffer(WRender::DB_NONE);
WRender::CheckFrameBuffer(fbo);
//set the projection matrix
Transform::CreateProjectionMatrix(transforms.proj, -1.0f, 1.0f, -1.0f, 1.0f, 1.0f, 50.0f);
WRender::BindTexture(depthTexture,WRender::Texture::UNIT_0);
}
void Setup(CPlatform * const pPlatform)
{
float vertices[3] = {0,0,0};
WRender::RenderBuffer::SDescriptor rboDesc = {WRender::RenderBuffer::RGBA8, WIDTH_HEIGHT, WIDTH_HEIGHT, 0};
const char* pV = 0;
const char* pF = 0;
glswInit();
glswSetPath("../resources/", ".glsl");
//setup the textures
WRender::Texture::SDescriptor desc = {WRender::Texture::TEX_2D, WRender::Texture::RGB8, WIDTH_HEIGHT, WIDTH_HEIGHT, 0, 0, WRender::Texture::DONT_GEN_MIPMAP};
WRender::Texture::SDescriptor descDepth = {WRender::Texture::TEX_2D, WRender::Texture::DEPTH_COMPONENT, WIDTH_HEIGHT, WIDTH_HEIGHT, 0, 0, WRender::Texture::DONT_GEN_MIPMAP};
WRender::Texture::SParam param[] ={
{ WRender::Texture::MIN_FILTER, WRender::Texture::LINEAR},
{ WRender::Texture::MAG_FILTER, WRender::Texture::LINEAR},
{ WRender::Texture::WRAP_S, WRender::Texture::REPEAT},
{ WRender::Texture::WRAP_T, WRender::Texture::REPEAT},
};
WRender::CreateBaseTexture(texR, desc);
WRender::CreateBaseTexture(texG, desc);
WRender::CreateBaseTexture(texB, desc);
WRender::CreateBaseTexture(texD, descDepth);
WRender::SetTextureParams(texR,param,4);
WRender::SetTextureParams(texG,param,4);
WRender::SetTextureParams(texB,param,4);
WRender::SetTextureParams(texD,param,4);
//Setup Render Buffer
WRender::CreateRenderBuffer(rbo,rboDesc);
//setup Frame Buffer
WRender::CreateFrameBuffer(fbo);
WRender::AddTextureRenderBuffer(fbo, texR, WRender::ATT_CLR0, 0);
//WRender::AddTextureRenderBuffer(fbo, texG, WRender::ATT_CLR1, 0);
WRender::AddTextureRenderBuffer(fbo, texB, WRender::ATT_CLR2, 0);
WRender::AddRenderBuffer(fbo, rbo, WRender::ATT_CLR3);
WRender::AddTextureRenderBuffer(fbo, texD, WRender::ATT_DEPTH, 0); //FOR DEPTH INDEX DOESN'T MATTER
WRender::CheckFrameBuffer(fbo);
//setup blitting FBO
WRender::CreateFrameBuffer(fboForBlitting);
WRender::AddTextureRenderBuffer(fboForBlitting, texG, WRender::ATT_CLR0, 0);
WRender::CheckFrameBuffer(fboForBlitting);
//setup shaders
pV = glswGetShaders("shaders.Version+shaders.MRT.Stage1.Vertex");
pF = glswGetShaders("shaders.Version+shaders.MRT_2.Stage1.Fragment");
CShader vertexShader(CShader::VERT, &pV, 1);
CShader fragmentShader(CShader::FRAG, &pF, 1);
pV = glswGetShaders("shaders.Version+shaders.MRT.Stage2.Vertex");
pF = glswGetShaders("shaders.Version+shaders.MRT.Stage2.Fragment");
CShader vertexShaderStage2(CShader::VERT, &pV, 1);
CShader fragmentShaderStage2(CShader::FRAG, &pF, 1);
program[0].Initialise();
program[0].AddShader(&vertexShader);
program[0].AddShader(&fragmentShader);
program[0].Link();
program[1].Initialise();
program[1].AddShader(&vertexShaderStage2);
program[1].AddShader(&fragmentShaderStage2);
program[1].Link();
//quickly set the uniforms
program[1].Start();
program[1].SetTextureUnit("mrt",0);
program[1].Stop();
// setup vertex buffers etc
//axis
vao = WRender::CreateVertexArrayObject();
ab = WRender::CreateBuffer(WRender::ARRAY, WRender::STATIC, sizeof(vertices), vertices);
WRender::BindVertexArrayObject(vao);
WRender::VertexAttribute va[1] = {
{ab, 0, 3, WRender::FLOAT, 0, sizeof(float)*3, 0, 0}, //vertices
};
WRender::SetAttributeFormat( va, 1, 0);
WRender::UnbindVertexArrayObject();//needed
//square
sqVao = WRender::CreateVertexArrayObject();
sqEab = WRender::CreateBuffer(WRender::ELEMENTS, WRender::STATIC, sizeof(sqIndices), sqIndices);
sqAb = WRender::CreateBuffer(WRender::ARRAY, WRender::STATIC, sizeof(sqVertices), sqVertices);
WRender::BindVertexArrayObject(sqVao);
WRender::BindBuffer(WRender::ELEMENTS, sqEab);
WRender::VertexAttribute sqVa[2] = {
{sqAb, 0, 3, WRender::FLOAT, 0, sizeof(float)*5, 0, 0}, //vertices
{sqAb, 1, 2, WRender::FLOAT, 0, sizeof(float)*5, sizeof(float)*3, 0}, //texture coordinates
};
WRender::SetAttributeFormat( sqVa, 2, 0);
WRender::UnbindVertexArrayObject();
//variables for camera
float latitude = 0.0f, longitude = 0.0f;
CVec3df cameraPosition(0, 0.0f, -3.0f);
Transforms transforms;
Transform::CreateProjectionMatrix(transforms.proj, -1.0f, 1.0f, -1.0f, 1.0f, 1.0f, 10.0f); //for rendering first time aorund
WRender::EnableDepthTest(true);
}
