예제 #1
0
void VPLShaderManager::drawBackground(const Sensor *sensor,
		const Transform &projectionTransform, Float scaleFactor) {
	if (m_backgroundProgram == NULL)
		return;

	const Transform &trafo = sensor->getWorldTransform()->eval(0);

	Transform clipToWorld = trafo
		* Transform::scale(Vector(-1, 1, -1)) * projectionTransform.inverse();

	GPUProgram *prog = m_backgroundProgram;
	int tuOffset = 0;
	prog->bind();
	m_backgroundDependencies.bind(prog, m_backgroundDependencies, tuOffset);

	if (sensor->getType() & Sensor::EOrthographicCamera) {
		Vector d = trafo(Vector(0.0f, 0.0f, 1.0f));
		prog->setParameter(m_backgroundParam_camDirection, d);
	} else {
		Point p = trafo(Point(0.0f));
		prog->setParameter(m_backgroundParam_camPosition, p);
	}

	prog->setParameter(m_backgroundParam_emitterScale, scaleFactor);
	prog->setParameter(m_backgroundParam_clipToWorld, clipToWorld);
	m_renderer->blitQuad(false);
	prog->unbind();
	m_backgroundDependencies.unbind();
}
예제 #2
0
void VPLShaderManager::bind(const VPL &vpl, const BSDF *bsdf, const Sensor *sensor,
		const Emitter *emitter, const Matrix4x4 &instanceTransform, bool faceNormals) {
	Shader *bsdfShader = m_renderer->getShaderForResource(bsdf);
	Shader *vplShader = (vpl.type == EPointEmitterVPL || vpl.type == EDirectionalEmitterVPL)
		? m_renderer->getShaderForResource(vpl.emitter)
		: m_renderer->getShaderForResource(vpl.its.getBSDF());
	Shader *emitterShader = (emitter == NULL) ? NULL
		: m_renderer->getShaderForResource(emitter);

	/* Find situations in which we won't be able to render the
	   object properly ...  Case 1: one of the shaders is missing */
	bool unsupported = bsdfShader == NULL || vplShader == NULL ||
		(emitter != NULL && emitterShader == NULL);

	/* The material uses face normals (which have to be generated on the fly), and:
	     case 2: anisotropy is active as well
	     case 3: the graphics card does not support geometry shaders
	*/
	if (faceNormals)
		unsupported |= (bsdf->getType() & BSDF::EAnisotropic)
			|| !m_renderer->getCapabilities()->isSupported(
				RendererCapabilities::EGeometryShaders);

	if (unsupported) {
		std::map<std::string, VPLConfiguration>::iterator it
			= m_configurations.find("unsupported");
		m_targetConfiguration = VPLConfiguration();
		if (it != m_configurations.end()) {
			/* A program for this configuration has been created previously */
			m_currentProgram = (*it).second;
		} else {
			m_currentProgram = VPLConfiguration();
			ref<GPUProgram> prog = m_renderer->createGPUProgram("Unsupported material program");
			prog->setSource(GPUProgram::EVertexProgram, sh_unsupported_vert);
			prog->setSource(GPUProgram::EFragmentProgram, sh_unsupported_frag);
			prog->init();
			prog->incRef();
			m_currentProgram.program = prog;

			m_currentProgram.param_instanceTransform = prog->getParameterID("instanceTransform", false);
			m_configurations["unsupported"] = m_currentProgram;
		}
		GPUProgram *prog = m_currentProgram.program;
		prog->bind();
		prog->setParameter(m_currentProgram.param_instanceTransform, instanceTransform);
		return;
	}

	m_targetConfiguration = VPLConfiguration(vplShader,
		bsdfShader, emitterShader, faceNormals);

	m_alpha = bsdfShader->getAlpha();

	/* Generate a fingerprint of this shader chain, and check if it is known */
	std::string fingerprint = m_targetConfiguration.toString();

	if (m_diffuseSources)
		fingerprint += ", ds";
	if (m_diffuseReceivers)
		fingerprint += ", dr";

	std::map<std::string, VPLConfiguration>::iterator it
		= m_configurations.find(fingerprint);

	bool directionalCamera = false;
	if (sensor->getType() & Sensor::EOrthographicCamera) {
		directionalCamera = true;
	} else if (!(sensor->getType() & Sensor::EPerspectiveCamera)) {
		/* Sensor is neither a perspective nor orthographic camera */
		Log(EError, "Unsupported sensor type!");
	}

	if (it != m_configurations.end()) {
		/* A program for this configuration has been created previously */
		m_currentProgram = (*it).second;
	} else {
		std::ostringstream oss;
		std::string vplEvalName, bsdfEvalName, emitterEvalName;
		m_targetConfiguration.generateCode(oss, vplEvalName, bsdfEvalName, emitterEvalName);
		m_currentProgram = m_targetConfiguration;

		ref<GPUProgram> prog = m_renderer->createGPUProgram(fingerprint);
		prog->setSource(GPUProgram::EVertexProgram, sh_render_vert);

		if (faceNormals) {
			prog->setSource(GPUProgram::EGeometryProgram, sh_render_geom);
			prog->setInputGeometryType(GPUProgram::ETriangles);
			prog->setOutputGeometryType(GPUProgram::ETriangleStrips);
			prog->setMaxVertices(3);
		}

		std::string code(sh_render_frag);
		std::string marker(SUPPLEMENTAL_CODE_MARKER);
		size_t insertionPos = code.find(marker);
		Assert(insertionPos != std::string::npos);
		code.replace(insertionPos, marker.length(), oss.str());

		prog->setSource(GPUProgram::EFragmentProgram, code);

		if (bsdf->getType() & BSDF::EAnisotropic)
			prog->define("ANISOTROPIC");

		if (fingerprint.find("VertexColor") != std::string::npos)
			prog->define("VERTEX_COLORS");

		if (m_shadowMapType == ShadowMapGenerator::EDirectional)
			prog->define("DIRECTIONAL_VPL");
		else if (m_shadowMapType == ShadowMapGenerator::EParaboloid)
			prog->define("PARABOLOIDAL_VPL");
		else
			prog->define("CUBEMAP_VPL");

		if (directionalCamera)
			prog->define("DIRECTIONAL_CAMERA");

		if (faceNormals)
			prog->define("FACE_NORMALS");

		if (vpl.type == EDirectionalEmitterVPL || vpl.type == EPointEmitterVPL) {
			prog->define("EMITTER_VPL");
			prog->define("VPL_EVAL_NAME", vplEvalName + "_dir");
		} else {
			if (m_diffuseSources)
				prog->define("VPL_EVAL_NAME", vplEvalName + "_diffuse");
			else
				prog->define("VPL_EVAL_NAME", vplEvalName);
		}

		if (vpl.type == ESurfaceVPL || (vpl.type == EPointEmitterVPL &&
				vpl.emitter->getType() & Emitter::EOnSurface))
			prog->define("VPL_ON_SURFACE");

		if (emitterShader) {
			prog->define("EMITTER_AREA_EVAL_NAME", emitterEvalName + "_area");
			prog->define("EMITTER_DIR_EVAL_NAME", emitterEvalName + "_dir");
		}

		if (m_diffuseReceivers)
			prog->define("BSDF_EVAL_NAME", bsdfEvalName + "_diffuse");
		else
			prog->define("BSDF_EVAL_NAME", bsdfEvalName);

		prog->init();
		prog->incRef();
		m_currentProgram.program = prog;

		m_currentProgram.param_camPosition       = prog->getParameterID("camPosition", false);
		m_currentProgram.param_camDirection      = prog->getParameterID("camDirection", false);
		m_currentProgram.param_vplPosition       = prog->getParameterID("vplPosition", false);
		m_currentProgram.param_vplDirection      = prog->getParameterID("vplDirection", false);
		m_currentProgram.param_vplPower          = prog->getParameterID("vplPower", false);
		m_currentProgram.param_vplTransform      = prog->getParameterID("vplTransform", false);
		m_currentProgram.param_vplFrame          = prog->getParameterID("vplFrame", false);
		m_currentProgram.param_vplUV             = prog->getParameterID("vplUV", false);
		m_currentProgram.param_vplWi             = prog->getParameterID("vplWi", false);
		m_currentProgram.param_minDistSqr        = prog->getParameterID("minDistSqr", false);
		m_currentProgram.param_emitterScale      = prog->getParameterID("emitterScale", false);
		m_currentProgram.param_depthRange        = prog->getParameterID("depthRange", false);
		m_currentProgram.param_instanceTransform = prog->getParameterID("instanceTransform", false);
		m_currentProgram.param_shadowMap         = prog->getParameterID("shadowMap", false);
		m_currentProgram.resolve(prog);
		m_configurations[fingerprint] = m_currentProgram;

		statsMaxResidentShaders.recordMaximum(m_configurations.size() + m_shadowGen->getShaderCount());
	}

	GPUProgram *prog = m_currentProgram.program;
	prog->bind();

	Float minDist = m_nearClip + (m_farClip - m_nearClip) * m_clamping;
	prog->setParameter(m_currentProgram.param_instanceTransform, instanceTransform);
	prog->setParameter(m_currentProgram.param_vplTransform, m_shadowMapTransform);
	prog->setParameter(m_currentProgram.param_depthRange, Vector2(m_nearClip, m_farClip));
	prog->setParameter(m_currentProgram.param_vplPower, vpl.P);
	prog->setParameter(m_currentProgram.param_vplFrame,
		Matrix3x3(vpl.its.shFrame.s, vpl.its.shFrame.t, vpl.its.shFrame.n));
	prog->setParameter(m_currentProgram.param_vplUV, vpl.its.uv);
	prog->setParameter(m_currentProgram.param_vplWi, vpl.its.wi);
	prog->setParameter(m_currentProgram.param_shadowMap, m_shadowMap);
	prog->setParameter(m_currentProgram.param_minDistSqr, minDist*minDist);
	prog->setParameter(m_currentProgram.param_emitterScale, vpl.emitterScale);

	if (directionalCamera) {
		Vector d = sensor->getWorldTransform()->eval(0)(Vector(0.0f, 0.0f, 1.0f));
		prog->setParameter(m_currentProgram.param_camDirection, d);
	} else {
		Point p = sensor->getWorldTransform()->eval(0).transformAffine(Point(0.0f));
		prog->setParameter(m_currentProgram.param_camPosition, p);
	}

	if (m_shadowMapType == ShadowMapGenerator::EDirectional)
		prog->setParameter(m_currentProgram.param_vplDirection, vpl.its.shFrame.n);
	else
		prog->setParameter(m_currentProgram.param_vplPosition, vpl.its.p);

	m_targetConfiguration.bind(m_currentProgram, 1);
}
예제 #3
0
void VPLShaderManager::configure(const VPL &vpl, const BSDF *bsdf, 
			const Luminaire *luminaire, const Point &camPos, bool faceNormals) {
	Shader *bsdfShader = m_renderer->getShaderForResource(bsdf);
	Shader *vplShader = (vpl.type == ELuminaireVPL)
		? m_renderer->getShaderForResource(vpl.luminaire)
		: m_renderer->getShaderForResource(vpl.its.shape->getBSDF());
	Shader *lumShader = (luminaire == NULL) ? NULL 
		: m_renderer->getShaderForResource(luminaire);
	std::ostringstream oss;

	if (bsdfShader == NULL || vplShader == NULL ||
		(luminaire != NULL && lumShader == NULL)) {
		/* Unsupported! */
		m_renderer->setColor(Spectrum(0.0f));
		return;
	}

	bool anisotropic = bsdf->getType() & BSDF::EAnisotropic;

	m_targetConfig = VPLProgramConfiguration(vplShader, bsdfShader, 
			lumShader, faceNormals);
	m_targetConfig.toString(oss);
	std::string configName = oss.str();
	std::map<std::string, ProgramAndConfiguration>::iterator it =
		m_programs.find(configName);
	GPUProgram *program = NULL;

	if (it != m_programs.end()) {
		/* A program for this configuration has been created previously */
		m_current = (*it).second;
		program = m_current.program;
	} else {
		/* No program for this particular combination exists -- create one */
		program = m_renderer->createGPUProgram(configName);

		if (faceNormals) {
			/* Generate face normals in a geometry shader */
	
    		if (!m_renderer->getCapabilities()->isSupported(
					RendererCapabilities::EGeometryShaders))
				Log(EError, "Face normals require geometry shader support!");
			if (anisotropic)
				Log(EError, "Anisotropy and face normals can't be combined at the moment");
	
			oss.str("");
			oss << "#version 120" << endl
				<< "#extension GL_EXT_geometry_shader4 : enable" << endl
				<< "varying in vec3 lightVec_vertex[3], camVec_vertex[3];" << endl
				<< "varying in vec2 uv_vertex[3];" << endl
				<< "varying in vec3 vertexColor_vertex[3];" << endl
				<< "varying out vec3 normal;" << endl
				<< "varying out vec3 lightVec, camVec;" << endl
				<< "varying out vec2 uv;" << endl
				<< "varying out vec3 vertexColor;" << endl
				<< endl
				<< "void main() {" << endl
				<< "   vec3 edge1 = camVec_vertex[0]-camVec_vertex[1];" << endl
				<< "   vec3 edge2 = camVec_vertex[0]-camVec_vertex[2];" << endl
				<< "   normal = normalize(cross(edge1, edge2));" << endl
				<< "   gl_Position = vec4(0.0);" << endl
				<< "   lightVec = camVec = vec3(0.0);" << endl
				<< "   for (int i=0; i<gl_VerticesIn; ++i) {" << endl
				<< "      gl_Position = gl_PositionIn[i];" << endl
				<< "      uv = uv_vertex[i];" << endl
				<< "      vertexColor = vertexColor_vertex[i];" << endl
				<< "      lightVec = lightVec_vertex[i];" << endl
				<< "      camVec = camVec_vertex[i];" << endl
				<< "      EmitVertex();" << endl
				<< "   }" << endl
				<< "   EndPrimitive();" << endl
				<< "}" << endl;

			program->setMaxVertices(3); 
			program->setSource(GPUProgram::EGeometryProgram, oss.str());
		}

		/* Vertex program */
		oss.str("");
        oss << "#version 120" << endl;
		if (anisotropic)
			oss << "varying vec3 tangent;" << endl;
		oss << "uniform vec3 vplPos, camPos;" << endl;

		if (!faceNormals) {
			oss << "varying vec3 lightVec, camVec;" << endl
				<< "varying vec2 uv;" << endl
				<< "varying vec3 normal;" << endl
				<< "varying vec3 vertexColor;" << endl
				<< endl
				<< "void main() {" << endl
				<< "   uv = gl_MultiTexCoord0.xy;" << endl
				<< "   camVec = camPos - gl_Vertex.xyz;" << endl
				<< "   lightVec = vplPos - gl_Vertex.xyz;" << endl
				<< "   gl_Position = ftransform();" << endl
				<< "   vertexColor = gl_Color.rgb;" << endl
				<< "   normal = gl_Normal;" << endl;
		} else {
			oss << "varying vec3 lightVec_vertex, camVec_vertex;" << endl
				<< "varying vec2 uv_vertex;" << endl
				<< "varying vec3 vertexColor_vertex;" << endl
				<< endl
				<< "void main() {" << endl
				<< "   uv_vertex = gl_MultiTexCoord0.xy;" << endl
				<< "   camVec_vertex = camPos - gl_Vertex.xyz;" << endl
				<< "   lightVec_vertex = vplPos - gl_Vertex.xyz;" << endl
				<< "   gl_Position = ftransform();" << endl
				<< "   vertexColor_vertex = gl_Color.rgb;" << endl;
		}
		if (anisotropic)
			oss << "   tangent = gl_MultiTexCoord1.xyz;" << endl;
		oss << "}" << endl;

		program->setSource(GPUProgram::EVertexProgram, oss.str());
		oss.str("");

		oss << "#version 120" << endl
			<< endl
			<< "/* Uniform inputs */" << endl
			<< "uniform samplerCube shadowMap;" << endl
			<< "uniform vec3 vplPower, vplS, vplT, vplN, vplWi;" << endl
			<< "uniform float nearClip, invClipRange, minDist, alpha;" << endl
			<< "uniform vec2 vplUV;" << endl
			<< "uniform bool diffuseSources, diffuseReceivers;" << endl
			<< "varying vec3 vertexColor;" << endl
			<< endl
			<< "/* Inputs <- Vertex program */" << endl
			<< "varying vec3 normal, lightVec, camVec;" << endl
			<< "varying vec2 uv;" << endl;
		if (anisotropic)
			oss << "varying vec3 tangent;" << endl;

		oss << endl
			<< "/* Some helper functions for BSDF implementations */" << endl
			<< "float cosTheta(vec3 v) { return v.z; }" << endl
			<< "float sinTheta2(vec3 v) { return 1.0-v.z*v.z; }" << endl
			<< "float sinTheta(vec3 v) { float st2 = sinTheta2(v); if (st2 <= 0) return 0.0; else return sqrt(sinTheta2(v)); }" << endl
			<< "float tanTheta(vec3 v) { return sinTheta(v)/cosTheta(v); }" << endl
			<< "float sinPhi(vec3 v) { return v.y/sinTheta(v); }" << endl
			<< "float cosPhi(vec3 v) { return v.x/sinTheta(v); }" << endl
			<< "const float pi = 3.141592653589;" << endl
			<< "const float inv_pi = 0.318309886183791;" << endl
			<< endl;

		std::string vplEvalName, bsdfEvalName, lumEvalName;
		m_targetConfig.generateCode(oss, vplEvalName, bsdfEvalName, lumEvalName);

		oss << "void main() {" << endl
			<< "   /* Set up an ONB */" << endl
			<< "   vec3 N = normalize(normal);" << endl;
		if (anisotropic) {
			oss << "   vec3 S = normalize(tangent - dot(tangent, N)*N);" << endl;
		} else {
			oss << "   vec3 S;" << endl
				<< "   if (abs(N.x) > abs(N.y)) {" << endl
				<< "        float invLen = 1.0 / sqrt(N.x*N.x + N.z*N.z);" << endl
				<< "        S = vec3(-N.z * invLen, 0.0, N.x * invLen);" << endl
				<< "   } else {" << endl
				<< "        float invLen = 1.0 / sqrt(N.y*N.y + N.z*N.z);" << endl
				<< "        S = vec3(0.0, -N.z * invLen, N.y * invLen);" << endl
				<< "   }" << endl;
		}
		oss << "   vec3 T = cross(N, S);" << endl
			<< endl
			<< "   /* Compute shadows */" << endl
			<< "   float d = length(lightVec);" << endl
			<< "   vec3 nLightVec = lightVec/d, absLightVec = abs(lightVec);" << endl
			<< "   float depth = max(max(absLightVec.x, absLightVec.y), absLightVec.z);" << endl
			<< "   depth = (depth-nearClip) * invClipRange - 0.005;" << endl
			<< "   float shadow = textureCube(shadowMap, nLightVec).r > depth ? 1.0 : 0.0;" << endl
			<< endl
			<< "   /* Shading */" << endl
			<< "   vec3 nCamVec = normalize(camVec);" << endl
			<< "   vec3 wo = vec3(dot(S, nLightVec)," << endl
			<< "                  dot(T, nLightVec)," << endl
			<< "                  dot(N, nLightVec));" << endl
			<< "   vec3 wi = vec3(dot(S, nCamVec)," << endl
			<< "                  dot(T, nCamVec)," << endl
			<< "                  dot(N, nCamVec));" << endl
			<< "   vec3 vplWo = -vec3(dot(vplS, nLightVec)," << endl
			<< "                      dot(vplT, nLightVec)," << endl
			<< "                      dot(vplN, nLightVec));" << endl
			<< "   vec3 contrib = vplPower;" << endl
			<< "   if (!diffuseSources)" << endl 
			<< "      contrib *= " << vplEvalName;
			if (vpl.type == ESurfaceVPL)
				oss << "(vplUV, vplWi, vplWo);" << endl;
			else
				oss << "_dir(vplWo);" << endl;
			if (vpl.type == ESurfaceVPL)
				oss << "   else contrib *= max(0, cosTheta(vplWo));" << endl;
		oss << "   if (d < minDist) d = minDist;" << endl
			<< "   if (!diffuseReceivers)" << endl
			<< "      contrib *= "<< bsdfEvalName << "(uv, wi, wo);" << endl
			<< "   else" << endl
			<< "      contrib *= " << bsdfEvalName << "_diffuse(uv, wi, wo);" << endl
			<< "   gl_FragColor.rgb = contrib";
		if (vpl.type == ELuminaireVPL 
				&& (vpl.luminaire->getType() & Luminaire::EOnSurface))
			oss << " * (shadow * abs(cosTheta(vplWo)) / (d*d))";
		else 
			oss << " * (shadow / (d*d))";
		if (luminaire != NULL) {
			oss << endl;
			oss << "                      + " << lumEvalName << "_area(uv)"
				<< " * " << lumEvalName << "_dir(wi);" << endl;
		} else {
			oss << ";" << endl;
		}
		oss << "   gl_FragColor.a = alpha;" << endl
			<< "}" << endl;

		program->setSource(GPUProgram::EFragmentProgram, oss.str());
		try {
			program->init();
		} catch (const std::exception &) {
			Log(EWarn, "Unable to compile the following VPL program:\n%s", oss.str().c_str());
			throw;
		}

		m_targetConfig.resolve(program);
		m_targetConfig.param_shadowMap = program->getParameterID("shadowMap", false);
		m_targetConfig.param_vplPos = program->getParameterID("vplPos", false);
		m_targetConfig.param_camPos = program->getParameterID("camPos", false);
		m_targetConfig.param_vplPower = program->getParameterID("vplPower", false);
		m_targetConfig.param_vplN = program->getParameterID("vplN", false);
		m_targetConfig.param_vplS = program->getParameterID("vplS", false);
		m_targetConfig.param_vplT = program->getParameterID("vplT", false);
		m_targetConfig.param_vplWi = program->getParameterID("vplWi", false);
		m_targetConfig.param_vplUV = program->getParameterID("vplUV", false);
		m_targetConfig.param_nearClip = program->getParameterID("nearClip", false);
		m_targetConfig.param_invClipRange = program->getParameterID("invClipRange", false);
		m_targetConfig.param_minDist = program->getParameterID("minDist", false);
		m_targetConfig.param_diffuseSources = program->getParameterID("diffuseSources", false);
		m_targetConfig.param_diffuseReceivers = program->getParameterID("diffuseReceivers", false);
		m_targetConfig.param_alpha = program->getParameterID("alpha", false);
		m_current.program = program;
		m_current.config = m_targetConfig;
		m_programs[configName] = m_current;
		program->incRef();
	}

	program->bind();
	m_shadowMap->bind(0);

	const VPLProgramConfiguration &config = m_current.config;

	program->setParameter(config.param_shadowMap, m_shadowMap);
	program->setParameter(config.param_vplPos, vpl.its.p);
	program->setParameter(config.param_camPos, camPos);
	program->setParameter(config.param_vplN, vpl.its.shFrame.n);
	program->setParameter(config.param_vplS, vpl.its.shFrame.s);
	program->setParameter(config.param_vplT, vpl.its.shFrame.t);
	
	program->setParameter(config.param_alpha, 
		bsdfShader->getFlags() & Shader::ETransparent ? 0.5f : 1.0f);

	if (vpl.type == ESurfaceVPL) {
		program->setParameter(config.param_vplWi, vpl.its.wi);
		program->setParameter(config.param_vplUV, vpl.its.uv);
		program->setParameter(config.param_diffuseSources, m_diffuseSources);
	}

	Spectrum power = vpl.P;
	if (m_diffuseSources && vpl.type == ESurfaceVPL)
		power *= vpl.its.shape->getBSDF()->getDiffuseReflectance(vpl.its) * INV_PI;
	program->setParameter(config.param_vplPower, power);
	program->setParameter(config.param_diffuseReceivers, m_diffuseReceivers);
	program->setParameter(config.param_nearClip, m_nearClip);
	program->setParameter(config.param_invClipRange, m_invClipRange);
	program->setParameter(config.param_minDist, m_minDist);

	int textureUnitOffset = 1;
	m_targetConfig.bind(program, config, textureUnitOffset);
}