Пример #1
0
void UIShader::checkShaderFile(){
	int currTime = ofGetElapsedTimeMillis();
	if( ((currTime - lastTimeCheckMillis) > millisBetweenFileCheck) ){
        if( fragFile.exists() ){
            std::time_t fragmentShaderFileLastChangeTime = getLastModified( fragFile );
            if( fragmentShaderFileLastChangeTime != fragChangedTimes ){
                fragChangedTimes = fragmentShaderFileLastChangeTime;
                reloadShader(fragFilename,vertFilename,geomFilename);
            } else if (bVertex){
                if( vertFile.exists() ){
                    std::time_t vertexShaderFileLastChangeTime = getLastModified( vertFile );
                    if( vertexShaderFileLastChangeTime != vertChangedTimes ){
                        vertChangedTimes = vertexShaderFileLastChangeTime;
                        reloadShader(fragFilename,vertFilename,geomFilename);
                    }
                }
                
                if( geomFile.exists() ){
                    std::time_t geometryShaderFileLastChangeTime = getLastModified( geomFile );
                    if( geometryShaderFileLastChangeTime != geomChangedTimes ){
                        vertChangedTimes = geometryShaderFileLastChangeTime;
                        reloadShader(fragFilename,vertFilename,geomFilename);
                    }
                }
            }
        }
        
		lastTimeCheckMillis = currTime;
	}
}
// selfSetup is called when the visual system is first instantiated
// This will be called during a "loading" screen, so any big images or
// geometry should be loaded here
void CloudsVisualSystemLaplacianTunnel::selfSetup(){
	frameCount = 0;
	bUseExternalCamera = false;
	bPalindrome = false;
	lastFrameTime = 0;
	growthFPS = 0;
	currentGrowthIndex = 0;
	
	ofDirectory objs(GetCloudsMediaPath() + "assets/LaplacianTunnel/Meshes/");
	objs.allowExt("vbo");
	objs.listDir();
	
	clear();
	
	min.set(999999);
	max.set(-99999);
	center.set(14.000,5.900,-13.950);
	int numFiles = objs.numFiles();
	vbos.resize( numFiles );
	for(int i = 0; i < numFiles; i++){
		vbos[i].vbo = new ofVboByteColor();
		vbos[i].name = objs.getName(i);
		vbos[i].indexCount = loadMesh(*vbos[i].vbo, objs.getPath( i ) );
		//vbos[i].indexCount = loadMeshPLY(*vbos[i].vbo, objs.getPath( i ) );
	}
	
	sort(vbos.begin(), vbos.end(), meshsort);
	
	reloadShader();
	tunnelCam.setNearClip(.01);
	tunnelCam.setFov(70);
}
Пример #3
0
ofxRGBDRenderer::ofxRGBDRenderer(){
	//come up with better names
	xmult = 0;
	ymult = 0;
	
	edgeCull = 4000;
	simplify = 1;

	farClip = 6000;
	ZFuzz = 0;
    meshRotate = ofVec3f(0,0,0);
    
    calculateNormals = false;
    
	hasDepthImage = false;
	hasRGBImage = false;

    shaderBound = false;
    rendererBound = false;
    

	mirror = false;
	calibrationSetup = false;
    
    reloadShader();
    setSimplification(1);
    
    hasVerts = false;
    forceUndistortOff = false;
    addColors = false;
    calculateTextureCoordinates = false;
}
Пример #4
0
void Goal::setup() {
    loader_.setScaleNomalization(false);
    loader_.loadModel("goal.obj");
    goal_ = loader_.getMesh(0);
    setPosition(28.2, 51.607, 187.8);
    reloadShader();
}
Пример #5
0
bool RendererServiceSetFocalDistance::reload(const std::string& shaderPath, Logger* logger)
{
	return reloadShader(shaderPath, 
						"FocalDistance", 
						"focalDistance/focalDistance.vs", 
						"shared/trivial.fs", 
						logger);
}
Пример #6
0
//--------------------------------------------------------------
void testApp::dragEvent(ofDragInfo dragInfo){ 
    vector<string> file = ofSplitString(dragInfo.files[0], ".");
    
    if ( file[1] == "fs" || file[1] == "frg" || file[1] == "frag" ) {
        
        cout << dragInfo.files[0] << " loaded"<< endl;
        reloadShader(dragInfo.files[0]);
    }
}
Пример #7
0
void Bloom::initialize(uint a_xRes, uint a_yRes)
{
	m_bloomResultTexture.initialize(GLTexture::ESizedFormat::RGB8, a_xRes, a_yRes, GLConfig::getMultisampleType());
	m_bloomResultFBO.initialize(GLConfig::getMultisampleType());
	m_bloomResultFBO.addFramebufferTexture(m_bloomResultTexture);
	m_gaussianBlur.initialize(GaussianBlur::EBlurValueType::VEC3, a_xRes, a_yRes);

	reloadShader();

	m_initialized = true;
}
Пример #8
0
bool UIShader::loadFrag(string _fragShader){
    bVertex = false;
    
    ofFile fragFile = ofFile(_fragShader);
    if (!fragFile.exists() ){
        ofBuffer frag;
        frag.append(fragmentShader);
        ofBufferToFile(_fragShader, frag);
    }
    
    return reloadShader( _fragShader );
}
Пример #9
0
void testApp::checkShaderFile(){
	int currTime = ofGetElapsedTimeMillis();
	if( ((currTime - lastTimeCheckMillis) > millisBetweenFileCheck) ){
        if( shaderFile.exists() ){
            std::time_t fragmentShaderFileLastChangeTime = getLastModified( shaderFile );
            if( fragmentShaderFileLastChangeTime != shaderChangedTimes ){
                shaderChangedTimes = fragmentShaderFileLastChangeTime;
                reloadShader();
            }
        }
    
		lastTimeCheckMillis = currTime;
	}
}
Пример #10
0
void MainWindow::shaderAction(int type)
{
	QString errMessage;
	bool useUserShader = false;
	wz_shader_type_t stype = static_cast<wz_shader_type_t>(type);

	if (m_actionEnableUserShaders->isChecked())
	{
		useUserShader = reloadShader(stype, true, &errMessage);
		if (!useUserShader)
		{
			QMessageBox::warning(this, "External shaders error",
				"Unable to load external shaders, so please ensure that they are correct and hit reload!"\
				"\nNOTE: Model might temporarily go into stealth mode due to this error...\n\n" +
				errMessage);
		}
	};

	if (!useUserShader)
		reloadShader(stype, false);

	if (static_cast<wz_shader_type_t>(type) != WZ_SHADER_NONE)
	{
		if (!m_model.setActiveShader(static_cast<wz_shader_type_t>(type)))
		{
		    QMessageBox::warning(this, "Shaders error",
		       "Unable to activate requested shaders!");
		}
	}
	else
	{
		m_model.disableShaders();
	}
	updateModelRender();

	setWindowTitle(buildAppTitle());
}
Пример #11
0
//--------------------------------------------------------------
void testApp::setup(){
    ofEnableAlphaBlending();
    ofSetVerticalSync(true);
//    ofSetDataPathRoot("data/");

    ofSetWindowShape(640, 480);
    millisBetweenFileCheck = 2 * 1000;
    
    oscReceiver.setup(PORT);
    
    sServer.setName(ofGetTimestampString("%H-%M-%S"));
    pingpong.allocate(ofGetScreenWidth(), ofGetScreenHeight());
    video = NULL;
    
    reloadShader("shader.fs");
}
Пример #12
0
void CpuClipmapRenderer::onCreateGpuResources()
{
    assert( window_ );

#ifndef OLD_GEOCLIP
    _pTerrainShader = SimpleSHLChunk::create();
#endif

    reloadShader();

    const int levelCount = int(levels_.size());

    // if the extension is supported:
    useVertexBufferObjects_ = true;

    for( int i = 0; i < levelCount; ++i )
    {
        TerrainLevelRenderData& levelData = levels_[ i ];
        GeometryClipmapLevel& level = geoClipmaps_->getLevel( i );

        // create vbo for the vertex data:
        // todo: create a dynamic vbo for the index data?
        const int vertexCount = int(levelData.vertices.size());

        // todo: use ReadOnly Vbo (for speed)
        if( !levelData.vertexBuffer.create( window_, GL_ARRAY_BUFFER_ARB, sizeof( OpenGLTerrainVertex ) * vertexCount, BufferUsage_Dynamic_ReadWrite ) )
        {
            useVertexBufferObjects_ = false;
            break;
        }
        levelData.vertexBuffer.uploadData( &levelData.vertices[ 0 ], 0, sizeof( OpenGLTerrainVertex ) * vertexCount );
        levelData.vertexBuffer.deactivate();

        // create the texture:
        levelData.texture = TextureObjChunk::create();


        levelData.texture->setImage( level.textureData );
        levelData.texture->setMinFilter( GL_NEAREST );		// TODO: use linear min/mag filters (but no mipmapping!
        levelData.texture->setMagFilter( GL_NEAREST );
        levelData.texture->setWrapS( GL_REPEAT );
        levelData.texture->setWrapT( GL_REPEAT );
        //levelData.texture->setEnvMode( GL_MODULATE );
    }
}
Пример #13
0
//--------------------------------------------------------------
void ofApp::setup(){
    
    // OF init
    ofEnableDepthTest();
    
    oculusRift.baseCamera = &cam;
    oculusRift.setup();
    oculusRift.fullscreenOnRift();
    
    reloadShader();
    
    // rect textures are fine by default in GL3, we can just use GL_TEXTURE_2D.
    // disabling allows simpler normalized texture coordinates, not pixel coords
    ofDisableArbTex();
    
    panoLeft.loadImage("panoL.jpg");
    panoRight.loadImage("panoR.jpg");
    
    cam.setAutoDistance(false);
}
Пример #14
0
//--------------------------------------------------------------
void ofApp::keyPressed(int key){
    
    // dismiss safety warning on any key
    oculusRift.dismissSafetyWarning();
    
    if( key == 'f' )
    {
        //gotta toggle full screen for it to be right
        ofToggleFullscreen();
    }
    if(key == 's'){
        reloadShader();
    }
    if(key == 'v'){
        oculusRift.setNoVsync( !oculusRift.getNoVsync() );
    }
    if(key == 'z'){
        cout << "FPS: " << ofGetFrameRate() << endl;
    }
    
}
Пример #15
0
void MainWindow::viewerInitialized()
{
	// Only do init once
	disconnect(m_ui->centralWidget, SIGNAL(viewerInitialized()), this, SLOT(viewerInitialized()));

	m_ui->centralWidget->addToRenderList(&m_model);
	m_ui->centralWidget->addToAnimateList(&m_model);
	m_meshDock->setModel(&m_model);

	m_actionEnableUserShaders = new QAction("Enable external shaders", this);
	m_actionEnableUserShaders->setCheckable(true);
	m_actionEnableUserShaders->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_E));
	connect(m_actionEnableUserShaders, SIGNAL(triggered(bool)), this, SLOT(actionEnableUserShaders(bool)));

	m_actionLocateUserShaders = new QAction("Locate external shaders...", this);
	m_actionLocateUserShaders->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_L));
	connect(m_actionLocateUserShaders, SIGNAL(triggered()), this, SLOT(actionLocateUserShaders()));

	m_actionReloadUserShaders = new QAction("Reload external shaders", this);
	m_actionReloadUserShaders->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_R));
	connect(m_actionReloadUserShaders, SIGNAL(triggered()), this, SLOT(actionReloadUserShader()));

	m_shaderGroup = new QActionGroup(this);

	for (int i = WZ_SHADER__FIRST; i < WZ_SHADER__LAST; ++i)
	{
		QString shadername = QWZM::shaderTypeToString(static_cast<wz_shader_type_t>(i));

		QAction* shaderAct = new QAction(shadername, this);

		m_shaderSignalMapper->setMapping(shaderAct, i);
		shaderAct->setActionGroup(m_shaderGroup);

		if (i < 9) // FIXME
			shaderAct->setShortcut(QKeySequence(tr("Ctrl+%1").arg(i+1)));
		shaderAct->setCheckable(true);

		reloadShader(static_cast<wz_shader_type_t>(i), false);

		connect(shaderAct, SIGNAL(triggered()), m_shaderSignalMapper, SLOT(map()));
	}

	connect(m_shaderSignalMapper, SIGNAL(mapped(int)), this, SLOT(shaderAction(int)));

	QMenu* rendererMenu = new QMenu(this);
	rendererMenu->addActions(m_shaderGroup->actions());

	// other user shader related stuff
	rendererMenu->addSeparator();
	rendererMenu->addAction(m_actionEnableUserShaders);
	rendererMenu->addAction(m_actionLocateUserShaders);
	rendererMenu->addAction(m_actionReloadUserShaders);

	m_ui->actionRenderer->setMenu(rendererMenu);

	connect(m_ui->actionShowModelCenter, SIGNAL(triggered(bool)),
		&m_model, SLOT(setDrawCenterPointFlag(bool)));
	connect(m_ui->actionShowNormals, SIGNAL(triggered(bool)),
		&m_model, SLOT(setDrawNormalsFlag(bool)));
	connect(m_ui->actionShowNormals, SIGNAL(triggered(bool)),
		m_ui->actionShow_Tangent_And_Bitangent, SLOT(setEnabled(bool)));
	connect(m_ui->actionShow_Tangent_And_Bitangent, SIGNAL(triggered(bool)),
		&m_model, SLOT(setDrawTangentAndBitangentFlag(bool)));
	connect(m_ui->actionShow_Connectors, SIGNAL(triggered(bool)),
		&m_model, SLOT(setDrawConnectors(bool)));

	/// Load previous state
	m_ui->actionShowModelCenter->setChecked(m_settings->value("3DView/ShowModelCenter", false).toBool());
	m_model.setDrawCenterPointFlag(m_ui->actionShowModelCenter->isChecked());

	m_ui->actionShowNormals->setChecked(m_settings->value("3DView/ShowNormals", false).toBool());
	m_model.setDrawNormalsFlag(m_ui->actionShowNormals->isChecked());

	m_ui->actionShow_Connectors->setChecked(m_settings->value("3DView/ShowConnectors", false).toBool());
	m_model.setDrawConnectors(m_ui->actionShow_Connectors->isChecked());

	m_ui->actionShow_Tangent_And_Bitangent->setChecked(m_settings->value("3DView/ShowTangentAndBitangent", false).toBool());
	m_model.setDrawTangentAndBitangentFlag(m_ui->actionShow_Tangent_And_Bitangent->isChecked());
	m_ui->actionShow_Tangent_And_Bitangent->setEnabled(m_ui->actionShowNormals->isChecked());

	m_ui->actionShowAxes->setChecked(m_settings->value("3DView/ShowAxes", true).toBool());
	m_ui->actionShowGrid->setChecked(m_settings->value("3DView/ShowGrid", true).toBool());

	m_ui->actionShowLightSource->setChecked(m_settings->value("3DView/ShowLightSource", true).toBool());
	m_ui->actionLink_Light_Source_To_Camera->setChecked(m_settings->value("3DView/LinkLightToCamera", true).toBool());

	m_actionEnableUserShaders->setChecked(m_settings->value("3DView/EnableUserShaders", false).toBool());
	m_ui->actionAnimate->setChecked(m_settings->value("3DView/Animate", true).toBool());

	actionEnableUserShaders(m_actionEnableUserShaders->isChecked());

	// Default to 3.1
	int shaderTag = m_settings->value("3DView/ShaderTag", wz_shader_type_tag[WZ_SHADER_WZ31]).toInt();
	int shaderActIdx = -1;
	for (int i = WZ_SHADER__FIRST; i < WZ_SHADER__LAST; ++i)
	{
		if (shaderTag == wz_shader_type_tag[i])
			shaderActIdx = i;
	}
	// Select any previous selection
	if (shaderActIdx >= 0)
	{
		if (m_shaderGroup->actions().at(shaderActIdx)->isEnabled())
			m_shaderGroup->actions().at(shaderActIdx)->activate(QAction::Trigger);
		else
			shaderActIdx = -1;
	}

	// Otherwise use old approach
	if (shaderActIdx < 0)
	{
		for (int i = m_shaderGroup->actions().size() - 1; i >= 0; --i)
		{
			if (m_shaderGroup->actions().at(i)->isEnabled())
			{
				m_shaderGroup->actions().at(i)->activate(QAction::Trigger);
				break;
			}
		}
	}
}
Пример #16
0
void App::update(float delta_time) {
	if (anim_play) frame_count++;

	if (!hide_gui) gui();

	// autoreload frag shader (every 60 frames)
	if (shader_filepath && shader_file_autoreload && (frame_count % 60) == 0) {
		struct stat attr;
		if (!stat(shader_filepath, &attr)) { // file exists
			if (attr.st_mtime > shader_file_mtime) { // file has been modified
				shader_file_mtime = (int)attr.st_mtime;
				reloadShader();
			}
		}
	}

	// update camera (-z: forward, y: up)
	camera_euler_angles += 2.0f*delta_time
		* v3(-movement_command.rotate.x, -movement_command.rotate.y, 0.0f);
	camera_euler_angles.x = fminf(fmaxf(-0.5f*(float)M_PI, camera_euler_angles.x), 0.5f*(float)M_PI); // clamp
	mat3 rot_x = rotationMatrix(v3(1.0f, 0.0f, 0.0f), camera_euler_angles.x);
	mat3 rot_y = rotationMatrix(v3(0.0f, 1.0f, 0.0f), camera_euler_angles.y);
	mat3 rot_z = rotationMatrix(v3(0.0f, 0.0f, 1.0f), camera_euler_angles.z);
	mat3 rot = rot_y * rot_x * rot_z;
	camera_location += rot * (8.0f*delta_time*movement_command.move);
	mat4 view_to_world = translationMatrix(camera_location) * m4(rot);
	mat4 world_to_view = m4(transpose(rot)) * translationMatrix(-camera_location);

	// bind textures
	for (int tsi = 0; tsi < (int)ARRAY_COUNT(texture_slots); tsi++) {
		glActiveTexture(GL_TEXTURE0+tsi);
		glBindTexture(texture_slots[tsi].target, texture_slots[tsi].texture);
	}

	// draw fullscreen triangle(s)
	glClearColor(0.2f, 0.21f, 0.22f, 1.0f);
	glClear(GL_COLOR_BUFFER_BIT);
	{ BindShader bind_shader(shader);
		if (!compile_error_log) {
			for (int i = 0; i < uniform_count; i++) {
				uniforms[i].apply();
			}
		}

		// apply builtin uniforms
		u_time = (float)frame_count / 60.0f;
		glUniform1f(shader.getUniformLocation(u_time_name), u_time);
		vec2 u_resolution = v2(video.pixel_scale*video.width, video.pixel_scale*video.height);
		glUniform2fv(shader.getUniformLocation(u_resolution_name), 1, u_resolution.e);
		glUniformMatrix4fv(shader.getUniformLocation(u_view_to_world_name), 1, GL_FALSE, view_to_world.e);
		glUniformMatrix4fv(shader.getUniformLocation(u_world_to_view_name), 1, GL_FALSE, world_to_view.e);

		if (single_triangle_mode) {
			{ BindArrayBuffer bind_array_buffer(single_triangle_vbo);
				glEnableVertexAttribArray(VAT_POSITION);
				glVertexAttribPointer(VAT_POSITION, 2, GL_FLOAT, GL_FALSE, 0, (GLvoid*)0);
				glDrawArrays(GL_TRIANGLES, 0, 3);
				glDisableVertexAttribArray(VAT_POSITION);
			}
		} else {
			{ BindArrayBuffer bind_array_buffer(two_triangles_vbo);
				glEnableVertexAttribArray(VAT_POSITION);
				glVertexAttribPointer(VAT_POSITION, 2, GL_FLOAT, GL_FALSE, 0, (GLvoid*)0);
				glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
				glDisableVertexAttribArray(VAT_POSITION);
			}
		}
	}
}
//events are called when the system is active
//Feel free to make things interactive for you, and for the user!
void CloudsVisualSystemLaplacianTunnel::selfKeyPressed(ofKeyEventArgs & args){
	if(args.key == 'R'){
		reloadShader();
	}
}
Пример #18
0
bool UIShader::load(string _fragShader, string _vertShader, string _geomShader){
    return reloadShader(_fragShader,_vertShader, _geomShader);
}
Пример #19
0
void CpuClipmapRenderer::onRender( const ClipmapRenderParameters& renderParameters )
{
    // activate the gpu program:
    //glDisable( GL_LIGHTING );
#ifdef OLD_GEOCLIP
    terrainShader_.activate();

    if( programTextChanged_ )
    {
        reloadShader();
        programTextChanged_ = false;
    }
#else
    _pTerrainShader->activate(renderParameters.drawEnv);
#endif

//    bool useDependentTextureLookup = false;

    if( renderParameters.globalTextureObj != NULL )
    {
        renderParameters.globalTextureObj->activate( renderParameters.drawEnv );
        renderParameters.globalTextureEnv->activate( renderParameters.drawEnv );
    }
    else if( renderParameters.heightColorTexture != NULL )
    {
        // todo: use a different pixel shader here
//        useDependentTextureLookup = true;
        renderParameters.heightColorTexture->activate( renderParameters.drawEnv );
    }

    // render all levels from finest to coarsest:
    const int levelCount = int(levels_.size());

    //		for( int i = 0; i < levelCount; ++i )
    for( int i = 0; i < levelCount; ++i )
    {
        int levelIdx = levelCount - i - 1;

        //std::cerr << "Rendering Level " << levelIdx << std::endl;

        GeometryClipmapLevel& level = geoClipmaps_->getLevel( levelIdx );
        GeometryClipmapLevel* coarserLevel = 0;
        GeometryClipmapLevel* finerLevel = 0;

        if( levelIdx > 0 )
        {
            coarserLevel = &geoClipmaps_->getLevel( levelIdx - 1 );
        }
        if( levelIdx + 1 < levelCount )
        {
            finerLevel = &geoClipmaps_->getLevel( levelIdx + 1 );
        }

        const Color3f& debugColor = getDebugColor( levelIdx );

#ifdef OLD_GEOCLIP
        terrainShader_.setUniform(
            "baseColor0", colorToVector( debugColor ) );

        terrainShader_.setUniform(
            "sampleDistance",
            renderParameters.worldTransform.sampleDistance );

        terrainShader_.setUniform(
            "worldOffset",
            renderParameters.worldTransform.offset );

        terrainShader_.setUniform(
            "heightScale",
            renderParameters.worldTransform.heightScale );

        terrainShader_.setUniform(
            "heightOffset",
            renderParameters.worldTransform.heightOffset );
#else
#ifdef NOTUSED
        _pTerrainShader->setUniformParameter(
            "baseColor0", colorToVector( debugColor ) );
#endif
        _pTerrainShader->addUniformVariable(
            "sampleDistance",
            renderParameters.worldTransform.sampleDistance );

        _pTerrainShader->addUniformVariable(
            "worldOffset",
            renderParameters.worldTransform.offset );

        _pTerrainShader->addUniformVariable(
            "heightScale",
            renderParameters.worldTransform.heightScale );

        _pTerrainShader->addUniformVariable(
            "heightOffset",
            renderParameters.worldTransform.heightOffset );
#endif
        if( renderParameters.showTransitionRegions )
        {
            // todo: add a sensible debug representation..
            drawSampleRectangle( level.getCoveredSampleRect(),
                                 debugColor,
                                 renderParameters.worldTransform );
            //drawSamples( level, Color3f( 0, 1, 0 ) );
            //drawVertices( level, debugColor );
            drawBlendLines( level,
                            debugColor,
                            renderParameters.worldTransform );
        }

        if( !level.isActive )
        {
            continue;
        }
        // only use the finer level, if it is active:
        if( finerLevel && !finerLevel->isActive )
        {
            finerLevel = 0;
        }

        // buildIndices dynamically builds the indices for this level and
        // does frustum culling
        // the method returns false if nothing is visible

        // todo: dont rebuild the indices every time.. just rebuild them if
        // something changed (inside the update() call)

        if( buildIndices( level, finerLevel ) )
        {
            // finally: draw the block:
            renderBlock( level, coarserLevel, renderParameters, debugColor );
        }

        stats_.drawnLevelCount++;
    }

    if( renderParameters.globalTextureObj != NULL )
    {
        renderParameters.globalTextureObj->deactivate(
            renderParameters.drawEnv );
        renderParameters.globalTextureEnv->deactivate(
            renderParameters.drawEnv );
    }
    else if(renderParameters.heightColorTexture != NULL)
    {
        renderParameters.heightColorTexture->deactivate(
            renderParameters.drawEnv );
    }

#ifdef OLD_GEOCLIP
    terrainShader_.deactivate();
#else
    _pTerrainShader->deactivate(renderParameters.drawEnv);
#endif

}
Пример #20
0
void Raycaster::draw(
        GLint volumeTextureHandle,
        GLint importanceVolumeTextureHandle,
        glm::vec3 volumeScale,
        glm::vec3 volumeResolution,
        VolumeProperties volumeProperties,
        GLfloat aspectRatio,
        GLfloat fieldOfView,
        glm::vec3 cameraPosition,
        glm::mat4 viewMatrix,
        glm::vec3 sunDirection,
        glm::vec3 sunColor,
        GLfloat sunBrightness,
        glm::vec3 ambientColor,
        GLint colorAlphaFunctionHandle,
        GLint ambientSpecularFunctionHandle,
        GLint advancedFunctionHandle,
        GLint colorAlphaPreintegrationHandle,
        GLint ambientSpecularPreintegrationHandle,
        GLint advancedPreintegrationHandle,
        GLint tfResolution,
        GLint reflectionHandle,
        glm::vec3 volumeExtent,
        glm::vec3 volumeExtentOffset)
{
    if(shaderShouldBeReloaded)
    {
        reloadShader();
        shaderShouldBeReloaded = GL_FALSE;
    }

    // basicInput.x has many jobs
    // Standard:				stepSize
    // Adaptive Sampling:		minAdaptiveStepSize
    // Voxel Spaced Samp.:		stepSizeMultiplier
    // Ad. Voxel Spaced Samp.:	minAdaptiveStepSizeMultiplier

    // Set basic input (need not to be set each frame..)
    glm::vec4 basicInput;
    GLfloat stepSize;
    GLfloat minAdaptiveStepSize;
    GLfloat maxAdaptiveStepSize;

    // When voxel spaced sampling is used, step size depends on direction and volume
    if(!useVoxelSpacedSampling)
    {
        stepSize = properties.stepSize;
        minAdaptiveStepSize = properties.minAdaptiveStepSize;
        maxAdaptiveStepSize = properties.maxAdaptiveStepSize;
    }
    else
    {
        stepSize = 1;
        minAdaptiveStepSize = 1;
        maxAdaptiveStepSize = 1;
    }

    if(useAdaptiveSampling)
    {
        // Max adaptive step size is filled into advanced input's w value
        basicInput.x = minAdaptiveStepSize * properties.minAdaptiveStepSizeMultiplier;
    }
    else
    {
        basicInput.x = stepSize * properties.stepSizeMultiplier;
    }
    basicInput.y = static_cast<GLfloat>(properties.outerIterations);
    basicInput.z = static_cast<GLfloat>(properties.innerIterations);
    basicInput.w = properties.alphaThreshold;

    // Set advanced input
    glm::vec4 advancedInput;
    advancedInput.x = properties.jitteringRangeMultiplier;
    advancedInput.y = properties.normalRangeMultiplier;
    advancedInput.z = properties.fresnelPower;
    advancedInput.w = maxAdaptiveStepSize * properties.maxAdaptiveStepSizeMultiplier;

    // Set volume value information
    glm::vec2 volumeValueInformation;
    volumeValueInformation.x = volumeProperties.valueOffset;
    volumeValueInformation.y = volumeProperties.valueScale;

    glm::vec3 mirrorUVW(0,0,0);
    if(volumeProperties.mirrorX)
    {
        mirrorUVW.x = 1;
    }
    if(volumeProperties.mirrorY)
    {
        mirrorUVW.y = 1;
    }
    if(volumeProperties.mirrorZ)
    {
        mirrorUVW.z = 1;
    }

    // Compute model matrix
    glm::mat4 modelScaleMatrix = glm::mat4(1.0f);
    glm::mat4 modelRotationMatrix = glm::mat4(1.0f);
    modelScaleMatrix = glm::scale(modelScaleMatrix,	volumeProperties.voxelScaleMultiplier * volumeScale);
    modelRotationMatrix = glm::rotate(modelRotationMatrix, glm::radians(volumeProperties.eulerZXZRotation.z), glm::vec3(0.0f, 0.0f, 1.0f));
    modelRotationMatrix = glm::rotate(modelRotationMatrix, glm::radians(volumeProperties.eulerZXZRotation.y), glm::vec3(1.0f, 0.0f, 0.0f));
    modelRotationMatrix = glm::rotate(modelRotationMatrix, glm::radians(volumeProperties.eulerZXZRotation.x), glm::vec3(0.0f, 0.0f, 1.0f));

    // Compute projection matrix
    glm::mat4 projectionMatrix = glm::perspective(glm::radians(fieldOfView), aspectRatio, 0.1f, 100.f);

    // Use program because setUniform needs ist
    shader.use();

    // Set matrices and vectors
    shader.setUniformValue(uniformModelScaleHandle, modelScaleMatrix);
    shader.setUniformValue(uniformModelRotationHandle, modelRotationMatrix);
    shader.setUniformValue(uniformViewHandle, viewMatrix);
    shader.setUniformValue(uniformProjectionHandle, projectionMatrix);
    shader.setUniformValue(uniformCameraPosHandle, cameraPosition);
    shader.setUniformValue(uniformBasicInputHandle, basicInput);
    shader.setUniformValue(uniformAdvancedInputHandle, advancedInput);
    shader.setUniformValue(uniformVolumeValueInformationHandle, volumeValueInformation);
    shader.setUniformValue(uniformMirrorUVWHandle, mirrorUVW);

    // Volume clipping
    glm::mat4 volumeExtentMatrix = glm::mat4(1.0f);
    volumeExtentMatrix = glm::scale(volumeExtentMatrix,	volumeExtent);
    shader.setUniformValue(uniformVolumeExtentHandle, volumeExtentMatrix);
    shader.setUniformValue(uniformVolumeExtentOffsetHandle, volumeExtentOffset);

    // Set up depending on defines
    shader.setUniformTexture(uniformVolumeHandle, volumeTextureHandle, GL_TEXTURE_3D);

    if(usePreintegration)
    {
        shader.setUniformTexture(uniformColorAlphaPreintegrationHandle, colorAlphaPreintegrationHandle, GL_TEXTURE_2D);
    }
    else
    {
        shader.setUniformTexture(uniformColorAlphaHandle, colorAlphaFunctionHandle, GL_TEXTURE_1D);
    }

    if(useGradientAlphaMultiplier || useFresnelAlphaMultiplier || useReflectionColorMultiplier || useEmissionColorMultiplier)
    {
        if(usePreintegration)
        {
            shader.setUniformTexture(uniformAdvancedPreintegrationHandle, advancedPreintegrationHandle, GL_TEXTURE_2D);
        }
        else
        {
            shader.setUniformTexture(uniformAdvancedHandle, advancedFunctionHandle, GL_TEXTURE_1D);
        }
    }

    if(useReflectionColorMultiplier)
    {
        shader.setUniformTexture(uniformReflectionHandle, reflectionHandle, GL_TEXTURE_2D);
    }

    if(useLocalIllumination)
    {
        if(usePreintegration)
        {
            shader.setUniformTexture(uniformAmbientSpecularPreintegrationHandle, ambientSpecularPreintegrationHandle, GL_TEXTURE_2D);
        }
        else
        {
            shader.setUniformTexture(uniformAmbientSpecularHandle, ambientSpecularFunctionHandle, GL_TEXTURE_1D);
        }
        shader.setUniformValue(uniformSunDirectionHandle, sunDirection);
        shader.setUniformValue(uniformSunColorHandle, glm::vec4(sunColor, sunBrightness));
        shader.setUniformValue(uniformAmbientColorHandle, ambientColor);
    }

    if(useJittering)
    {
        shader.setUniformTexture(uniformNoiseHandle, noiseHandle, GL_TEXTURE_2D);
    }

    if(useAdaptiveSampling)
    {
        shader.setUniformTexture(uniformImportanceVolumeHandle, importanceVolumeTextureHandle, GL_TEXTURE_3D);
    }

    if(useVoxelSpacedSampling)
    {
        shader.setUniformValue(uniformVolumeResolutionHandle, volumeResolution);
    }

    // Draw it
    shader.draw(GL_TRIANGLES);
}