Пример #1
0
IqmTypeMap getShader(XMLElement*elShade, ShaderPtr& sPtr, uint32_t nMat, uint32_t nLights){
	// this will store all vertex attributes
	IqmTypeMap ret;

	// Check to see if all variables described in XML are present
	string v(check("Vertex", elShade)->Attribute("src"));
	string f(check("Fragment", elShade)->Attribute("src"));

	ifstream vIn("../Resources/Shaders/" + v), fIn("../Resources/Shaders/" + f);
	string vSrc((istreambuf_iterator<char>(vIn)), istreambuf_iterator<char>());
	string fSrc((istreambuf_iterator<char>(fIn)), istreambuf_iterator<char>());

	// Set the light and geom (material) count in the shaders
	auto setNum = [nMat, nLights](string& shdrSrc){
		auto pos = shdrSrc.find("\n");
		shdrSrc.insert(pos + 1, "#define NUM_MATS " + std::to_string(nMat) + "\n");
		shdrSrc.insert(pos + 1, "#define NUM_LIGHTS " + std::to_string(nLights) + "\n");
	};
	setNum(vSrc);
	setNum(fSrc);

	sPtr = Shader::FromSource(vSrc, fSrc);

	auto sBind = sPtr->Bind();

	// Declared vertex attributes
	XMLElement * attrs = check("Attributes", elShade);

	// Make sure those variables exist in the shader
	for (auto el = attrs->FirstChildElement(); el; el = el->NextSiblingElement()){
		string type(el->Value());
		string var(el->GetText());
		GLint handle = sPtr->getHandle(var); // Should I have the shader ensure it's an attribute?
		// A negative handle means the query was unsuccessful
		if (handle < 0){
			cout << "Invalid variable queried in shader " << var << endl;
			continue; //exit(6);
		}
		// Populate returned map
		if (type.compare("Position") == 0)
			ret[IqmFile::IQM_T::POSITION] = handle;
		else if (type.compare("TexCoord") == 0)
			ret[IqmFile::IQM_T::TEXCOORD] = handle;
		else if (type.compare("Normal") == 0)
			ret[IqmFile::IQM_T::NORMAL] = handle;
		else if (type.compare("Tangent") == 0)
			ret[IqmFile::IQM_T::TANGENT] = handle;
	}

	return ret;
}
Пример #2
0
void setupMiscUniforms(const ShaderPtr& sPtr){
	// Uniform Handles (really shouldn't be hard coded like this)
	Camera::SetProjHandle(sPtr->getHandle("PV")); // Projection Matrix
	Camera::SetPosHandle(sPtr->getHandle("u_wCameraPos")); // World Space cam pos
	//Camera::SetCHandle(shader["C"]); // Camera Matrix

	Geometry::setMHandle(sPtr->getHandle("M")); // World transform Matrix
	Geometry::setNHandle(sPtr->getHandle("N")); // Normal Matrix
	Geometry::setMatIdxHandle(sPtr->getHandle("mIdx"));

	// If these end up negative, so be it
	Material::SetTexMapHandle(sPtr->getHandle("u_TextureMap")); // Texture Map Sampler
	Material::SetNrmMapHandle(sPtr->getHandle("u_NormalMap")); // Normal Map Sample;

	// This causes GL_TEXTUREi to be associated with an int
	// Make a manager for this inside Textures namespace
	glUniform1i(sPtr->getHandle("u_TextureMap"), COLOR_TEX_UNIT);
	glUniform1i(sPtr->getHandle("u_NormalMap"), NORMAL_TEX_UNIT);
	glUniform1i(sPtr->getHandle("u_EnvMap"), CUBE_TEX_UNIT);
}
Пример #3
0
Scene::Scene(string XmlSrc, ShaderPtr& sPtr, Camera& cam){
	XMLDocument doc;
	doc.LoadFile(XmlSrc.c_str());

	// Get the root (Scene) element
	XMLElement * elScene = doc.FirstChildElement("Scene");
	if (!elScene){
		cout << "XML Root not found. " << endl;
		exit(5);
	}
	// Get and verify that important things are there
	XMLElement * elCam = check("Camera", elScene);
	XMLElement * elShade = check("Shader", elScene);
	XMLElement * elGeom = check("Geom", elScene);
	XMLElement * elLight = check("Light", elScene);

	// First create host assets
	// Init Camera
	Camera::Type camType = getCamera(*elCam, cam);
	if (camType == Camera::Type::NIL){
		cout << "Error creating Camera" << endl;
		exit(7);
	}

	// Init Geometry
	for (XMLElement * el = elGeom->FirstChildElement(); el; el = el->NextSiblingElement())
		m_vGeometry.push_back(getGeom(el));

	// Set up the lights, arbitrarily assigning pre-existing geometry as its representation
	for (auto el = elLight->FirstChildElement(); el; el = el->NextSiblingElement())
		m_vLights.push_back(getLight(el));
	
	// Init shader
	// The material count == #geom + # of point lights
	int nMaterials = m_vGeometry.size() + std::count_if(
		m_vLights.begin(), m_vLights.end(), [](const Light& l){
		return l.getType() == Light::Type::POINT;
	});
	IqmTypeMap iqmTypes = getShader(elShade, sPtr, nMaterials, m_vLights.size());

	// Sort so overlapping geometry is adjacent
	std::sort(m_vGeometry.begin(), m_vGeometry.end());

	// Create all GPU assets, starting by binding the shader
	auto sBind = sPtr->ScopeBind();

	// Create Geometry
	for (auto it = m_vGeometry.begin(); it != m_vGeometry.end();){
		// For the first instance, create the assets
		createGPUAssets(iqmTypes, *it);
		// For all remaining instances, just copy VAO and nIdx
		int count = std::count(m_vGeometry.begin(), m_vGeometry.end(), *it);
		auto cloneIt = it;
		for (int i = 1; i < count; i++){
			(it + i)->setNumIndices(it->getNumIdx());
			(it + i)->setVAO(it->getVAO());
		}
		it += count;
	}

	// Set up material shader access
	Shader * s = sPtr.get();
	auto fixMaterial = [s](Geometry& G, int i){
		string m = "MatArr[i].";
		m[m.length() - 3] = '0' + i;

		Material M = G.getMaterial();

		// Material handles aren't static
		M.SetReflectHandle(s->getHandle(m + "Reflectivity"));
		M.setShinyHandle(s->getHandle(m + "Shininess"));
		M.setDiffHandle(s->getHandle(m + "Diffuse"));
		M.setSpecHandle(s->getHandle(m + "Specular"));
		createGPUAssets(M);

		G.setMaterial(M);
	};

	// Upload all geometry materials
	for (int i = 0; i < m_vGeometry.size(); i++)
		fixMaterial(m_vGeometry[i], i);

	// Create lights
	for (int i = 0; i < m_vLights.size(); i++){
		// Upload to shader (Must be accessed like "TheLights[i].Type, GL3)
		string s = "LightArr[i].";
		s[s.length() - 3] = '0' + i;

		// Store handles per light, since they could move
		m_vLights[i].SetTypeHandle(sPtr->getHandle(s + "Type"));
		m_vLights[i].SetPosOrHalfHandle(sPtr->getHandle(s + "PosOrHalf"));
		m_vLights[i].SetDirOrAttenHandle(sPtr->getHandle(s + "DirOrAtten"));
		m_vLights[i].SetIntensityHandle(sPtr->getHandle(s + "Intensity"));

		// Put light data on GPU
		createGPUAssets(m_vLights[i]);

		// Give point lights some geometry
		if (m_vLights[i].getType() == Light::Type::POINT){
			Geometry lightGeom = m_vGeometry[0];
			lightGeom.identity(); // Maybe scale it somehow?
			mat4 light_T = glm::translate(m_vLights[i].getPos());
			lightGeom.leftMultM(light_T);

			Material lightMat(10.f, 0.f, vec4(glm::linearRand(vec3(0), vec3(1)), 0.5f), vec4(1));

			lightGeom.setMaterial(lightMat);
			fixMaterial(lightGeom, i + m_vGeometry.size() );
			m_vLights[i].SetGeometry(lightGeom);
		}

		//// Set up point light materials
		//if (m_vLights[i].getType() == Light::Type::POINT){
		//	Geometry g = m_vLights[i].GetGeometry(); // I wish we didn't have to go back and forth like this
		//	fixMaterial(g, i + m_vGeometry.size() - 1);  // but returning a reference seems like overkill
		//	m_vLights[i].SetGeometry(g);
		//}
	}

	setupMiscUniforms(sPtr);

	Scene::s_EnvMapHandle = sPtr->getHandle("u_EnvMap");

	//// Find a better place for this, do XML
	std::string cubeFaces[6] = { "posX.png", "negX.png", "posY.png", "negY.png", "posZ.png", "negZ.png" };
	m_EnvMap = Textures::CubeMap(cubeFaces);
}