Exemplos de get_geometric_normal em C++ (Cpp)

Exemplo n.º 1

Arquivo: shadingpoint.cpp Projeto: hipopotamo-hipotalamo/appleseed

Vector3d ShadingPoint::get_biased_point(const Vector3d& direction) const
{
    assert(hit());

    if (!(m_members & HasBiasedPoint))
    {
        const Vector3d point = m_ray.point_at(m_ray.m_tmax);

        switch (m_object_instance->get_ray_bias_method())
        {
          case ObjectInstance::RayBiasMethodNone:
            {
                m_biased_point = point;
                m_members |= HasBiasedPoint;
                return m_biased_point;
            }

          case ObjectInstance::RayBiasMethodNormal:
            {
                const Vector3d& n = get_geometric_normal();
                const double bias = m_object_instance->get_ray_bias_distance();
                return dot(direction, n) > 0.0 ? point + bias * n : point - bias * n;
            }

          case ObjectInstance::RayBiasMethodIncomingDirection:
            {
                const double bias = m_object_instance->get_ray_bias_distance();
                m_biased_point = point + bias * normalize(m_ray.m_dir);
                m_members |= HasBiasedPoint;
                return m_biased_point;
            }

          case ObjectInstance::RayBiasMethodOutgoingDirection:
            {
                const double bias = m_object_instance->get_ray_bias_distance();
                return point + bias * normalize(direction);
            }

          assert_otherwise;
        }
    }

    return m_biased_point;
}

Exemplo n.º 2

OSL::ShaderGlobals& ShadingPoint::get_osl_shader_globals() const
{
    assert(hit());

    if (!(m_members & HasOSLShaderGlobals))
    {
        const ShadingRay& ray(get_ray());

        m_shader_globals.P = Vector3f(get_point());
        m_shader_globals.dPdx = OSL::Vec3(0, 0, 0);
        m_shader_globals.dPdy = OSL::Vec3(0, 0, 0);
        m_shader_globals.dPdz = OSL::Vec3(0, 0, 0);

        m_shader_globals.I = Vector3f(normalize(ray.m_dir));
        m_shader_globals.dIdx = OSL::Vec3(0, 0, 0);
        m_shader_globals.dIdy = OSL::Vec3(0, 0, 0);

        m_shader_globals.N = Vector3f(get_shading_normal());
        m_shader_globals.Ng = Vector3f(get_geometric_normal());

        m_shader_globals.u = get_uv(0).x;
        m_shader_globals.dudx = 0;
        m_shader_globals.dudy = 0;

        m_shader_globals.v = get_uv(0).y;
        m_shader_globals.dvdx = 0;
        m_shader_globals.dvdy = 0;

        m_shader_globals.dPdu = Vector3f(get_dpdu(0));
        m_shader_globals.dPdv = Vector3f(get_dpdv(0));

        m_shader_globals.time = ray.m_time;
        m_shader_globals.dtime = 0;
        m_shader_globals.dPdtime = OSL::Vec3(0, 0, 0);
        
        m_shader_globals.Ps = OSL::Vec3(0, 0, 0);
        m_shader_globals.dPsdx = OSL::Vec3(0, 0, 0);
        m_shader_globals.dPsdy = OSL::Vec3(0, 0, 0);
        
        m_shader_globals.renderstate = 0;
        m_shader_globals.tracedata = 0;
        m_shader_globals.objdata = 0;

        m_obj_transform_info.m_assembly_instance_transform = 
            &get_assembly_instance().cumulated_transform_sequence();
        m_obj_transform_info.m_object_instance_transform = 
            &get_object_instance().get_transform();

        m_shader_globals.object2common = reinterpret_cast<OSL::TransformationPtr>(&m_obj_transform_info);

        m_shader_globals.shader2common = 0;
        m_shader_globals.surfacearea = 0;

        m_shader_globals.raytype = static_cast<int>(ray.m_type);

        m_shader_globals.flipHandedness = 0;
        m_shader_globals.backfacing = get_side() == ObjectInstance::FrontSide ? 0 : 1;

        m_shader_globals.context = 0;
        m_shader_globals.Ci = 0;
        
        m_members |= HasOSLShaderGlobals;
    }
    else
    {
        // Update always the raytype, as it might have changed from the previous run.
        m_shader_globals.raytype = static_cast<int>(get_ray().m_type);
    }

    return m_shader_globals;
}