mirror/OpenSpace
1
0
Fork 0
mirror of https://github.com/OpenSpace/OpenSpace.git synced 2026-01-02 01:30:34 -06:00
Code Issues Packages Projects Releases Wiki Activity

small changes to to get everything working on my end / michal

Browse Source
This commit is contained in:
michal
2014-09-26 17:42:07 -04:00
parent 5427dbdeb2
commit 22fd3acc59
7 changed files with 19 additions and 181 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
openspace-data

Submodule openspace-data updated: 7ca4cc9594...2685def87a

4
scripts/default_startup.lua
View File

@@ -1,5 +1,5 @@
--openspace.setPropertyValue('Earth.renderable.colorTexture', '${OPENSPACE_DATA}/modules/mars/textures/mars.png')
openspace.time.setTime("2000-01-01T00:00:00")
openspace.time.setDeltaTime(1.0)
openspace.time.setTime("2007-11-01T00:00:00")
openspace.time.setDeltaTime(100000.0)
print(openspace.time.currentTimeUTC())

12
shaders/star_fs.glsl
View File

@@ -8,7 +8,7 @@ in vec2 texCoord;
layout(location = 2) in vec3 ge_brightness;
//out vec4 diffuse;
out vec4 diffuse;
#include "ABuffer/abufferStruct.hglsl"
@@ -48,12 +48,12 @@ void main(void)
//glEnable(GL_BLEND);
//glBlendFunc(GL_ONE_MINUS_DST_COLOR, GL_ONE);
vec4 color = bv2rgb(ge_brightness[0])/1.1;
//color.rgb = 1/ color.rgb;
color.a = 1-color.a;
vec4 diffuse = texture2D(texture1, texCoord)*color;
//color = 1/ color;
//color.a = 1-color.a;
diffuse = texture2D(texture1, texCoord)*color;
///diffuse = vec4(Color, 1.0);
// diffuse = vec4(Color, 1.0);
vec4 position = vs_position;
float depth = pscDepth(position);
@@ -62,6 +62,6 @@ void main(void)
ABufferStruct_t frag = createGeometryFragment(diffuse, position, depth);
addToBuffer(frag);
discard;
//discard;
}

4
src/interaction/interactionhandler.cpp
View File

