// build a program with a vertex shader and a fragment shader
GLuint buildProgram(const std::string vertexFile, const std::string fragmentFile)
{
auto vshader = buildShader(GL_VERTEX_SHADER, fileGetContents(vertexFile));
auto fshader = buildShader(GL_FRAGMENT_SHADER, fileGetContents(fragmentFile));
GLuint program = glCreateProgram();
glAttachShader(program, vshader);
glAttachShader(program, fshader);
glLinkProgram(program);
GLint res;
glGetProgramiv(program, GL_LINK_STATUS, &res);
if(!res)
{
std::cerr << "program link error" << std::endl;
char message[1000];
GLsizei readSize;
glGetProgramInfoLog(program, 1000, &readSize, message);
message[999] = '/0';
std::cerr << message << std::endl;
glfwTerminate();
exit(-1);
}
return program;
}
Program::Program(const ProgramDescription& description, const char* vertex, const char* fragment) {
mInitialized = false;
mHasColorUniform = false;
mHasSampler = false;
mUse = false;
// No need to cache compiled shaders, rely instead on Android's
// persistent shaders cache
mVertexShader = buildShader(vertex, GL_VERTEX_SHADER);
if (mVertexShader) {
mFragmentShader = buildShader(fragment, GL_FRAGMENT_SHADER);
if (mFragmentShader) {
mProgramId = glCreateProgram();
glAttachShader(mProgramId, mVertexShader);
glAttachShader(mProgramId, mFragmentShader);
bindAttrib("position", kBindingPosition);
if (description.hasTexture || description.hasExternalTexture) {
texCoords = bindAttrib("texCoords", kBindingTexCoords);
} else {
texCoords = -1;
}
ATRACE_BEGIN("linkProgram");
glLinkProgram(mProgramId);
ATRACE_END();
GLint status;
glGetProgramiv(mProgramId, GL_LINK_STATUS, &status);
if (status != GL_TRUE) {
GLint infoLen = 0;
glGetProgramiv(mProgramId, GL_INFO_LOG_LENGTH, &infoLen);
if (infoLen > 1) {
GLchar log[infoLen];
glGetProgramInfoLog(mProgramId, infoLen, nullptr, &log[0]);
ALOGE("%s", log);
}
LOG_ALWAYS_FATAL("Error while linking shaders");
} else {
mInitialized = true;
}
} else {
glDeleteShader(mVertexShader);
}
}
if (mInitialized) {
transform = addUniform("transform");
projection = addUniform("projection");
}
}
Program::Program(const ProgramCache::Key& /*needs*/, const char* vertex, const char* fragment)
: mInitialized(false) {
GLuint vertexId = buildShader(vertex, GL_VERTEX_SHADER);
GLuint fragmentId = buildShader(fragment, GL_FRAGMENT_SHADER);
GLuint programId = glCreateProgram();
glAttachShader(programId, vertexId);
glAttachShader(programId, fragmentId);
glBindAttribLocation(programId, position, "position");
glBindAttribLocation(programId, texCoords, "texCoords");
glLinkProgram(programId);
GLint status;
glGetProgramiv(programId, GL_LINK_STATUS, &status);
if (status != GL_TRUE) {
ALOGE("Error while linking shaders:");
GLint infoLen = 0;
glGetProgramiv(programId, GL_INFO_LOG_LENGTH, &infoLen);
if (infoLen > 1) {
GLchar log[infoLen];
glGetProgramInfoLog(programId, infoLen, 0, &log[0]);
ALOGE("%s", log);
}
glDetachShader(programId, vertexId);
glDetachShader(programId, fragmentId);
glDeleteShader(vertexId);
glDeleteShader(fragmentId);
glDeleteProgram(programId);
} else {
mProgram = programId;
mVertexShader = vertexId;
mFragmentShader = fragmentId;
mInitialized = true;
mColorMatrixLoc = glGetUniformLocation(programId, "colorMatrix");
mProjectionMatrixLoc = glGetUniformLocation(programId, "projection");
mTextureMatrixLoc = glGetUniformLocation(programId, "texture");
mSamplerLoc = glGetUniformLocation(programId, "sampler");
mColorLoc = glGetUniformLocation(programId, "color");
mAlphaPlaneLoc = glGetUniformLocation(programId, "alphaPlane");
mSamplerMaskLoc = glGetUniformLocation(programId, "samplerMask");
mMaskAlphaThresholdLoc = glGetUniformLocation(programId, "maskAlphaThreshold");
// set-up the default values for our uniforms
glUseProgram(programId);
const GLfloat m[16] = {1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1 };
glUniformMatrix4fv(mProjectionMatrixLoc, 1, GL_FALSE, m);
glEnableVertexAttribArray(0);
}
}
GLuint GlHelper::createProgram(const char *vertexShaderFunc,
const char *fragShaderFunc) {
GLuint vertexShader = GlHelper::buildShader(vertexShaderFunc,
GL_VERTEX_SHADER);
GLuint fragmentShader = buildShader(fragShaderFunc,
GL_FRAGMENT_SHADER);
GLuint programHandle = glCreateProgram();
if (programHandle) {
glAttachShader(programHandle, vertexShader);
checkGlError("glAttachShader");
glAttachShader(programHandle, fragmentShader);
checkGlError("glAttachShader");
glLinkProgram(programHandle);
GLint linkStatus = GL_FALSE;
glGetProgramiv(programHandle, GL_LINK_STATUS, &linkStatus);
if (linkStatus != GL_TRUE) {
GLint bufLength = 0;
glGetProgramiv(programHandle, GL_INFO_LOG_LENGTH, &bufLength);
if (bufLength) {
char* buf = (char*) malloc(bufLength);
if (buf) {
glGetProgramInfoLog(programHandle, bufLength, NULL, buf);
LOGE("error::Could not link program:\n%s\n", buf);
free(buf);
}
}
glDeleteProgram(programHandle);
programHandle = 0;
}
}
return programHandle;
}
bool glfwTest::Init()
{
if (!App::Init())
return false;
buildShader();
buildGeometryBuffers();
printHint();
return true;
}
void ofApp::keyPressed(int key) {
if(key == '\\') {
ofSaveImage(audioPixels, ofToString(curCount++) + ".png");
}
time = 0;
string source = OneLiner::build();
cout << source << endl;
shader.unload();
shader.setupShaderFromSource(GL_FRAGMENT_SHADER, buildShader(source));
shader.linkProgram();
}
Program::Program(const char* vertex, const char* fragment) {
mInitialized = false;
vertexShader = buildShader(vertex, GL_VERTEX_SHADER);
if (vertexShader) {
fragmentShader = buildShader(fragment, GL_FRAGMENT_SHADER);
if (fragmentShader) {
id = glCreateProgram();
glAttachShader(id, vertexShader);
glAttachShader(id, fragmentShader);
glLinkProgram(id);
GLint status;
glGetProgramiv(id, GL_LINK_STATUS, &status);
if (status != GL_TRUE) {
LOGE("Error while linking shaders:");
GLint infoLen = 0;
glGetProgramiv(id, GL_INFO_LOG_LENGTH, &infoLen);
if (infoLen > 1) {
GLchar log[infoLen];
glGetProgramInfoLog(id, infoLen, 0, &log[0]);
LOGE("%s", log);
}
glDeleteShader(vertexShader);
glDeleteShader(fragmentShader);
glDeleteProgram(id);
} else {
mInitialized = true;
}
}
}
mUse = false;
if (mInitialized) {
position = addAttrib("position");
transform = addUniform("transform");
}
}
GLuint RenderingEngine::buildProgram(const char* vertexShaderSource, const char* fragmentShaderSource) const
{
GLuint vertexShader = buildShader(vertexShaderSource, GL_VERTEX_SHADER);
GLuint fragmentShader = buildShader(fragmentShaderSource, GL_FRAGMENT_SHADER);
GLuint programHandle = glCreateProgram();
glAttachShader(programHandle, vertexShader);
glAttachShader(programHandle, fragmentShader);
glLinkProgram(programHandle);
GLint linkSuccess;
glGetProgramiv(programHandle, GL_LINK_STATUS, &linkSuccess);
if (linkSuccess == GL_FALSE) {
GLchar messages[256];
glGetProgramInfoLog(programHandle, sizeof(messages), 0, &messages[0]);
std::cout << messages;
exit(1);
}
return programHandle;
}
Shader::Shader(GL3ShaderManager *manager, const char *vert_src, const char *frag_src) :
_manager(manager)
{
GLuint VertexShaderLoc = glCreateShader(GL_VERTEX_SHADER);
GLuint FragmentShaderLoc = glCreateShader(GL_FRAGMENT_SHADER);
LOG_TRACE(logger) << "Building '" << vert_src << "'";
buildShader(VertexShaderLoc, vert_src);
LOG_TRACE(logger) << "Building '" << frag_src << "'";
buildShader(FragmentShaderLoc, frag_src);
_programLocation = glCreateProgram();
GLuint ProgramShaderLocs[2] = {VertexShaderLoc, FragmentShaderLoc};
LOG_TRACE(logger) << "Building program";
buildProgram(_programLocation, ProgramShaderLocs, 2);
glDeleteShader(VertexShaderLoc);
glDeleteShader(FragmentShaderLoc);
LOG_OPENGL_ERROR;
}
GLuint buildShaderFile(const char *vert_fn, const char *frag_fn, const char *prepend_src)
{
char *vert_src = readShaderFile(vert_fn);
char *frag_src = readShaderFile(frag_fn);
GLuint ret = 0;
if (vert_src && frag_src) {
ret = buildShader(vert_src, frag_src, prepend_src);
}
free(vert_src);
free(frag_src);
return ret;
}
ShaderProgram buildProgram(const char* vertexShaderSource, const char* fragmentShaderSource, ShaderProgram &program) {
program.vertexShader = buildShader(vertexShaderSource, GL_VERTEX_SHADER);
program.fragmentShader = buildShader(fragmentShaderSource, GL_FRAGMENT_SHADER);
program.program = glCreateProgram();
glAttachShader(program.program, program.vertexShader);
glAttachShader(program.program, program.fragmentShader);
glLinkProgram(program.program);
GLint linkSuccess;
glGetProgramiv(program.program, GL_LINK_STATUS, &linkSuccess);
if (linkSuccess == GL_FALSE) {
GLchar messages[256];
glGetProgramInfoLog(program.program, sizeof(messages), 0, &messages[0]);
std::cout << messages;
exit(1);
}
program.attributes.position = glGetAttribLocation(program.program, "Position");
program.attributes.normal = glGetAttribLocation(program.program, "Normal");
program.attributes.diffuseMaterial = glGetAttribLocation(program.program, "DiffuseMaterial");
program.attributes.textureCoord = glGetAttribLocation(program.program, "TextureCoord");
program.uniforms.projection = glGetUniformLocation(program.program, "Projection");
program.uniforms.modelview = glGetUniformLocation(program.program, "Modelview");
program.uniforms.normalMatrix = glGetUniformLocation(program.program, "NormalMatrix");
program.uniforms.textureMatrix = glGetUniformLocation(program.program, "TextureMatrix");
program.uniforms.ambientMaterial = glGetUniformLocation(program.program, "AmbientMaterial");
program.uniforms.specularMaterial = glGetUniformLocation(program.program, "SpecularMaterial");
program.uniforms.shininess = glGetUniformLocation(program.program, "Shininess");
program.uniforms.samplers = new GLuint[program.numTextures];
for (int i = 0; i < program.numTextures; i++) {
stringstream ss;
ss << "Sampler" << i;
string samplerName = ss.str();
program.uniforms.samplers[i] = glGetUniformLocation(program.program, samplerName.c_str());
}
return program;
}
GLuint KMShader::buildShaderProgram(const char* vertexShaderSource, const char* fragmentShaderSource)
{
GLuint vertexShader = buildShader(vertexShaderSource, GL_VERTEX_SHADER);
GLuint fragmentShader = buildShader(fragmentShaderSource, GL_FRAGMENT_SHADER);
GLuint programHandle = glCreateProgram();
glAttachShader(programHandle, vertexShader);
glAttachShader(programHandle, fragmentShader);
glLinkProgram(programHandle);
GLint linkSuccess;
glGetProgramiv(programHandle, GL_LINK_STATUS, &linkSuccess);
if (linkSuccess == GL_FALSE)
{
GLchar messages[256];
glGetProgramInfoLog(programHandle, sizeof(messages), 0, &messages[0]);
KMLOG("Error building shaderProgram: %s", messages);
exit(1);
}
return programHandle;
}
static GLuint buildProgram(const char* vertexShaderSource,
const char* fragmentShaderSource)
{
GLuint vertexShader = buildShader(vertexShaderSource, GL_VERTEX_SHADER);
GLuint fragmentShader = buildShader(fragmentShaderSource, GL_FRAGMENT_SHADER);
GLuint programHandle = glCreateProgram();
if (programHandle)
{
glAttachShader(programHandle, vertexShader);
checkGlError("glAttachShader");
glAttachShader(programHandle, fragmentShader);
checkGlError("glAttachShader");
glLinkProgram(programHandle);
GLint linkStatus = GL_FALSE;
glGetProgramiv(programHandle, GL_LINK_STATUS, &linkStatus);
if (linkStatus != GL_TRUE) {
GLint bufLength = 0;
glGetProgramiv(programHandle, GL_INFO_LOG_LENGTH, &bufLength);
if (bufLength) {
char* buf = (char*) malloc(bufLength);
if (buf) {
glGetProgramInfoLog(programHandle, bufLength, NULL, buf);
__android_log_print(ANDROID_LOG_DEBUG, LOG_TAG," error: Could not link programe: %s\n", buf);
free(buf);
}
}
glDeleteProgram(programHandle);
programHandle = 0;
}
}
return programHandle;
}
void glInit2(GLsizei w, GLsizei h)
{
width = w;
height = h;
glViewport(0, 0, w, h);
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
glEnable(GL_DEPTH_TEST|GL_BLEND);
glClearDepthf(1.0f);
glDepthFunc(GL_LEQUAL); //Éî¶È²âÊÔ·½Ê½
initPerspetive();
buildShader(&prog,VSRC_0,FSRC_0);
uploadData();
//fileTest();
}
//
// Vulkan initialization.
//
VkBool32 Example::init(const vkts::IUpdateThreadContext& updateContext)
{
if (!updateContext.isDisplayAttached(displayIndex))
{
return VK_FALSE;
}
if (!updateContext.isWindowAttached(windowIndex))
{
return VK_FALSE;
}
windowDimension = updateContext.getWindowDimension(windowIndex);
//
VkResult result;
//
if (!vkts::wsiGatherNeededInstanceExtensions())
{
vkts::logPrint(VKTS_LOG_WARNING, "Example: Could not gather instance extensions.");
return VK_TRUE;
}
instance = vkts::instanceCreate(VKTS_EXAMPLE_NAME, VK_MAKE_VERSION(1, 0, 0), VK_MAKE_VERSION(1, 0, 0), 0, 0, nullptr, vkts::extensionGetNeededInstanceExtensionCount(), vkts::extensionGetNeededInstanceExtensionNames());
if (!instance.get())
{
vkts::logPrint(VKTS_LOG_ERROR, "Example: Could not create instance.");
return VK_FALSE;
}
if (!vkts::wsiInitInstanceExtensions(instance->getInstance()))
{
vkts::logPrint(VKTS_LOG_ERROR, "Example: Could not initialize instance extension.");
return VK_FALSE;
}
physicalDevice = vkts::physicalDeviceCreate(instance->getInstance(), 0);
if (!physicalDevice.get())
{
vkts::logPrint(VKTS_LOG_ERROR, "Example: Could not get physical device.");
return VK_FALSE;
}
if (!vkts::wsiGatherNeededDeviceExtensions(physicalDevice->getPhysicalDevice()))
{
vkts::logPrint(VKTS_LOG_ERROR, "Example: Could not gather device extension.");
return VK_FALSE;
}
//
surface = vkts::wsiSurfaceCreate(instance->getInstance(), updateContext.getNativeDisplay(displayIndex), updateContext.getNativeWindow(windowIndex));
if (!surface.get())
{
vkts::logPrint(VKTS_LOG_ERROR, "Example: Could not create surface.");
return VK_FALSE;
}
//
std::vector<VkBool32> supportFilter;
result = vkts::wsiGetPhysicalDeviceSurfaceSupport(physicalDevice->getPhysicalDevice(), surface->getSurface(), (uint32_t) physicalDevice->getAllQueueFamilyProperties().size(), supportFilter);
if (result != VK_SUCCESS || supportFilter.size() == 0)
{
vkts::logPrint(VKTS_LOG_ERROR, "Example: Could not get physical device surface support.");
return VK_FALSE;
}
//
uint32_t queueFamilyIndex;
if (!vkts::queueGetFamilyIndex(physicalDevice->getAllQueueFamilyProperties(), VK_QUEUE_GRAPHICS_BIT, 0, &supportFilter, queueFamilyIndex))
{
vkts::logPrint(VKTS_LOG_ERROR, "Example: Could not find queue family index.");
return VK_FALSE;
}
//
float queuePriorities[1] = {0.0f};
VkDeviceQueueCreateInfo deviceQueueCreateInfo;
memset(&deviceQueueCreateInfo, 0, sizeof(VkDeviceQueueCreateInfo));
deviceQueueCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
deviceQueueCreateInfo.flags = 0;
deviceQueueCreateInfo.queueFamilyIndex = 0;
deviceQueueCreateInfo.queueCount = 1;
deviceQueueCreateInfo.pQueuePriorities = queuePriorities;
device = vkts::deviceCreate(physicalDevice->getPhysicalDevice(), 0, 1, &deviceQueueCreateInfo, 0, nullptr, vkts::extensionGetNeededDeviceExtensionCount(), vkts::extensionGetNeededDeviceExtensionNames(), nullptr);
if (!device.get())
{
vkts::logPrint(VKTS_LOG_ERROR, "Test: Could not create device.");
return VK_FALSE;
}
if (!vkts::wsiInitDeviceExtensions(device->getDevice()))
{
vkts::logPrint(VKTS_LOG_ERROR, "Example: Could not initialize device extension.");
return VK_FALSE;
}
//
queue = vkts::queueGet(device->getDevice(), queueFamilyIndex, 0);
if (!queue.get())
{
vkts::logPrint(VKTS_LOG_ERROR, "Example: Could not get device queue.");
return VK_FALSE;
}
//
commandPool = vkts::commandPoolCreate(device->getDevice(), 0, queue->getQueueFamilyIndex());
if (!commandPool.get())
{
vkts::logPrint(VKTS_LOG_ERROR, "Example: Could not get command pool.");
return VK_FALSE;
}
//
imageAcquiredSemaphore = vkts::semaphoreCreate(device->getDevice(), 0);
if (!imageAcquiredSemaphore.get())
{
vkts::logPrint(VKTS_LOG_ERROR, "Example: Could not create semaphore.");
return VK_FALSE;
}
renderingCompleteSemaphore = vkts::semaphoreCreate(device->getDevice(), 0);
if (!renderingCompleteSemaphore.get())
{
vkts::logPrint(VKTS_LOG_ERROR, "Example: Could not create semaphore.");
return VK_FALSE;
}
//
if (!buildVertexBuffer())
{
vkts::logPrint(VKTS_LOG_ERROR, "Example: Could not build vertex buffer.");
return VK_FALSE;
}
if (!buildShader())
{
vkts::logPrint(VKTS_LOG_ERROR, "Example: Could not build shader.");
return VK_FALSE;
}
if (!buildPipelineCache())
{
vkts::logPrint(VKTS_LOG_ERROR, "Example: Could not build pipeline cache.");
return VK_FALSE;
}
if (!buildPipelineLayout())
{
vkts::logPrint(VKTS_LOG_ERROR, "Example: Could not build pipeline layout.");
return VK_FALSE;
}
//
if (!buildResources(updateContext))
{
vkts::logPrint(VKTS_LOG_ERROR, "Example: Could not build resources.");
return VK_FALSE;
}
return VK_TRUE;
}
void OglRenderer::init(uint wi,uint he)
{
texVelocity.intFormat = GL_RG;
texVelocity.format = GL_RG;
//texVelocity.type = GL_FLOAT;
texColor.intFormat = GL_RGBA;
texColor.format = GL_RGBA;
vector<OglTexTarget*> textars;
textars.push_back( &texColor );
textars.push_back( &texNormal );
textars.push_back( &texVelocity );
GBuffer.init( textars, DEPTHBUF_TEXTURE, wi, he );
textars.clear( );
DirLBuffer.init( textars, DEPTHBUF_TEXTURE | DEPTHBUF_LINEAR | DEPTHBUF_SHADOW, 1024, 1024 );
texNum = 2;
cnt = 0;
for ( int i = 0; i < texNum; i++ )
{
textars.clear();
texAA[i].intFormat = GL_RGBA;
texAA[i].format = GL_RGBA;
texAA[i].magFilter = GL_LINEAR;
texAA[i].minFilter = GL_LINEAR;
texAA[i].clampBorder = true;
textars.push_back( &texAA[i] );
AABuffer[i].init( textars, 0, wi, he );
}
AAp = 0;
textars.clear( );
texAATemp.intFormat = GL_RGBA;
texAATemp.format = GL_RGBA;
texAATemp.magFilter = GL_LINEAR;
texAATemp.minFilter = GL_LINEAR;
textars.push_back( &texAATemp );
AATemp.init( textars, 0, wi, he );
textars.clear( );
texAO.intFormat = GL_RG32F;
texAO.format = GL_RG;
//texAO.type = GL_FLOAT;
texAO.magFilter = GL_LINEAR;
texAO.minFilter = GL_LINEAR;
texAO.clampBorder = true;
textars.push_back( &texAO );
AOBuffer.init( textars, 0, wi/2-1, he/2-1 );
createRandomTexture();
floorTex.magFilter = GL_LINEAR;
floorTex.minFilter = GL_LINEAR;
floorTex.init("floor.jpg",true);
DIR *d;
struct dirent *dir;
d = opendir( "shaders" );
int i = 0;
if ( d )
{
while ( (dir = readdir( d )) != NULL )
{
if ( i > 1 )
{
string name = dir->d_name;
string subname = name.substr( name.length() - 4, 4 );
if ( subname == ".vsh" )
{
cout << "vertex: " << name << endl;
string compileName = "shaders\\" + name;
OglVertexShader vsh; vsh.compile( compileName.c_str() );
vsh.notDelete();
shVertex[name] = vsh;
}
else if ( subname == ".fsh" )
{
cout << "fragment: " << name << endl;
string compileName = "shaders\\" + name;
OglFragmentShader fsh; fsh.compile( compileName.c_str( ) );
fsh.notDelete();
shFragment[name] = fsh;
}
else
cout << "error reading shader " << name << endl;
}
i++;
}
closedir( d );
}
buildShader( "GBuff", "GBuff.vsh", "GBuff.fsh" );
buildShader( "GBuffFloor", "GBuff.vsh", "GBuffFloor.fsh" );
buildShader( "GBuffAA", "GBuffAA.vsh", "GBuffAA.fsh" );
buildShader( "AmbQ", "Quad.vsh", "AmbQ.fsh" );
buildShader( "AmbDirQ", "Quad.vsh", "AmbDirQ.fsh" );
buildShader( "AmbDirShadowQ", "QuadInv.vsh", "AmbDirShadowQ.fsh" );
buildShader( "Quad", "Quad.vsh", "Quad.fsh" );
buildShader( "QuadFXAA", "Quad.vsh", "QuadFXAA.fsh");
buildShader( "QuadAA", "Quad.vsh", "QuadAA.fsh" );
buildShader( "Blur", "Quad.vsh", "Blur.fsh" );
buildShader( "ShadowMap", "ShadowMap.vsh", "ShadowMap.fsh" );
buildShader( "EVSMGauss", "Quad.vsh", "EVSMGauss.fsh" );
buildShader( "EVSMGaussV", "Quad.vsh", "EVSMGaussV.fsh" );
buildShader( "AO", "QuadInv.vsh", "AO.fsh" );
activeShader = 0;
MeshFullscreenQuad quad;
quad.init( BUF_POS | BUF_UV );
bufQuad.init( BUF_POS | BUF_UV );
quad.toBuffs( bufQuad );
bufQuad.postInit( );
lastWiggle = glm::vec3( 0, 0, 0 );
wp = 0;
rx[0] = 0.16; ry[0] = 0.35;
rx[1] = 0.82; ry[1] = 0.20;
rx[2] = 0.40; ry[2] = 0.88;
rx[3] = 0.84; ry[3] = 0.69;
enableBuffer( &AABuffer[0], true );
enableBuffer( &AABuffer[1], true );
}
//
// Vulkan initialization.
//
VkBool32 Example::init(const vkts::IUpdateThreadContext& updateContext)
{
fence = vkts::fenceCreate(device->getDevice(), 0);
if (!fence.get())
{
vkts::logPrint(VKTS_LOG_ERROR, __FILE__, __LINE__, "Could not build fence.");
return VK_FALSE;
}
if (!buildShader())
{
vkts::logPrint(VKTS_LOG_ERROR, __FILE__, __LINE__, "Could not build shader.");
return VK_FALSE;
}
if (!buildCmdPool())
{
vkts::logPrint(VKTS_LOG_ERROR, __FILE__, __LINE__, "Could not build command pool.");
return VK_FALSE;
}
//
if (!buildTexture())
{
vkts::logPrint(VKTS_LOG_ERROR, __FILE__, __LINE__, "Could not build texture.");
return VK_FALSE;
}
//
if (!buildDescriptorSetLayout())
{
vkts::logPrint(VKTS_LOG_ERROR, __FILE__, __LINE__, "Could not build descriptor set layout.");
return VK_FALSE;
}
if (!buildDescriptorSetPool())
{
vkts::logPrint(VKTS_LOG_ERROR, __FILE__, __LINE__, "Could not build descriptor set pool.");
return VK_FALSE;
}
if (!buildDescriptorSets())
{
vkts::logPrint(VKTS_LOG_ERROR, __FILE__, __LINE__, "Could not build descriptor sets.");
return VK_FALSE;
}
if (!buildPipelineLayout())
{
vkts::logPrint(VKTS_LOG_ERROR, __FILE__, __LINE__, "Could not build pipeline layout.");
return VK_FALSE;
}
if (!buildPipeline())
{
vkts::logPrint(VKTS_LOG_ERROR, __FILE__, __LINE__, "Could not build pipeline.");
return VK_FALSE;
}
if (!buildCmdBuffer())
{
vkts::logPrint(VKTS_LOG_ERROR, __FILE__, __LINE__, "Could not build command buffer.");
return VK_FALSE;
}
return VK_TRUE;
}
//
// Vulkan initialization.
//
VkBool32 Example::init(const vkts::IUpdateThreadContext& updateContext)
{
if (!updateContext.isWindowAttached(windowIndex))
{
return VK_FALSE;
}
windowDimension = updateContext.getWindowDimension(windowIndex);
//
camera = vkts::cameraCreate(glm::vec4(0.0f, 4.0f, 10.0f, 1.0f), glm::vec4(0.0f, 2.0f, 0.0f, 1.0f));
if (!camera.get())
{
return VK_FALSE;
}
allUpdateables.append(camera);
inputController = vkts::inputControllerCreate(updateContext, windowIndex, 0, camera);
if (!inputController.get())
{
return VK_FALSE;
}
allUpdateables.insert(0, inputController);
//
commandPool = vkts::commandPoolCreate(initialResources->getDevice()->getDevice(), 0, initialResources->getQueue()->getQueueFamilyIndex());
if (!commandPool.get())
{
vkts::logPrint(VKTS_LOG_ERROR, "Example: Could not get command pool.");
return VK_FALSE;
}
//
imageAcquiredSemaphore = vkts::semaphoreCreate(initialResources->getDevice()->getDevice(), 0);
if (!imageAcquiredSemaphore.get())
{
vkts::logPrint(VKTS_LOG_ERROR, "Example: Could not create semaphore.");
return VK_FALSE;
}
renderingCompleteSemaphore = vkts::semaphoreCreate(initialResources->getDevice()->getDevice(), 0);
if (!renderingCompleteSemaphore.get())
{
vkts::logPrint(VKTS_LOG_ERROR, "Example: Could not create semaphore.");
return VK_FALSE;
}
//
if (!buildUniformBuffers())
{
vkts::logPrint(VKTS_LOG_ERROR, "Example: Could not build uniform buffers.");
return VK_FALSE;
}
if (!buildShader())
{
vkts::logPrint(VKTS_LOG_ERROR, "Example: Could not build shader.");
return VK_FALSE;
}
if (!buildDescriptorSetLayout())
{
vkts::logPrint(VKTS_LOG_ERROR, "Example: Could not build descriptor set layout.");
return VK_FALSE;
}
if (!buildPipelineLayout())
{
vkts::logPrint(VKTS_LOG_ERROR, "Example: Could not build pipeline cache.");
return VK_FALSE;
}
//
if (!buildResources(updateContext))
{
vkts::logPrint(VKTS_LOG_ERROR, "Example: Could not build resources.");
return VK_FALSE;
}
//
glm::vec3 lightDirection = glm::vec3(0.0f, 1.0f, 2.0f);
lightDirection = glm::normalize(lightDirection);
if (!fragmentUniformBuffer->upload(0, 0, lightDirection))
{
vkts::logPrint(VKTS_LOG_ERROR, "Example: Could not upload light direction.");
return VK_FALSE;
}
return VK_TRUE;
}
// setup
int main(int argc, char *argv[])
{
GLenum err = 0;
/*********************************************
* GLFW SETUP
*********************************************/
err = glfwInit();
if (!err)
{
fputs("Failed to load the GLFW library", stderr);
exit(EXIT_FAILURE);
}
/*********************************************
* STATE SETUP (initialize gl context)
*********************************************/
// must be setup before glew so that a valid openGL
// context exists (created with the window)
w_state = new WorldState();
c_state.init(*w_state);
/*********************************************
* GLEW SETUP
*********************************************/
err = glewInit();
if (err != GLEW_OK)
{
fputs("Failed to initialize the GLEW library", stderr);
exit(EXIT_FAILURE);
}
/*********************************************
* STATE SETUP (construct render states)
*********************************************/
// must be setup after glew so that GL array
// objects exist
r_state[0] = new RenderState(3);
r_state[1] = new RenderState(3);
/*********************************************
* SHADER SETUP
*********************************************/
// read default shaders from file
GLuint shaderProgram[2] = {0};
GLuint shaders[2] = {0};
buildShader(GL_VERTEX_SHADER, "default.vs.glsl", shaders[0]);
buildShader(GL_FRAGMENT_SHADER, "default.fs.glsl", shaders[1]);
// create default shader program
shaderProgram[0] = buildProgram(2, shaders);
// bind shader program
w_state->setProgram(0, shaderProgram[0]);
w_state->useProgram(0);
// setup the transform matrices and uniform variables
w_state->loadTransforms();
w_state->loadLights();
w_state->loadMaterials();
/*********************************************
* LOAD MESH
*********************************************/
g_mesh = loadMeshFromFile(*r_state[0], "Mesh/arma.obj");
/*********************************************
* SET GL STATE
*********************************************/
glEnable(GL_DEPTH_TEST);
/*********************************************
* RENDER LOOP
*********************************************/
glfwSetTime(0.0);
while (!glfwWindowShouldClose(c_state.window))
display();
/*********************************************
* CLEAN UP
*********************************************/
delete g_mesh;
glfwTerminate();
exit(EXIT_SUCCESS);
}
