void GLShaderProgram::NewVertexShader(char *filename)
{
GLShader vshader(GL_VERTEX_SHADER, filename);
vshader.Init();
glAttachShader(programID,vshader.GetShaderID());
_Shaders.push_back(vshader);
}
// Init parameters from config file
void StelSkyDrawer::init()
{
// Load star texture no mipmap:
texHalo = StelApp::getInstance().getTextureManager().createTexture(StelFileMgr::getInstallationDir()+"/textures/star16x16.png");
texBigHalo = StelApp::getInstance().getTextureManager().createTexture(StelFileMgr::getInstallationDir()+"/textures/haloLune.png");
texSunHalo = StelApp::getInstance().getTextureManager().createTexture(StelFileMgr::getInstallationDir()+"/textures/halo.png");
texSunCorona = StelApp::getInstance().getTextureManager().createTexture(StelFileMgr::getInstallationDir()+"/textures/corona.png");
// Create shader program
QOpenGLShader vshader(QOpenGLShader::Vertex);
const char *vsrc =
"attribute mediump vec2 pos;\n"
"attribute mediump vec2 texCoord;\n"
"attribute mediump vec3 color;\n"
"uniform mediump mat4 projectionMatrix;\n"
"varying mediump vec2 texc;\n"
"varying mediump vec3 outColor;\n"
"void main(void)\n"
"{\n"
" gl_Position = projectionMatrix * vec4(pos.x, pos.y, 0, 1);\n"
" texc = texCoord;\n"
" outColor = color;\n"
"}\n";
vshader.compileSourceCode(vsrc);
if (!vshader.log().isEmpty()) { qWarning() << "StelSkyDrawer::init(): Warnings while compiling vshader: " << vshader.log(); }
QOpenGLShader fshader(QOpenGLShader::Fragment);
const char *fsrc =
"varying mediump vec2 texc;\n"
"varying mediump vec3 outColor;\n"
"uniform sampler2D tex;\n"
"void main(void)\n"
"{\n"
" gl_FragColor = texture2D(tex, texc)*vec4(outColor, 1.);\n"
"}\n";
fshader.compileSourceCode(fsrc);
if (!fshader.log().isEmpty()) { qWarning() << "StelSkyDrawer::init(): Warnings while compiling fshader: " << fshader.log(); }
starShaderProgram = new QOpenGLShaderProgram(QOpenGLContext::currentContext());
starShaderProgram->addShader(&vshader);
starShaderProgram->addShader(&fshader);
StelPainter::linkProg(starShaderProgram, "starShader");
starShaderVars.projectionMatrix = starShaderProgram->uniformLocation("projectionMatrix");
starShaderVars.texCoord = starShaderProgram->attributeLocation("texCoord");
starShaderVars.pos = starShaderProgram->attributeLocation("pos");
starShaderVars.color = starShaderProgram->attributeLocation("color");
starShaderVars.texture = starShaderProgram->uniformLocation("tex");
update(0);
}
//----------------------------------------------------------------------------
bool WireMeshWindow::CreateScene()
{
std::string path = mEnvironment.GetPath("WireMesh.hlsl");
std::shared_ptr<VertexShader> vshader(ShaderFactory::CreateVertex(path));
if (!vshader)
{
return false;
}
std::shared_ptr<GeometryShader> gshader(ShaderFactory::CreateGeometry(
path));
if (!gshader)
{
return false;
}
std::shared_ptr<PixelShader> pshader(ShaderFactory::CreatePixel(path));
if (!pshader)
{
return false;
}
std::shared_ptr<ConstantBuffer> parameters(
new ConstantBuffer(3 * sizeof(Vector4<float>), false));
Vector4<float>* data = parameters->Get<Vector4<float>>();
data[0] = Vector4<float>(0.0f, 0.0f, 1.0f, 1.0f); // mesh color
data[1] = Vector4<float>(0.0f, 0.0f, 0.0f, 1.0f); // edge color
data[2] = Vector4<float>((float)mXSize, (float)mYSize, 0.0f, 0.0f);
vshader->Set("WireParameters", parameters);
gshader->Set("WireParameters", parameters);
pshader->Set("WireParameters", parameters);
std::shared_ptr<ConstantBuffer> cbuffer(
new ConstantBuffer(sizeof(Matrix4x4<float>), true));
vshader->Set("PVWMatrix", cbuffer);
std::shared_ptr<VisualEffect> effect(new VisualEffect(vshader, pshader,
gshader));
VertexFormat vformat;
vformat.Bind(VA_POSITION, DF_R32G32B32_FLOAT, 0);
MeshFactory mf;
mf.SetVertexFormat(vformat);
mMesh = mf.CreateSphere(16, 16, 1.0f);
mMesh->SetEffect(effect);
mMesh->Update();
SubscribeCW(mMesh, cbuffer);
return true;
}
void GLRC_Text2DModule::Initialize(GLRenderingContext *rc)
{
if (GLEW_ARB_shader_objects) {
prog = new ProgramObject(rc);
Shader vshader(GL_VERTEX_SHADER);
Shader fshader(GL_FRAGMENT_SHADER);
vshader.CompileSource(shaderSource[0]);
fshader.CompileSource(shaderSource[1]);
prog->AttachShader(vshader);
prog->AttachShader(fshader);
prog->Link();
prog->Uniform("ColorMap", 0);
}
else prog = NULL;
}
//----------------------------------------------------------------------------
bool PlaneMeshIntersectionWindow::CreateScene()
{
std::string path = mEnvironment.GetPath("PlaneMeshIntersection.hlsl");
std::shared_ptr<VertexShader> vshader(ShaderFactory::CreateVertex(path));
if (!vshader)
{
return false;
}
std::shared_ptr<PixelShader> pshader(ShaderFactory::CreatePixel(path));
if (!pshader)
{
return false;
}
path = mEnvironment.GetPath("DrawIntersections.hlsl");
mDrawIntersections.reset(ShaderFactory::CreateCompute(path));
float planeDelta = 0.125f;
mPMIParameters.reset(new ConstantBuffer(sizeof(PMIParameters), true));
PMIParameters& p = *mPMIParameters->Get<PMIParameters>();
p.pvMatrix = mCamera.GetProjectionViewMatrix();
p.wMatrix = Matrix4x4<float>::Identity();
p.planeVector0 = Vector4<float>(1.0f, 0.0f, 0.0f, 0.0f) / planeDelta;
p.planeVector1 = Vector4<float>(0.0f, 1.0f, 0.0f, 0.0f) / planeDelta;
vshader->Set("PMIParameters", mPMIParameters);
std::shared_ptr<VisualEffect> effect(new VisualEffect(vshader, pshader));
VertexFormat vformat;
vformat.Bind(VA_POSITION, DF_R32G32B32_FLOAT, 0);
MeshFactory mf;
mf.SetVertexFormat(vformat);
mMesh = mf.CreateSphere(16, 16, 1.0f);
mMesh->SetEffect(effect);
mMesh->Update();
return true;
}
//----------------------------------------------------------------------------
bool StructuredBuffersWindow::CreateScene()
{
// Create the shaders and associated resources
HLSLDefiner definer;
definer.SetInt("WINDOW_WIDTH", mXSize);
std::shared_ptr<VertexShader> vshader(ShaderFactory::CreateVertex(
mEnvironment.GetPath("StructuredBuffers.hlsl"), definer));
if (!vshader)
{
return false;
}
std::shared_ptr<PixelShader> pshader(ShaderFactory::CreatePixel(
mEnvironment.GetPath("StructuredBuffers.hlsl"), definer));
if (!pshader)
{
return false;
}
std::shared_ptr<ConstantBuffer> cbuffer(new ConstantBuffer(
sizeof(Matrix4x4<float>), true));
vshader->Set("PVWMatrix", cbuffer);
// Create the pixel shader and associated resources.
std::string path = mEnvironment.GetPath("StoneWall.png");
std::shared_ptr<Texture2> baseTexture(WICFileIO::Load(path, false));
pshader->Set("baseTexture", baseTexture);
std::shared_ptr<SamplerState> baseSampler(new SamplerState());
baseSampler->filter = SamplerState::MIN_L_MAG_L_MIP_P;
baseSampler->mode[0] = SamplerState::CLAMP;
baseSampler->mode[1] = SamplerState::CLAMP;
pshader->Set("baseSampler", baseSampler);
mDrawnPixels.reset(new StructuredBuffer(mXSize*mYSize,
sizeof(Vector4<float>)));
mDrawnPixels->SetUsage(Resource::SHADER_OUTPUT);
mDrawnPixels->SetCopyType(Resource::COPY_BIDIRECTIONAL);
memset(mDrawnPixels->GetData(), 0, mDrawnPixels->GetNumBytes());
pshader->Set("drawnPixels", mDrawnPixels);
// Create the visual effect for the square.
std::shared_ptr<VisualEffect> effect(new VisualEffect(vshader, pshader));
// Create a vertex buffer for a single triangle. The PNG is stored in
// left-handed coordinates. The texture coordinates are chosen to reflect
// the texture in the y-direction.
struct Vertex
{
Vector3<float> position;
Vector2<float> tcoord;
};
VertexFormat vformat;
vformat.Bind(VA_POSITION, DF_R32G32B32_FLOAT, 0);
vformat.Bind(VA_TEXCOORD, DF_R32G32_FLOAT, 0);
std::shared_ptr<VertexBuffer> vbuffer(new VertexBuffer(vformat, 4));
Vertex* vertex = vbuffer->Get<Vertex>();
vertex[0].position = Vector3<float>(0.0f, 0.0f, 0.0f);
vertex[0].tcoord = Vector2<float>(0.0f, 1.0f);
vertex[1].position = Vector3<float>(1.0f, 0.0f, 0.0f);
vertex[1].tcoord = Vector2<float>(1.0f, 1.0f);
vertex[2].position = Vector3<float>(0.0f, 1.0f, 0.0f);
vertex[2].tcoord = Vector2<float>(0.0f, 0.0f);
vertex[3].position = Vector3<float>(1.0f, 1.0f, 0.0f);
vertex[3].tcoord = Vector2<float>(1.0f, 0.0f);
// Create an indexless buffer for a triangle mesh with two triangles.
std::shared_ptr<IndexBuffer> ibuffer(new IndexBuffer(IP_TRISTRIP, 2));
// Create the geometric object for drawing. Translate it so that its
// center of mass is at the origin. This supports virtual trackball
// motion about the object "center".
mSquare.reset(new Visual(vbuffer, ibuffer, effect));
mSquare->localTransform.SetTranslation(-0.5f, -0.5f, 0.0f);
mSquare->Update();
// Enable automatic updates of pvw-matrices and w-matrices.
SubscribeCW(mSquare, cbuffer);
// The structured buffer is written in the pixel shader. This texture
// will receive a copy of it so that we can write the results to disk
// as a PNG file.
mDrawnPixelsTexture = new Texture2(DF_R8G8B8A8_UNORM, mXSize, mYSize);
return true;
}
int main(int, char**)
{
int width = 1080;
int height = 900;
if (!glfwInit()){ std::cout << "ERROR: glfwInit failed\n"; return -1; }
GLFWwindow* window = glfwCreateWindow(width, height, "mesh", NULL, NULL);
if (!window){ std::cout << "ERROR: window was not created\n"; return -1; }
glfwMakeContextCurrent(window);
glewExperimental = GL_TRUE;
glewInit();
versionPrint();
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);
//glEnable(GL_CULL_FACE);
GUI gui;
gui.Init(window, false);
float vertices[] = {
-0.5, -0.5, 0,
-0.5, 0.5, 0,
0.5, 0.5, 0,
/////////////////////
-0.5, -0.5, 0,
0.5, 0.5, 0,
0.5, -0.5, 0
};
//////////////////////////////////
//OBJECT LOADING
std::string resourcePath = "../../../resources/";
//std::string inputfile = resourcePath + "teapot/teapot.obj";
//std::string mtlfile = resourcePath + "teapot/teapot.mtl";
//std::string inputfile = resourcePath + "sphere/sphere.obj";
//std::string mtlfile = resourcePath + "sphere/sphere.mtl";
std::string inputfile = resourcePath + "dragon/dragon.obj";
//std::string inputfile = resourcePath + "monkey/monkey.obj";
//std::string mtlfile = resourcePath + "monkey/monkey.mtl";
std::vector<tinyobj::shape_t> shapes;
std::vector<tinyobj::material_t> materials;
std::string err;
if (!tinyobj::LoadObj(shapes, materials, err, inputfile.c_str()))
std::cerr << err << std::endl;
std::cout << "# of shapes : " << shapes.size() << std::endl;
std::cout << "# of materials : " << materials.size() << std::endl;
//OBJECT LOADING
//////////////////////////////////
glm::vec3 cpos = glm::vec3(0.0f, 0.0f, 10.0f);
glm::mat4 view;
view = glm::lookAt( cpos,
glm::vec3(0.0f, 0.0f, 0.0f),
glm::vec3(0.0f, 1.0f, 0.0f));
glm::mat4 projection = glm::perspective(45.0f, (float)width/(float)height, 0.01f, 1000.0f);
glm::mat4 model = glm::mat4();
float s = 1.0f;
model = glm::scale(model, glm::vec3(s, s, s));
std::string shaderPath = "../../../source/shaders/";
Program shaderProgram;
Shader vshader(shaderPath + "vertexShader.glsl", GL_VERTEX_SHADER);
Shader fshader(shaderPath + "fragmentShader.glsl", GL_FRAGMENT_SHADER);
shaderProgram.attachShader(&vshader);
shaderProgram.attachShader(&fshader);
shaderProgram.linkProgram();
GLuint elems;
glGenBuffers(1, &elems);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, elems);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, shapes[0].mesh.indices.size() * sizeof(unsigned int), &(shapes[0].mesh.indices[0]), GL_STATIC_DRAW);
GLuint vbo;
glGenBuffers(1, &vbo);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
glBufferData(GL_ARRAY_BUFFER, shapes[0].mesh.positions.size() * sizeof(float), &(shapes[0].mesh.positions[0]), GL_STATIC_DRAW);
GLuint nbo;
glGenBuffers(1, &nbo);
glBindBuffer(GL_ARRAY_BUFFER, nbo);
glBufferData(GL_ARRAY_BUFFER, shapes[0].mesh.normals.size() * sizeof(float), &(shapes[0].mesh.normals[0]), GL_STATIC_DRAW);
GLuint vao;
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
glEnableVertexAttribArray(0);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, NULL);
glEnableVertexAttribArray(1);
glBindBuffer(GL_ARRAY_BUFFER, nbo);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, NULL);
GLuint ModelMatrixHandle = glGetUniformLocation(shaderProgram.getID(), "ModelMatrix");
GLuint ViewMatrixHandle = glGetUniformLocation(shaderProgram.getID(), "ViewMatrix");
GLuint ProjectionMatrixHandle = glGetUniformLocation(shaderProgram.getID(), "ProjectionMatrix");
glUniformMatrix4fv(ModelMatrixHandle, 1, GL_FALSE, glm::value_ptr(model));
glUniformMatrix4fv(ViewMatrixHandle, 1, GL_FALSE, glm::value_ptr(view));
glUniformMatrix4fv(ProjectionMatrixHandle, 1, GL_FALSE, glm::value_ptr(projection));
glClearColor(0.3, 0.3, 0.3, 1.0);
while (!glfwWindowShouldClose(window)){
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
shaderProgram.use();
glBindVertexArray(vao);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, elems);
model = glm::rotate(model, 0.0001f, glm::vec3(0, 1, 0));
glUniformMatrix4fv(ModelMatrixHandle, 1, GL_FALSE, glm::value_ptr(model));
glUniformMatrix4fv(ViewMatrixHandle, 1, GL_FALSE, glm::value_ptr(view));
glUniformMatrix4fv(ProjectionMatrixHandle, 1, GL_FALSE, glm::value_ptr(projection));
glDrawElements(GL_TRIANGLES, shapes[0].mesh.indices.size(),GL_UNSIGNED_INT,(void*)0);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
gui.Render(&shapes);
glfwSwapBuffers(window);
glfwPollEvents();
}
return 0;
}