@@ -355,11 +355,11 @@ void InteractionHandler::keyboardCallback(int key, int action) {
distance(dist);
}
if (key == SGCT_KEY_T) {
PowerScaledScalar dist(-speed * 100.0 * dt, 0.0);
PowerScaledScalar dist(-speed * pow(10,8) * dt, 0.0);
distance(dist);
}
if (key == SGCT_KEY_G) {
PowerScaledScalar dist(speed * 100.0 * dt, 0.0);
PowerScaledScalar dist(speed * pow(10, 8) * dt, 0.0);
distance(dist);
}
if (key == SGCT_KEY_Y) {

4
src/rendering/renderengine.cpp
View File

@@ -94,8 +94,8 @@ bool RenderEngine::initializeGL()
// development
// sgct::Engine::instance()->setNearAndFarClippingPlanes(0.1f,100.0f);
sgct::Engine::instance()->setNearAndFarClippingPlanes(0.1f, 1000.00f);
sgct::Engine::instance()->setNearAndFarClippingPlanes(0.0001f, 100.0f);
sgct::Engine::instance()->setNearAndFarClippingPlanes(0.1f, 200.0f);
// sgct::Engine::instance()->setNearAndFarClippingPlanes(0.0001f, 100.0f);
// sgct::Engine::instance()->setNearAndFarClippingPlanes(0.1f, 200.0f);
// calculating the maximum field of view for the camera, used to
// determine visibility of objects in the scene graph

6
src/rendering/stars/renderablestars.cpp
View File

@@ -322,9 +322,9 @@ void RenderableStars::render(const RenderData& data){
glm::vec3(0.0f, 1.0f, 0.0f));
#endif
// disable depth test, enable additative blending
//glDisable(GL_DEPTH_TEST);
//glEnable(GL_BLEND);
//glBlendFunc(GL_ONE_MINUS_DST_COLOR, GL_ONE);
glDisable(GL_DEPTH_TEST);
glEnable(GL_BLEND);
glBlendFunc(GL_ONE_MINUS_DST_COLOR, GL_ONE);
#ifdef GLSPRITES
glm::mat4 modelMatrix = data.camera.modelMatrix();

168
src/scenegraph/scenegraph.cpp
View File

@@ -277,173 +277,9 @@ bool SceneGraph::initialize()
if (!tmpProgram) return false;
OsEng.ref().configurationManager().setValue("GridProgram", tmpProgram);
double elapsed = std::chrono::duration_cast<second_>(clock_::now()-beginning).count();
LINFO("Time to load shaders: " << elapsed);
/*
auto programCreator = [] ( const std::string& name,
const std::string& vpath,
const std::string& fpath)
{
const std::string vsPath = absPath(vpath);
const std::string fsPath = absPath(fpath);
const ShaderObject::ShaderType vsType = ShaderObject::ShaderType::ShaderTypeVertex;
const ShaderObject::ShaderType fsType = ShaderObject::ShaderType::ShaderTypeFragment;
ProgramObject* po = new ProgramObject(name);
ShaderObject* vs = new ShaderObject(vsType, vsPath, name + "Vertex");
ShaderObject* fs = new ShaderObject(fsType, fsPath, name + "Fragment");
po->attachObject(vs);
po->attachObject(fs);
if ( po->compileShaderObjects() && po->linkProgramObject())
return po;
// unsuccessful compilation, cleanup and return nullptr
delete po;
po = nullptr;
//<<<<<<< HEAD
}
ShaderObject* powerscale_vs
= new ShaderObject(ShaderObject::ShaderType::ShaderTypeVertex,
absPath("${SHADERS}/pscstandard_vs.glsl"), "PS Vertex");
ShaderObject* powerscale_fs
= new ShaderObject(ShaderObject::ShaderType::ShaderTypeFragment,
absPath("${SHADERS}/pscstandard_fs.glsl"), "PS Fragment");
po = new ProgramObject;
po->attachObject(powerscale_vs);
po->attachObject(powerscale_fs);
if (!po->compileShaderObjects())
return false;
if (!po->linkProgramObject())
return false;
OsEng.ref().configurationManager().setValue("pscShader", po);
ProgramObject* _gridProgram = new ProgramObject("GridProgram");
ShaderObject* gridvs = new ShaderObject(ShaderObject::ShaderTypeVertex,
absPath("${SHADERS}/grid_vs.glsl"));
ShaderObject* gridfs = new ShaderObject(ShaderObject::ShaderTypeFragment,
absPath("${SHADERS}/grid_fs.glsl"));
_gridProgram->attachObject(gridvs);
_gridProgram->attachObject(gridfs);
_gridProgram->compileShaderObjects();
_gridProgram->linkProgramObject();
// STAR HALO RENDERING
ProgramObject* _starProgram = new ProgramObject("StarProgram");
ShaderObject* starvs = new ShaderObject(ShaderObject::ShaderTypeVertex,
absPath("${SHADERS}/star_vs.glsl"));
ShaderObject* starge = new ShaderObject(ShaderObject::ShaderTypeGeometry,
absPath("${SHADERS}/star_ge.glsl"));
ShaderObject* starfs = new ShaderObject(ShaderObject::ShaderTypeFragment,
absPath("${SHADERS}/star_fs.glsl"));
_starProgram->attachObject(starvs);
_starProgram->attachObject(starge);
_starProgram->attachObject(starfs);
_starProgram->compileShaderObjects();
_starProgram->linkProgramObject();
// STAR POINT RENDERING
ProgramObject* _pointProgram = new ProgramObject("PointProgram");
ShaderObject* starvs_point = new ShaderObject(ShaderObject::ShaderTypeVertex,
absPath("${SHADERS}/star_vs_points.glsl"));
ShaderObject* starge_point = new ShaderObject(ShaderObject::ShaderTypeGeometry,
absPath("${SHADERS}/star_ge_points.glsl"));
ShaderObject* starfs_point = new ShaderObject(ShaderObject::ShaderTypeFragment,
absPath("${SHADERS}/star_fs_points.glsl"));
_pointProgram->attachObject(starvs_point);
_pointProgram->attachObject(starge_point);
_pointProgram->attachObject(starfs_point);
_pointProgram->compileShaderObjects();
_pointProgram->linkProgramObject();
ProgramObject* _fboProgram = new ProgramObject("RaycastProgram");
ShaderObject* vertexShader = new ShaderObject(ShaderObject::ShaderTypeVertex,
absPath("${SHADERS}/exitpoints.vert"));
ShaderObject* fragmentShader = new ShaderObject(ShaderObject::ShaderTypeFragment,
absPath("${SHADERS}/exitpoints.frag"));
_fboProgram->attachObject(vertexShader);
_fboProgram->attachObject(fragmentShader);
_fboProgram->compileShaderObjects();
_fboProgram->linkProgramObject();
ProgramObject* _twopassProgram = new ProgramObject("TwoPassProgram");
vertexShader = new ShaderObject(ShaderObject::ShaderTypeVertex,
absPath("${SHADERS}/twopassraycaster.vert"));
fragmentShader = new ShaderObject(ShaderObject::ShaderTypeFragment,
absPath("${SHADERS}/twopassraycaster.frag"));
_twopassProgram->attachObject(vertexShader);
_twopassProgram->attachObject(fragmentShader);
_twopassProgram->compileShaderObjects();
_twopassProgram->linkProgramObject();
_twopassProgram->setUniform("texBack", 0);
_twopassProgram->setUniform("texFront", 1);
_twopassProgram->setUniform("texVolume", 2);
ProgramObject* quad = new ProgramObject("Quad");
ShaderObject* quadv = new ShaderObject(ShaderObject::ShaderTypeVertex,
absPath("${SHADERS}/quadVert.glsl"));
ShaderObject* quadf = new ShaderObject(ShaderObject::ShaderTypeFragment,
absPath("${SHADERS}/quadFrag.glsl"));
quad->attachObject(quadv);
quad->attachObject(quadf);
quad->compileShaderObjects();
quad->linkProgramObject();
quad->setUniform("quadTex", 0);
OsEng.ref().configurationManager().setValue("RaycastProgram", _fboProgram);
OsEng.ref().configurationManager().setValue("TwoPassProgram", _twopassProgram);
OsEng.ref().configurationManager().setValue("Quad", quad);
OsEng.ref().configurationManager().setValue("PointProgram", _pointProgram);
OsEng.ref().configurationManager().setValue("StarProgram", _starProgram);
OsEng.ref().configurationManager().setValue("GridProgram", _gridProgram);
=======
return po;
};
// pscstandard
tmpProgram = programCreator("pscstandard",
"${SHADERS}/pscstandard_vs.glsl",
"${SHADERS}/pscstandard_fs.glsl");
if( ! tmpProgram) return false;
OsEng.ref().configurationManager().setValue("pscShader", tmpProgram);
// RaycastProgram
tmpProgram = programCreator("RaycastProgram",
"${SHADERS}/exitpoints.vert",
"${SHADERS}/exitpoints.frag");
if( ! tmpProgram) return false;
OsEng.ref().configurationManager().setValue("RaycastProgram", tmpProgram);
// TwoPassProgram
tmpProgram = programCreator("TwoPassProgram",
"${SHADERS}/twopassraycaster.vert",
"${SHADERS}/twopassraycaster.frag");
if( ! tmpProgram) return false;
tmpProgram->setUniform("texBack", 0);
tmpProgram->setUniform("texFront", 1);
tmpProgram->setUniform("texVolume", 2);
OsEng.ref().configurationManager().setValue("TwoPassProgram", tmpProgram);
// Quad
tmpProgram = programCreator("Quad",
"${SHADERS}/quadVert.glsl",
"${SHADERS}/quadFrag.glsl");
if( ! tmpProgram) return false;
tmpProgram->setUniform("quadTex", 0);
OsEng.ref().configurationManager().setValue("Quad", tmpProgram);
*/
//>>>>>>> develop
return true;
}
@@ -618,13 +454,15 @@ bool SceneGraph::loadSceneInternal(const std::string& sceneDescriptionFilePath)
const PowerScaledScalar bound = positionNode->calculateBoundingSphere();
// this part is full of magic!
glm::vec2 boundf = bound.vec2();
glm::vec2 boundf = bound.vec2();
glm::vec2 scaling{1.0f, -boundf[1]};
boundf[0] *= 5.0f;
psc cameraPosition = positionNode->position();
cameraPosition += psc(glm::vec4(0.f, 0.f, boundf));
cameraPosition = psc(glm::vec4(0.f, 0.f, 1.f,0.f));
c->setPosition(cameraPosition);
c->setCameraDirection(glm::vec3(0, 0, -1));
c->setScaling(scaling);