예제 #1
0
void CloudLayer::renderObject( ObjectRenderInst *ri, SceneRenderState *state, BaseMatInstance *mi )
{
   GFXTransformSaver saver;

   const Point3F &camPos = state->getCameraPosition();
   MatrixF xfm(true);
   xfm.setPosition(camPos);
   GFX->multWorld(xfm);   

   if ( state->isReflectPass() )
      GFX->setProjectionMatrix( state->getSceneManager()->getNonClipProjection() );

   GFX->setShader( mShader );
   GFX->setShaderConstBuffer( mShaderConsts );
   GFX->setStateBlock( mStateblock );

   // Set all the shader consts...

   MatrixF xform(GFX->getProjectionMatrix());
   xform *= GFX->getViewMatrix();
   xform *= GFX->getWorldMatrix();

   mShaderConsts->setSafe( mModelViewProjSC, xform );

   mShaderConsts->setSafe( mEyePosWorldSC, camPos );

   LightInfo *lightinfo = LIGHTMGR->getSpecialLight(LightManager::slSunLightType);
   const ColorF &sunlight = state->getAmbientLightColor();

   Point3F ambientColor( sunlight.red, sunlight.green, sunlight.blue );
   mShaderConsts->setSafe( mAmbientColorSC, ambientColor );   

   const ColorF &sunColor = lightinfo->getColor();
   Point3F data( sunColor.red, sunColor.green, sunColor.blue );
   mShaderConsts->setSafe( mSunColorSC, data );

   mShaderConsts->setSafe( mSunVecSC, lightinfo->getDirection() );

   for ( U32 i = 0; i < TEX_COUNT; i++ )         
      mShaderConsts->setSafe( mTexOffsetSC[i], mTexOffset[i] );

   Point3F scale( mTexScale[0], mTexScale[1], mTexScale[2] );
   mShaderConsts->setSafe( mTexScaleSC, scale );

   Point3F color;
   color.set( mBaseColor.red, mBaseColor.green, mBaseColor.blue );
   mShaderConsts->setSafe( mBaseColorSC, color );

   mShaderConsts->setSafe( mCoverageSC, mCoverage );

   mShaderConsts->setSafe( mExposureSC, mExposure );

   GFX->setTexture( mNormalHeightMapSC->getSamplerRegister(), mTexture );                            
   GFX->setVertexBuffer( mVB );            
   GFX->setPrimitiveBuffer( mPB );

   GFX->drawIndexedPrimitive( GFXTriangleList, 0, 0, smVertCount, 0, smTriangleCount );
}
예제 #2
0
color3 Ray::PhongColor(Light light, Material material, Fragment fragment) const
{
	vec3 ambient = ambientColor(light, material);
	vec3 diffuse = diffuseColor(light, material, fragment);
	vec3 specular = specularColor(light, material, fragment);

	vec3 color = clamp(ambient + diffuse + specular, 0.0, 1.0);
	return color;
}
예제 #3
0
Color<real> BlinnPhongShader<real>::GetAmbient( const Light<real>& light )
{
    Color<real> ambientColor( 0, 0, 0, 1 );

    ////////////////////////////////////////////
    //////////////////IFT 3355//////////////////
    ////////////////////////////////////////////
    //Ici, vous calculerez la composante
    //ambiante.
    ////////////////////////////////////////////
    //////////////////IFT 3355//////////////////
    ////////////////////////////////////////////

    ambientColor += light.GetAmbient() *
        GetMaterialSurfaceColor() *
      mMaterial.GetAmbient() *
      GetAmbientOcclusion(mRayTracer.GetNbAmbientOcclusionSamples(),
			  mRayTracer.GetAmbientOcclusionRadius());
    return ambientColor;
}
예제 #4
0
void SpotLight::apply()
{
	const math::Matrix4x4&	wt		= cachedWorldTransform();
	math::Vector3			wrotz	= math::Vector3( wt(0,2),wt(1,2),wt(2,2) );

	float wrotzlen = wrotz.length();
	if ( wrotzlen > Float::MIN_VALUE )
	{
		wrotz *= 1.f / wrotzlen;
		float intens = intensity();

		gd::LightState ls;
		GdUtil::setLightState( ls,
			gd::LightState::LIGHT_SPOT,
			diffuseColor()*intens, specularColor()*intens, ambientColor()*intens,
			wt.translation(), wrotz,
			m_range, m_atten[0], m_atten[1], m_atten[2],
			1.f, m_inner, m_outer );

		gd::GraphicsDevice*	dev = Context::device();
		dev->addLight( ls );
	}
}
예제 #5
0
void DirectLight::apply()
{
	const Matrix4x4&	wt		= cachedWorldTransform();
	Vector3				wrotz	= Vector3( wt(0,2),wt(1,2),wt(2,2) );

	float wrotzlen = wrotz.length();
	if ( wrotzlen > Float::MIN_VALUE )
	{
		wrotz *= 1.f / wrotzlen;
		float intens = intensity();

		gd::LightState ls;
		GdUtil::setLightState( ls,
			gd::LightState::LIGHT_DIRECT,
			diffuseColor()*intens, specularColor()*intens, ambientColor()*intens,
			wt.translation(), wrotz.normalize(),
			MAX_RANGE, 1.f, 0.f, 0.f,
			1.f, MAX_CONE_ANGLE, MAX_CONE_ANGLE );

		gd::GraphicsDevice*	dev = Context::device();
		dev->addLight( ls );
	}
}
예제 #6
0
void Lighting2D::init(glm::vec2 _screenSize, GE::Camera2D* _mainCamera){
	screenSize = _screenSize;
	mainCamera = _mainCamera;

	camera.init(glm::ivec2(screenSize));
	camera.setPosition(glm::vec2(0));
	camera.setScale(camera.getScale());
	camera.update();

	shader.compileShaders("shaders/lighting2D.vert", "shaders/lighting2D.frag");
	shader.addAttribute("vertexPosition");
	shader.addAttribute("vertexColor");
	shader.linkShaders();


	ColorRGBA8 ambientColor(0, 0, 0, 255);

	vertexArray.init();
	vertexArray.addVertex(glm::vec2(-screenSize.x / 2, -screenSize.y / 2), ambientColor);
	vertexArray.addVertex(glm::vec2(screenSize.x / 2, -screenSize.y / 2), ambientColor);
	vertexArray.addVertex(glm::vec2(screenSize.x / 2, screenSize.y / 2), ambientColor);
	vertexArray.addVertex(glm::vec2(-screenSize.x / 2, -screenSize.y / 2), ambientColor);
	vertexArray.addVertex(glm::vec2(screenSize.x / 2, screenSize.y / 2), ambientColor);
	vertexArray.addVertex(glm::vec2(-screenSize.x / 2, screenSize.y / 2), ambientColor);
	

	shadows.init();


	glGenBuffers(1, &lUBO);
	glBindBuffer(GL_UNIFORM_BUFFER, lUBO);
	glBufferData(GL_UNIFORM_BUFFER, TMPNL * sizeof(Light2D), nullptr, GL_DYNAMIC_DRAW);
	glBindBuffer(GL_UNIFORM_BUFFER, 0);

	GLuint lIx = glGetUniformBlockIndex(shader.getProgramID(), "lightBlock");
	glUniformBlockBinding(shader.getProgramID(), lIx, 2);
	glBindBufferBase(GL_UNIFORM_BUFFER, 2, lUBO);


	glGenBuffers(1, &ecUBO);
	glBindBuffer(GL_UNIFORM_BUFFER, ecUBO);
	glBufferData(GL_UNIFORM_BUFFER, TMPNL * TMPNS * sizeof(ExCor), nullptr, GL_DYNAMIC_DRAW);
	glBindBuffer(GL_UNIFORM_BUFFER, 0);

	GLuint exIx = glGetUniformBlockIndex(shader.getProgramID(), "shadowClippingBlock");
	glUniformBlockBinding(shader.getProgramID(), exIx, 3);
	glBindBufferBase(GL_UNIFORM_BUFFER, 3, ecUBO);


	glGenBuffers(1, &sdUBO);
	glBindBuffer(GL_UNIFORM_BUFFER, sdUBO);
	glBufferData(GL_UNIFORM_BUFFER, TMPNS * sizeof(ShadowData), nullptr, GL_DYNAMIC_DRAW);
	glBindBuffer(GL_UNIFORM_BUFFER, 0);

	GLuint sdIx = glGetUniformBlockIndex(shader.getProgramID(), "shadowDataBlock");
	glUniformBlockBinding(shader.getProgramID(), sdIx, 4);
	glBindBufferBase(GL_UNIFORM_BUFFER, 4, sdUBO);



	float size = TMPNL * sizeof(Light2D)+TMPNL * TMPNS * sizeof(ExCor)+TMPNS * sizeof(ShadowData);
	std::cout << size << std::endl;
}
예제 #7
0
MaterialData ModelLoader::loadMaterial(unsigned int index, const aiMaterial* material)
{
    Q_ASSERT(material != nullptr);

    MaterialData data = MaterialData();
    data.name = "material_" + to_string(index);

    aiColor3D ambientColor(0.1f, 0.1f, 0.1f);
    aiColor3D diffuseColor(0.8f, 0.8f, 0.8f);
    aiColor3D specularColor(0.0f, 0.0f, 0.0f);
    aiColor3D emissiveColor(0.0f, 0.0f, 0.0f);

    int blendMode;
    int twoSided = 1;

    float opacity = 1.0f;
    float shininess = 0.0f;
    float shininessStrength = 1.0f;

    if(material->Get(AI_MATKEY_COLOR_AMBIENT, ambientColor) == AI_SUCCESS)
    {
        data.ambientColor.setX(ambientColor.r);
        data.ambientColor.setY(ambientColor.g);
        data.ambientColor.setZ(ambientColor.b);
    }

    if(material->Get(AI_MATKEY_COLOR_DIFFUSE, diffuseColor) == AI_SUCCESS)
    {
        data.diffuseColor.setX(diffuseColor.r);
        data.diffuseColor.setY(diffuseColor.g);
        data.diffuseColor.setZ(diffuseColor.b);
    }

    if(material->Get(AI_MATKEY_COLOR_SPECULAR, specularColor) == AI_SUCCESS)
    {
        data.specularColor.setX(specularColor.r);
        data.specularColor.setY(specularColor.g);
        data.specularColor.setZ(specularColor.b);
    }

    if(material->Get(AI_MATKEY_COLOR_EMISSIVE, emissiveColor) == AI_SUCCESS)
    {
        data.emissiveColor.setX(emissiveColor.r);
        data.emissiveColor.setY(emissiveColor.g);
        data.emissiveColor.setZ(emissiveColor.b);
    }

    if(material->Get(AI_MATKEY_TWOSIDED, twoSided) == AI_SUCCESS)
    {
        data.twoSided = twoSided;
    }

    if(material->Get(AI_MATKEY_OPACITY, opacity) == AI_SUCCESS)
    {
        data.ambientColor.setW(opacity);
        data.diffuseColor.setW(opacity);
        data.specularColor.setW(opacity);
        data.emissiveColor.setW(opacity);

        if(opacity < 1.0f)
        {
            data.alphaBlending = true;

            // Activate backface culling allows to avoid
            // cull artifacts when alpha blending is activated
            data.twoSided = 1;

            if(material->Get(AI_MATKEY_BLEND_FUNC, blendMode) == AI_SUCCESS)
            {
                if(blendMode == aiBlendMode_Additive)
                    data.blendMode = aiBlendMode_Additive;
                else
                    data.blendMode = aiBlendMode_Default;
            }
        }
        else
        {
            data.alphaBlending = false;
            data.blendMode = -1;
        }
    }

    if(material->Get(AI_MATKEY_SHININESS, shininess) == AI_SUCCESS)
    {
        data.shininess = shininess;
    }

    if(material->Get(AI_MATKEY_SHININESS_STRENGTH, shininessStrength) == AI_SUCCESS)
    {
        data.shininessStrength = shininessStrength;
    }

    return data;
}
예제 #8
0
MStatus anisotropicShaderNode::compute( const MPlug& plug, MDataBlock& block )
{
    if ((plug == aOutColor) || (plug.parent() == aOutColor))
	{
        MFloatVector resultColor(0.0,0.0,0.0);
        MFloatVector diffuseColor( 0.0,0.0,0.0 );
        MFloatVector specularColor( 0.0,0.0,0.0 );
        MFloatVector ambientColor( 0.0,0.0,0.0 );

        // get matrix
        MFloatMatrix& matrixOToW = block.inputValue( aMatrixOToW ).asFloatMatrix();
        MFloatMatrix& matrixWToC = block.inputValue( aMatrixWToC ).asFloatMatrix();

        // spin scratch around this vector (in object space )
        MFloatVector& A = block.inputValue( aAxesVector ).asFloatVector();
        A.normalize();

        // spin scratch around this vector (in world space )
        MFloatVector wa = A * matrixOToW;
        wa.normalize();

        // spin scratch around this vector (in camera space )
        MFloatVector ca = wa * matrixWToC;
        ca.normalize();

        MFloatVector& surfacePoint = block.inputValue( aPointCamera ).asFloatVector();

        // get sample surface shading parameters
        MFloatVector& N = block.inputValue( aNormalCamera ).asFloatVector();
        MFloatVector& surfaceColor = block.inputValue( aColor ).asFloatVector();

        float diffuseReflectivity = block.inputValue( aDiffuseReflectivity ).asFloat();
        float specularCoeff = block.inputValue( aSpecularCoeff ).asFloat();

        // get light list
        MArrayDataHandle lightData = block.inputArrayValue( aLightData );
        int numLights = lightData.elementCount();

        // iterate through light list and get ambient/diffuse values
        for( int count=0; count < numLights; count++ ) {
            MDataHandle currentLight = lightData.inputValue();

            MFloatVector& lightIntensity = 
                currentLight.child( aLightIntensity ).asFloatVector();
            MFloatVector& lightDirection = 
                currentLight.child( aLightDirection ).asFloatVector();

            // find ambient component
            if( currentLight.child(aLightAmbient).asBool()) {
                ambientColor[0] += lightIntensity[0] * surfaceColor[0];
                ambientColor[1] += lightIntensity[1] * surfaceColor[1];
                ambientColor[2] += lightIntensity[2] * surfaceColor[2];
            }

            float cosln = lightDirection * N;
            if( cosln > 0.0f ){ // illuminated!

                // find diffuse component
                if( currentLight.child(aLightDiffuse).asBool()) {
                
                    float cosDif = cosln * diffuseReflectivity;
                    diffuseColor[0] += lightIntensity[0] * cosDif * surfaceColor[0];
                    diffuseColor[1] += lightIntensity[1] * cosDif * surfaceColor[1];
                    diffuseColor[2] += lightIntensity[2] * cosDif * surfaceColor[2];
                }

                // find specular component
                if( currentLight.child( aLightSpecular).asBool()){

                    MFloatVector& rayDirection = block.inputValue( aRayDirection ).asFloatVector();
                    MFloatVector viewDirection = -rayDirection;
                    MFloatVector half = calcHalfVector( viewDirection, lightDirection );


                    // Beckmann function

                    MFloatVector nA;
                    if( fabs(1.0-fabs(N*ca)) <= 0.0001f ){
                        MFloatPoint oo( 0.0,0.0,0.0 );
                        MFloatPoint ow = oo * matrixOToW;
                        MFloatPoint oc = ow * matrixWToC;
                        MFloatVector origin( oc[0], oc[1], oc[2] );
                        nA = origin - surfacePoint;
                        nA.normalize();
                    }else{
                        nA = ca;
                    }

                    MFloatVector x = N ^ nA;
                    x.normalize();
                    MFloatVector y = N ^ x;
                    y.normalize();

                    MFloatVector azimuthH = N ^ half;
                    azimuthH = N ^ azimuthH;
                    azimuthH.normalize();

                    float cos_phai = x * azimuthH;
                    float sin_phai = 0.0;
                    if( fabs(1 - cos_phai*cos_phai) < 0.0001 ){
                        sin_phai = 0.0;
                    }else{
                        sin_phai = sqrtf( 1.0f - cos_phai*cos_phai );
                    }
                    double co = pow( (half * N), 4.0f );
                    double t = tan( acos(half*N) );
                    t *= -t;

                    float rough1 = block.inputValue( aRoughness1 ).asFloat();
                    float rough2 = block.inputValue( aRoughness2 ).asFloat();

                    double aaa = cos_phai / rough1;
                    double bbb = sin_phai / rough2;

                    t = t * ( aaa*aaa + bbb*bbb );

                    double D = pow( (1.0/((double)rough1*(double)rough2 * co)), t );

                    double aa = (2.0 * (N*half) * (N*viewDirection) ) / (viewDirection*half);
                    double bb = (2.0 * (N*half) * (N*lightDirection) ) / (viewDirection*half);
                    double cc = 1.0;
                    double G = 0.0;
                    G = MIN( aa, bb );
                    G = MIN( G, cc );

                    float s = (float) (D * G /
                            (double)((N*lightDirection) * (N*viewDirection)));
                    MFloatVector& specColor = block.inputValue( aSpecColor ).asFloatVector();
                    specularColor[0] += lightIntensity[0] * specColor[0] * 
                                            s * specularCoeff;
                    specularColor[1] += lightIntensity[1] * specColor[1] * 
                                            s * specularCoeff;
                    specularColor[2] += lightIntensity[2] * specColor[2] * 
                                            s * specularCoeff;
                }
            }

            if( !lightData.next() ){
                break;
            }
        }

        // result = specular + diffuse + ambient;
        resultColor = diffuseColor + specularColor + ambientColor;

        MFloatVector& transparency = block.inputValue( aInTransparency ).asFloatVector();
        resultColor[0] *= ( 1.0f - transparency[0] );
        resultColor[1] *= ( 1.0f - transparency[1] );
        resultColor[2] *= ( 1.0f - transparency[2] );

        // set ouput color attribute
        MDataHandle outColorHandle = block.outputValue( aOutColor );
        MFloatVector& outColor = outColorHandle.asFloatVector();
        outColor = resultColor;
        outColorHandle.setClean();
        block.setClean( plug );
    }
	else if ((plug == aOutTransparency) || (plug.parent() == aOutTransparency))
	{
        MFloatVector& tr = block.inputValue( aInTransparency ).asFloatVector();

        // set ouput color attribute
        MDataHandle outTransHandle = block.outputValue( aOutTransparency );
        MFloatVector& outTrans = outTransHandle.asFloatVector();
        outTrans = tr;
        block.setClean( plug );
    } else
		return MS::kUnknownParameter;

    return MS::kSuccess;
}
예제 #9
0
// Execute OpenGL Material
void GLC_Material::glExecute(float overwriteTransparency)
{
	GLfloat pAmbientColor[4]= {ambientColor().redF(),
								ambientColor().greenF(),
								ambientColor().blueF(),
								overwriteTransparency};

	GLfloat pDiffuseColor[4]= {diffuseColor().redF(),
								diffuseColor().greenF(),
								diffuseColor().blueF(),
								overwriteTransparency};

	GLfloat pSpecularColor[4]= {specularColor().redF(),
								specularColor().greenF(),
								specularColor().blueF(),
								overwriteTransparency};

	GLfloat pLightEmission[4]= {emissiveColor().redF(),
								emissiveColor().greenF(),
								emissiveColor().blueF(),
								overwriteTransparency};

	const bool textureIsEnable= glIsEnabled(GL_TEXTURE_2D);

	if (m_pTexture != NULL)
	{
		if (!textureIsEnable) glEnable(GL_TEXTURE_2D);
		m_pTexture->glcBindTexture();
		if (GLC_State::glslUsed())
		{
			if (GLC_Shader::hasActiveShader())
			{
				GLC_Shader::currentShaderHandle()->programShaderHandle()->setUniformValue("tex", GLint(0));
				GLC_Shader::currentShaderHandle()->programShaderHandle()->setUniformValue("useTexture", true);
			}
		}
	}
	else
	{
		if (textureIsEnable) glDisable(GL_TEXTURE_2D);
		if (GLC_State::glslUsed())
		{
			if (GLC_Shader::hasActiveShader())
			{
				GLC_Shader::currentShaderHandle()->programShaderHandle()->setUniformValue("tex", GLint(0));
				GLC_Shader::currentShaderHandle()->programShaderHandle()->setUniformValue("useTexture", false);
			}
		}
	}

	glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, pAmbientColor);
	glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, pDiffuseColor);
	glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, pSpecularColor);
	glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, pLightEmission);
	glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, &m_Shininess);

	glColor4fv(pDiffuseColor);

	// OpenGL Error handler
	GLenum error= glGetError();
	if (error != GL_NO_ERROR)
	{
		GLC_OpenGlException OpenGlException("GLC_Material::glExecute(float overwriteTransparency) ", error);
		throw(OpenGlException);
	}
}
예제 #10
0
void Material::ExportMaterials(FbxScene* scene, FbxMesh* mesh, const ImporterMesh& importedMesh, const ImporterMaterial* importedMaterials)
{
	for (int i = 0; i < importedMesh.material_count; i++)
	{
		FbxNode* node = mesh->GetNode();
		FbxString materialName = importedMaterials[importedMesh.material_Id[i]].name;
		
		FbxString shadingName;

		FbxDouble3 diffuseColor(importedMaterials[importedMesh.material_Id[i]].diffuse[0], importedMaterials[importedMesh.material_Id[i]].diffuse[1], importedMaterials[importedMesh.material_Id[i]].diffuse[2]);
		FbxDouble3 ambientColor(importedMaterials[importedMesh.material_Id[i]].ambient[0], importedMaterials[importedMesh.material_Id[i]].ambient[1], importedMaterials[importedMesh.material_Id[i]].ambient[2]);
		FbxDouble3 emissiveColor(importedMaterials[importedMesh.material_Id[i]].incandescence[0], importedMaterials[importedMesh.material_Id[i]].incandescence[1], importedMaterials[importedMesh.material_Id[i]].incandescence[2]);
		FbxDouble3 transparencyColor(importedMaterials[importedMesh.material_Id[i]].transparency_color[0], importedMaterials[importedMesh.material_Id[i]].transparency_color[1], importedMaterials[importedMesh.material_Id[i]].transparency_color[2]);
		FbxDouble3 specularColor(importedMaterials[importedMesh.material_Id[i]].specular[0], importedMaterials[importedMesh.material_Id[i]].specular[1] , importedMaterials[importedMesh.material_Id[i]].specular[2]);
		
		const char* pathName = "C://Users/Litet/Documents/GitHub/SmallGameProject/FBX Export/FBX Export/";
		// Lambert
		if (importedMaterials[importedMesh.material_Id[i]].mtrl_type == 0)
		{
			shadingName = "Lambert";
			FbxSurfaceLambert* material = NULL;
			material= node->GetSrcObject<FbxSurfaceLambert>(0);
			material = FbxSurfaceLambert::Create(scene, materialName.Buffer());
			
			materialName += i;
			material->Emissive.Set(emissiveColor);

			material->Ambient.Set(ambientColor);

			material->Diffuse.Set(diffuseColor);
			material->DiffuseFactor.Set(importedMaterials[importedMesh.material_Id[i]].diffuse_factor);

			material->TransparentColor.Set(transparencyColor);

			FbxNode* node = mesh->GetNode();
			if (node)
			{
				node->AddMaterial(material);
			}

			// Diffuse Texture
			FbxFileTexture* texture = FbxFileTexture::Create(scene, "Diffuse Texture");
			std::cout << "DAFUSE MAP LENGTH: " << importedMaterials[importedMesh.material_Id[i]].duffuse_map_length << std::endl;
			if (importedMaterials[importedMesh.material_Id[i]].duffuse_map_length > 0)
			{
				std::string tmp(pathName);
				tmp += importedMaterials[importedMesh.material_Id[i]].diffuse_map;
				texture->SetFileName(tmp.c_str());
				texture->SetTextureUse(FbxTexture::eStandard);
				texture->SetMappingType(FbxTexture::eUV);
				texture->SetMaterialUse(FbxFileTexture::eModelMaterial);
				texture->SetSwapUV(false);
				texture->SetTranslation(0.0, 0.0);
				texture->SetScale(1.0, 1.0);
				texture->SetRotation(0.0, 0.0);

				if (material)
					material->Diffuse.ConnectSrcObject(texture);
			}

			// Normal Texture
			texture = FbxFileTexture::Create(scene, "Normal Texture");
			if (importedMaterials[importedMesh.material_Id[i]].normal_map_length > 0)
			{
				texture->SetFileName(importedMaterials[importedMesh.material_Id[i]].normal_map);
				texture->SetTextureUse(FbxTexture::eStandard);
				texture->SetMappingType(FbxTexture::eUV);
				texture->SetMaterialUse(FbxFileTexture::eModelMaterial);
				texture->SetSwapUV(false);
				texture->SetTranslation(0.0, 0.0);
				texture->SetScale(1.0, 1.0);
				texture->SetRotation(0.0, 0.0);

				if (material)
					material->NormalMap.ConnectSrcObject(texture);
			}

			

		}

		// Phong
		else
		{
			shadingName = "Phong";
			FbxSurfacePhong* material = NULL;
			material = node->GetSrcObject<FbxSurfacePhong>(0);
			
			material = FbxSurfacePhong::Create(scene, materialName.Buffer());
			materialName += i;
			material->Emissive.Set(emissiveColor);

			material->Ambient.Set(ambientColor);

			material->Diffuse.Set(diffuseColor);
			material->DiffuseFactor.Set(importedMaterials[importedMesh.material_Id[i]].diffuse_factor);

			material->TransparentColor.Set(transparencyColor);

			material->Specular.Set(specularColor);

			// No need... super boost?
			//material->SpecularFactor.Set(importedMaterials[importedMesh.material_Id[i]].specular_factor * 100);

			material->Shininess.Set(importedMaterials[importedMesh.material_Id[i]].specular_factor);
			
			material->Reflection.Set(FbxDouble3(importedMaterials[importedMesh.material_Id[i]].reflection[0], importedMaterials[importedMesh.material_Id[i]].reflection[1], importedMaterials[importedMesh.material_Id[i]].reflection[2]));
			
			// Bugged...?
			material->ReflectionFactor.Set(FbxDouble(importedMaterials[importedMesh.material_Id[i]].reflection_factor));
			cout << importedMaterials[importedMesh.material_Id[i]].shininess << endl;

			FbxNode* node = mesh->GetNode();
			if (node)
			{
				node->AddMaterial(material);
			}

			// Diffuse Texture
			FbxFileTexture* texture = FbxFileTexture::Create(scene, "Diffuse Texture");
			if (importedMaterials[importedMesh.material_Id[i]].duffuse_map_length > 0)
			{
				texture->SetFileName(importedMaterials[importedMesh.material_Id[i]].diffuse_map);
				texture->SetTextureUse(FbxTexture::eStandard);
				texture->SetMappingType(FbxTexture::eUV);
				texture->SetMaterialUse(FbxFileTexture::eModelMaterial);
				texture->SetSwapUV(false);
				texture->SetTranslation(0.0, 0.0);
				texture->SetScale(1.0, 1.0);
				texture->SetRotation(0.0, 0.0);

				if (material)
					material->Diffuse.ConnectSrcObject(texture);
			}

			// Specular Texture
			texture = FbxFileTexture::Create(scene, "Specular Texture");
			if (importedMaterials[importedMesh.material_Id[i]].specular_map_length > 0)
			{
				texture->SetFileName(importedMaterials[importedMesh.material_Id[i]].specular_map);
				texture->SetTextureUse(FbxTexture::eStandard);
				texture->SetMappingType(FbxTexture::eUV);
				texture->SetMaterialUse(FbxFileTexture::eModelMaterial);
				texture->SetSwapUV(false);
				texture->SetTranslation(0.0, 0.0);
				texture->SetScale(1.0, 1.0);
				texture->SetRotation(0.0, 0.0);

				if (material)
					material->Specular.ConnectSrcObject(texture);
			}

			// Normal Texture
			texture = FbxFileTexture::Create(scene, "Normal Texture");
			if (importedMaterials[importedMesh.material_Id[i]].normal_map_length > 0)
			{
				texture->SetFileName(importedMaterials[importedMesh.material_Id[i]].normal_map);
				texture->SetTextureUse(FbxTexture::eStandard);
				texture->SetMappingType(FbxTexture::eUV);
				texture->SetMaterialUse(FbxFileTexture::eModelMaterial);
				texture->SetSwapUV(false);
				texture->SetTranslation(0.0, 0.0);
				texture->SetScale(1.0, 1.0);
				texture->SetRotation(0.0, 0.0);

				if (material)
					material->NormalMap.ConnectSrcObject(texture);
			}


		}
	}

}
예제 #11
0
파일: main.cpp 프로젝트: rodrimc/RayTracing
Color trace (const Ray& ray, std::set<IShape*>& sceneShapes,
						 std::set<Light*>& sceneLights, int depth)
{
	Color pixelColor (0.3);

	float near;
	Color color;
	Vector3D normal;
	IShape *shape = calculateIntersect (ray, sceneShapes, &near, normal, color);
	if (shape)
	{
		pixelColor = color;
		Point intersectionPoint = ray.calculate (near);

		Vector3D n;
		Color c;

		pixelColor = Color (0.0f);

		//Calculate illumination on intersected pixel
		for (auto light : sceneLights)
		{
			Vector3D lightDirection = (light->position () - intersectionPoint);

			float lightLenght = lightDirection.normalize ();

			const Ray shadowRay (intersectionPoint + normal * bias, lightDirection,
													 lightLenght);
			float near = INFINITY;

			IShape *s = calculateIntersect (shadowRay, sceneShapes, &near, n, c);
			if (!s) //There is no object between the intersected pixel and this light.
			{
				float diffuseCoefficient = shape->diffuse ();
				float specularCoefficient = shape->specular ();

				pixelColor += ambientColor (color);
				if (diffuseCoefficient > 0.0f)
					pixelColor += diffuseColor (lightDirection, light, normal, color,
																			diffuseCoefficient);

				if (specularCoefficient > 0.0f)
					pixelColor += specularColor (lightDirection, normal, ray, light,
																			 specularCoefficient);
			}
			else //Intersected pixel is shadowed!!!
			{
				pixelColor = color * 0.1;
				break;
			}
		}

		//Calculate the reflected color
		if ((shape->reflection () > 0)
				&& depth <= MAX_DEPTH)
		{
			Vector3D reflDir = ray.direction ()
					- normal * 2 * ray.direction ().dot (normal);
			reflDir.normalize ();

			Ray reflectionRay (intersectionPoint + normal * bias, reflDir);
			Color reflectionColor = trace (reflectionRay, sceneShapes, sceneLights,
			                               depth + 1);

			pixelColor += reflectionColor * shape->reflection ();
		}

	}

	pixelColor.clamp ();
	return pixelColor;
}