void HeightMap::keyEvent(SDL_Keysym &key, bool press) {
if (!press) {
return;
}
switch(key.sym) {
case SDLK_a:
if (_vertsPerSide < 1024) {
_vertsPerSide *= 2;
_totalVerts = _vertsPerSide * 2 * (_vertsPerSide - 1);
glUniform1i(_vpsLoc, _vertsPerSide);
checkGLError("Error encountered updating Vertices Per Side count: %s\n", Logger::LOG_WARN);
}
break;
case SDLK_z:
if (_vertsPerSide > 4) {
_vertsPerSide /= 2;
_totalVerts = _vertsPerSide * 2 * (_vertsPerSide - 1);
glUniform1i(_vpsLoc, _vertsPerSide);
checkGLError("Error encountered updating Vertices Per Side count: %s\n", Logger::LOG_WARN);
}
break;
case SDLK_d:
_drawMode = GL_TRIANGLE_STRIP;
running &= buildShaderProgram(VERTEX_SHADER, "heightmap-debugfrag.sdr");
loadUniforms();
break;
case SDLK_c:
_drawMode = GL_TRIANGLE_STRIP;
running &= buildShaderProgram(VERTEX_SHADER, FRAGMENT_SHADER);
loadUniforms();
break;
case SDLK_p:
glPointSize(2.0);
_drawMode = GL_POINTS;
running &= buildShaderProgram(VERTEX_SHADER, "heightmap-pointdebug.sdr");
loadUniforms();
break;
case SDLK_f:
_flatten = !_flatten;
glUniform1i(_flattenLoc, _flatten);
break;
case SDLK_s:
if (_zPlane < 4.0f) {
_zPlane += 0.1f;
}
break;
case SDLK_x:
if (_zPlane > 0.0f) {
_zPlane -= 0.1f;
}
break;
}
}
dx11ShaderProgram::dx11ShaderProgram(const char *vshader, const char *pshader,int flags,
const ConstantDesc *uniforms, const DataDesc *attributes) {
bool fromCode=(flags&ShaderProgram::Flag_FromCode);
long VSLen, PSLen;
void *VSFile = fromCode?NULL:LoadShaderFile(vshader, "cso", &VSLen);
if (!VSFile) {
void *src = fromCode?(void *)vshader:LoadShaderFile(vshader, "hlsl", &VSLen);
ID3DBlob *pCode;
ID3DBlob *pError;
if (fromCode&&vshader)
VSLen = strlen(vshader);
D3DCompile(src, VSLen, vshader, NULL, NULL, "VShader",
"vs_4_0_level_9_3", D3DCOMPILE_PREFER_FLOW_CONTROL, 0, &pCode, &pError);
if (src&&(!fromCode))
free(src);
if (pError) {
errorLog.append("VertexShader:\n");
errorLog.append((char *) pError->GetBufferPointer(),
pError->GetBufferSize());
errorLog.append("\n");
pError->Release();
}
if (pCode) {
VSLen = pCode->GetBufferSize();
VSFile = malloc(VSLen);
memcpy(VSFile, pCode->GetBufferPointer(), VSLen);
pCode->Release();
}
}
void *PSFile = fromCode?NULL:LoadShaderFile(pshader, "cso", &PSLen);
if (!PSFile) {
void *src = fromCode?(void *)pshader:LoadShaderFile(pshader, "hlsl", &PSLen);
ID3DBlob *pCode;
ID3DBlob *pError;
if (fromCode&&pshader)
PSLen = strlen(pshader);
D3DCompile(src, PSLen, pshader, NULL, NULL, "PShader",
"ps_4_0_level_9_3", D3DCOMPILE_PREFER_FLOW_CONTROL, 0, &pCode, &pError);
if (src&&(!fromCode))
free(src);
if (pError) {
errorLog.append("PixelShader:\n");
errorLog.append((char *) pError->GetBufferPointer(),
pError->GetBufferSize());
errorLog.append("\n");
pError->Release();
}
if (pCode) {
PSLen = pCode->GetBufferSize();
PSFile = malloc(PSLen);
memcpy(PSFile, pCode->GetBufferPointer(), PSLen);
pCode->Release();
}
}
buildShaderProgram(VSFile, VSLen, PSFile, PSLen, flags, uniforms, attributes);
if (VSFile)
free(VSFile);
if (PSFile)
free(PSFile);
}
void ObjObject::initialize()
{
textureObject = setupTexture( textureName );
buildShaderProgram();
glUseProgram(shaderProgram);
initObj();
}
void Box::initialize()
{
textureObject = setupTexture( "earth.bmp" );
buildShaderProgram();
glUseProgram(shaderProgram);
initTopBottomBack();
initSides();
}
// Construct visual object display list.
void Cylinder::initialize()
{
textureObject = setupTexture( "test.bmp" );
buildShaderProgram();
initializeCylinderBottom();
initializeCylinderBody();
initializeCylinderTop();
VisualObject::initialize();
} // end initialize
void HeightMap::appInit() {
bool shaderReady = buildShaderProgram(VERTEX_SHADER, FRAGMENT_SHADER);
if (!shaderReady) {
exit(1);
}
loadUniforms();
glGenVertexArrays(1, &_vertexArray);
glBindVertexArray(_vertexArray);
resizeWindow(400, 400);
running &= checkGLError("Error encountered binding Texture Sampler: %s\n", Logger::LOG_ERROR);
glEnable(GL_DEPTH_TEST);
running &= checkGLError("Error encountered enabling Depth Buffer: %s\n", Logger::LOG_ERROR);
glClearColor(0.2f, 0.2f, 0.2f, 1.0f);
}
int main () {
assert (restart_gl_log ());
Rendebal_Object ro;
GLuint shader_programme;
GLfloat points[] = {
0.0f, 0.5f, 0.0f,
0.5f, -0.5f, 0.0f,
-0.5f, -0.5f, 0.0f
};
std::string vs = loadFileToString("Resources/basic.vert");
std::string fs = loadFileToString("Resources/basic.frag");
const char* vertex_shader = vs.c_str();
const char* fragment_shader = fs.c_str();
struct render_object object;
object.points = points;
object.pointsSize = 9;
GLFWwindow* window;
window = CreateGLFWWindow(false);
loadVertexToGPU(&object, &ro);
shader_programme = buildShaderProgram(vertex_shader, fragment_shader);
ro.shader_programme = shader_programme;
mainLoop(ro, window);
// close GL context and any other GLFW resources
glfwTerminate();
return 0;
}
// Construct visual object display list.
void Wall::initialize()
{
//textureObject = setupTexture( this->textureFileName);
textureObject = setupTexture( "stone_texture_012_stacked_slate.bmp");//this->textureFileName);
buildShaderProgram( );
// vector containers to hold data
vector<pntVertexData> v; // vertex positions
vector<unsigned int> indices; // indices
GLuint VBO, IBO; // Identifiers for buffer objects
vec3 n = vec3( 0.0f, 0.0f, 1.0f);
vec3 v0 = vec3( -width/2, 0.0f, 0.0f);
vec3 v1 = vec3( width/2, 0.0f, 0.0f);
vec3 v2 = vec3( width/2, height, 0.0f);
vec3 v3 = vec3( -width/2, height, 0.0f);
vec2 t0 = vec2(0.0f, 0.0f);
vec2 t1 = vec2(2.0f, 0.0f);
vec2 t2 = vec2(2.0f, 1.5f);
vec2 t3 = vec2(0.0f, 1.5f);
v.push_back( pntVertexData( v0, n, t0) ); // 0
v.push_back( pntVertexData( v1, n, t1) ); // 1
v.push_back( pntVertexData( v2, n, t2) ); // 2
v.push_back( pntVertexData( v3, n, t3) ); // 3
indices.push_back( 0 );
indices.push_back( 1 );
indices.push_back( 2 );
indices.push_back( 0 );
indices.push_back( 2 );
indices.push_back( 3 );
glGenVertexArrays (1, &vertexArrayObject);
glBindVertexArray( vertexArrayObject );
// Create the buffer to hold interleaved data and bind the data to them
glGenBuffers(1, &VBO);
glBindBuffer(GL_ARRAY_BUFFER, VBO); // Buffer for vertex data
glBufferData(GL_ARRAY_BUFFER, v.size() * sizeof(pntVertexData), &v[0], GL_STATIC_DRAW); //Buffering vertex data
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(pntVertexData), 0);
glEnableVertexAttribArray(0);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(pntVertexData), (const GLvoid*)sizeof(vec3) );
glEnableVertexAttribArray(1);
glVertexAttribPointer(3, 2, GL_FLOAT, GL_FALSE, sizeof(pntVertexData), (const GLvoid*)(2 * sizeof(vec3)) );
glEnableVertexAttribArray(3);
// Generate a buffer for the indices
glGenBuffers(1, &IBO);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.size() * sizeof(unsigned int), &indices[0] , GL_STATIC_DRAW);
// store the number of indices for later use
indiceCount = indices.size();
v.clear();
indices.clear();
VisualObject::initialize();
} // end initialize
void SetupRC()
{
context.getClearColor().setValue(docgl::GLColor(0.7f, 0.7f, 0.7f, 1.0f));
cameraFrame.moveForward(-10.0f);
bool succeed = vertexArray.create().hasSucceed();
jassert(succeed);
constructSuperMesh(superFormulaParameters, invertCoordinate);
// compile shader with attribute
static const GLchar* transformVertexShader =
"uniform mat4 mvpMatrix;"
"attribute vec4 vVertex;"
""
"void main(void) "
" {gl_Position = mvpMatrix * vVertex;}";
#ifdef DOCGL4_1
static const GLchar* coloredFragmentShader =
"#version 410\n"
""
"subroutine vec4 getColorSubRoutine();"
""
"uniform vec4 vColor;"
"subroutine uniform getColorSubRoutine getColorFunction;"
""
"subroutine(getColorSubRoutine)"
"vec4 getUniformColor()"
" {return vColor;}"
""
"subroutine(getColorSubRoutine)"
"vec4 getUniformColorInv()"
" {return vec4(vec3(1 - vColor.rgb), vColor.a);}"
""
"void main(void) "
" {gl_FragColor = getColorFunction();}";
#else // !DOCGL4_1
static const GLchar* coloredFragmentShader =
"uniform vec4 vColor;"
""
"void main(void) "
" {gl_FragColor = vColor;}";
#endif // !DOCGL4_1
static const GLchar* vertexAttributes[] = {"vVertex", NULL};
succeed = buildShaderProgram(flatColorTransformShader, transformVertexShader, coloredFragmentShader, vertexAttributes).hasSucceed();
jassert(succeed);
succeed = flatColorTransformShader.getUniformVariableLocation("vColor", vColorLocation).hasSucceed();
jassert(succeed);
succeed = flatColorTransformShader.getUniformVariableLocation("mvpMatrix", mvpMatrixLocation).hasSucceed();
jassert(succeed);
#ifdef DOCGL4_1
succeed = flatColorTransformShader.getSubroutineUniformLocation(GL_FRAGMENT_SHADER, "getColorFunction", getColorFunctionLocation).hasSucceed();
jassert(succeed);
succeed = flatColorTransformShader.getSubroutineIndex(GL_FRAGMENT_SHADER, "getUniformColor", getUniformColorIndex).hasSucceed();
jassert(succeed);
succeed = flatColorTransformShader.getSubroutineIndex(GL_FRAGMENT_SHADER, "getUniformColorInv", getUniformColorInvIndex).hasSucceed();
jassert(succeed);
#endif // !DOCGL4_1
succeed = context.getActiveProgramBind().setValue(flatColorTransformShader.getId()).hasSucceed();
jassert(succeed);
}
// Construct visual object display list.
void Floor::initialize()
{
float divisionsPerSide = sideLength;
VertexData v0, v1, v2, v3;
short color = 1;
buildShaderProgram();
GLuint VBO, IBO;
glGenVertexArrays (1, &vertexArrayObject);
glBindVertexArray( vertexArrayObject );
vector<VertexData> v;
vector<unsigned int> indices;
GLfloat tileWidth = sideLength / divisionsPerSide ;
// Find corner of the board
GLfloat tileX = -( (divisionsPerSide/2.0f) * tileWidth);
GLfloat tileZ = ( (divisionsPerSide/2.0f) * tileWidth);
// define the two square colors
vec4 color1( 0.9f, 0.9f, 0.9f, 1.0f );
vec4 color2( 0.05f, 0.05f, 0.05f, 1.0f );
vec4 currentColor;
GLuint currentIndex = 0;
// Loop through rows
for ( int j = 0 ; j < divisionsPerSide ; j++ ) {
currentColor = (color++)%2 ? color1 : color2 ;
// Loop through columns
for ( int i = 0 ; i < divisionsPerSide ; i++ ) {
currentColor = (color++)%2 ? color1 : color2 ;
v0 = VertexData ( vec3(tileX, 0.0f, tileZ-tileWidth ), currentColor );
v.push_back( v0 );
v1 = VertexData ( vec3(tileX, 0.0f, tileZ ), currentColor );
v.push_back( v1 );
tileX += tileWidth;
v2 = VertexData ( vec3(tileX, 0.0f, tileZ), currentColor );
v.push_back( v2 );
v3 = VertexData ( vec3(tileX, 0.0f, tileZ-tileWidth), currentColor );
v.push_back( v3 );
indices.push_back(currentIndex);
indices.push_back(currentIndex + 1);
indices.push_back(currentIndex + 2);
indices.push_back(currentIndex);
indices.push_back(currentIndex + 2);
indices.push_back(currentIndex + 3);
currentIndex += 4;
} // end for i
tileX = - ( (divisionsPerSide/2.0f) * tileWidth);
tileZ -= tileWidth;
} // end for j
glGenBuffers(1, &VBO);
glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBufferData(GL_ARRAY_BUFFER, v.size() * sizeof(VertexData), &v[0], GL_STATIC_DRAW);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(VertexData), 0);
glEnableVertexAttribArray(0);
glVertexAttribPointer(2, 4, GL_FLOAT, GL_FALSE, sizeof(VertexData),(const GLvoid*)sizeof(vec3));
glEnableVertexAttribArray(2);
numberOfIndices = indices.size();
glGenBuffers(1, &IBO);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.size() * sizeof(unsigned int), &indices[0], GL_STATIC_DRAW);
v.clear();
indices.clear();
VisualObject::initialize();
} // end initialize
dx11ShaderProgram::dx11ShaderProgram(const void *vshader, int vshadersz,
const void *pshader, int pshadersz, const ConstantDesc *uniforms,
const DataDesc *attributes) {
buildShaderProgram(vshader, vshadersz, pshader, pshadersz, uniforms,
attributes);
}
void ColoredPyramid::initialize()
{
GLfloat hH = height/2.0f;
GLfloat hW = width/2.0f;
buildShaderProgram();
GLuint VBO, IBO;
glGenVertexArrays (1, &vertexArrayObject);
glBindVertexArray( vertexArrayObject );
vector<VertexData> v;
v.push_back( VertexData( vec3( 0.0f, hH, 0.0f), vec4( 1.0f, 0.0f, 0.0f, 1.0f )));
v.push_back( VertexData( vec3(-hW, -hH, hW), vec4( 0.0f, 1.0f, 0.0f, 1.0f )));
v.push_back( VertexData( vec3( hW, -hH, hW), vec4( 0.0f, 0.0f, 1.0f, 1.0f )));
v.push_back( VertexData( vec3( hW, -hH, -hW), vec4( 1.0f, 1.0f, 0.0f, 1.0f )));
v.push_back( VertexData( vec3(-hW, -hH, -hW), vec4( 0.0f, 1.0f, 1.0f, 1.0f )));
glGenBuffers(1, &VBO);
glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBufferData(GL_ARRAY_BUFFER, v.size() * sizeof(VertexData), &v[0], GL_STATIC_DRAW);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(VertexData), 0);
glEnableVertexAttribArray(0);
glVertexAttribPointer(2, 4, GL_FLOAT, GL_FALSE, sizeof(VertexData),(const GLvoid*)sizeof(vec3));
glEnableVertexAttribArray(2);
vector<unsigned int> i;
i.push_back(0);
i.push_back(1);
i.push_back(2);
i.push_back(0);
i.push_back(2);
i.push_back(3);
i.push_back(0);
i.push_back(3);
i.push_back(4);
i.push_back(0);
i.push_back(4);
i.push_back(1);
i.push_back(4);
i.push_back(2);
i.push_back(1);
i.push_back(4);
i.push_back(3);
i.push_back(2);
numberOfIndices = sizeof( i );
glGenBuffers(1, &IBO);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, i.size() * sizeof(unsigned int), &i[0], GL_STATIC_DRAW);
} // end initialize
KMShader::KMShader(const char* vertex, const char* fragment)
{
const char* vertexSource = KMFileUtils::getSharedFileUtils().loadFile(vertex);
const char* fragmentSource = KMFileUtils::getSharedFileUtils().loadFile(fragment);
_glProgram = buildShaderProgram(vertexSource, fragmentSource);
}
