コード例 #1
0
void PMirror::initialize()
{
    m_reflectionCamera = PNEW(PCamera("reflection", this));
    m_reflectionCamera->setFixed(true);

    // Framebuffer
    PResourceManager *resMgr = scene()->context()->module<PResourceManager>("resource-manager");
    
    const puint32 *rect = scene()->context()->rect();
    m_reflectionFB = resMgr->createFrameBuffer(P_NULL,
                                               rect[2],
                                               rect[3],
                                               P_GLTEXTURE_FORMAT_RGBA8888,
                                               P_GLTEXTURE_FORMAT_DEPTH_COMPONENT16);
    m_reflectionFB->retain();

    // Geometry and material
    setGeometry(PNEW(PGeometryPlane(resMgr)));
    setMaterial(PNEW(PMaterial("reflection.pmt", resMgr)));

    material()->parameter("texture")      = m_reflectionFB->colorBuffer();
    material()->parameter("inv-viewport") = pVector2(1.0f / (pfloat32)rect[2], 1.0f / (pfloat32)rect[3]);
    material()->parameter("color")        = pVector3(0.0f, 0.0f, 1.0f);
    material()->parameter("blend")        = 0.7f;

	// Render pass
    m_reflectionPass = PNEW(PRenderPass("reflection", scene())); 

}
コード例 #2
0
MyScene::MyScene(PContext *context)
    : PScene("my-scene", context)
{
    PRandom random(1001);

    const puint32 *rect = context->rect();

    for (puint32 i = 0; i < NUM_LOGOS; ++i)
    {
        m_velocities[i][0] = (random.getFloat32() - 0.5f) * (pfloat32)rect[2] * 0.001f; 
        m_velocities[i][1] = (random.getFloat32() - 0.5f) * (pfloat32)rect[3] * 0.001f; 
    }

    // -------------------------------------------------------------- 
    // Add camera
    // -------------------------------------------------------------- 
    PCamera *camera = PNEW(PCamera("camera", this));
    camera->setFixed(true);
    camera->transform().setLookAt(0.0f, 0.0f, 10.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f);
    camera->projection().window((pfloat32)rect[2], (pfloat32)rect[3]);
    setMainCamera(camera);
    
	PResourceManager* resMgr = context->module<PResourceManager>("resource-manager");

    // -------------------------------------------------------------- 
    // Scene objects
    // -------------------------------------------------------------- 
    PMaterial *material = PNEW(PMaterial("texture.pmt", resMgr));
    material->parameter("texture") = resMgr->getTexture("texture.png");
    material->setTransparent(true);
        
    PAbstractGeometry *geometry = PNEW(PGeometryPlane(resMgr));

    for (puint32 i = 0; i < NUM_LOGOS; ++i)
    {
        PString name = PString::fromUint(i);
        m_logos[i] = PNEW(PDrawable(name.c_str(), this));
        m_logos[i]->setGeometry(geometry);
        m_logos[i]->setMaterial(material);

        m_logos[i]->transform().setTranslation(pVector3(0.0f, 0.0f, 0.0f));
        m_logos[i]->transform().setScaling(pVector3(64.0f, 16.0f, 1.0f));
    }

    setBackgroundColor(pColorRGBA(1.0f, 1.0f, 1.0f, 0.0f));
}
コード例 #3
0
PDirectionalLight::PDirectionalLight(const pchar *name, PNode *node)
    : PAbstractLight(P_LIGHT_DIRECTIONAL, name, node)
{
    P_OBJECT_INITIALIZE_PROPERTY(PAbstractLight);

    P_OBJECT_REGISTER_PROPERTY("direction",    &m_direction);
    P_OBJECT_REGISTER_PROPERTY("castshadow",   &m_castShadow);
    m_direction = pVector3(-1.0f, 0.0f, 0.0f);
}
コード例 #4
0
void MyScene::fire()
{
    PSprite* sprite = m_sprites[m_nextSprite];
    sprite->transform().setTranslation(pVector3(0, 0, 0));

    
    pfloat32 theta = P_PI * 2.0f * m_random.getFloat32();
    pfloat32 phi = 0.48f * P_PI;
    pfloat32 speed = m_random.getFloat32() * 5.0f + 10.0f;

    pfloat32 y = sinf(phi);
    pfloat32 x = cosf(phi) * sinf(theta);
    pfloat32 z = cosf(phi) * cosf(theta);

    m_velocity[m_nextSprite] = pVector3(x, y, z) * speed;

    m_nextSprite = (m_nextSprite + 1) % NUM_SPRITES;
}
コード例 #5
0
MyScene::MyScene(PContext *context)
    : PScene("my-scene", context)
{
    m_nextSprite = 0;

    PResourceManager *resMgr = context->module<PResourceManager>("resource-manager");

    const puint32 *rect = context->rect();

    PCamera *camera = PNEW(PCamera("camera", this));
    camera->setFixed(true);
    camera->transform().setLookAt(0.0f, 10.0f, 7.0f, 0.0f, 5.0f, 0.0f, 0.0f, 1.0f, 0.0f);
    camera->projection().perspective(60.0f, (pfloat32)rect[2] / (pfloat32)rect[3], 0.1f, 100.0f);
    setMainCamera(camera);
    
    m_plane = PNEW(PDrawable("plane", this));
    m_plane->setGeometry(PNEW(PGeometryPlane(resMgr)));
    m_plane->setMaterial(PNEW(PMaterial("color.pmt", resMgr)));
    m_plane->material()->parameter("color") = P_COLOR_RED;

    PTexture* textures[1];
    textures[0] = resMgr->getTexture("texture.png");

    pchar name[] = "sprite0";
    for (puint32 i = 0; i < NUM_SPRITES; ++i)
    {
        name[6]++;        
        m_sprites[i] = PNEW(PSprite(name, this));
        m_sprites[i]->setAnimationDuration(4, 2000);
        m_sprites[i]->setTextureAtlas(textures, 1, 2, 2, true);

        m_sprites[i]->transform().setScaling(pVector3(0.25f, 0.25f, 1.0f));
        m_sprites[i]->transform().setTranslation(pVector3(-100000.0f, -100000.0f, -100000.0f));
    }

    pfloat32 aspect = (pfloat32)rect[2] / (pfloat32)rect[3];
    PSprite2D *legend = PNEW(PSprite2D("legend", this));
    legend->transform().setScaling(pVector3(aspect * 0.25f, aspect * 0.0625f, 1.0f));
    textures[0] = resMgr->getTexture("legend.png");
    legend->setTextureAtlas(textures, 1, 1, 1, true);
    legend->setAnimationDuration(1, 10000);
    legend->transform().setTranslation(pVector3(0, 0.4f, -1.0f));
}
コード例 #6
0
ファイル: pcamera.cpp プロジェクト: Freedom000/paper3d
void PCamera::fromLight(const PDirectionalLight *light, const PBox *bbox)
{
    PVector3 center = pVector3(0, 0, 0);
    PVector3 eye = light->direction() * 100.0f; // any point on the light ray is OK.
    PVector3 up;
    PVector3 lightSource = pVector3(-light->direction()[0],
                                    -light->direction()[1],
                                    -light->direction()[2]);
    if (lightSource[1] >= 0)
    {
        if (lightSource[1] < 0.99f)
        {
            up = pVector3(0, 1, 0);
        }
        else
        {
            up = pVector3(-1.0f, 0.0f, 0.0f);
        }
    }
    else
    {
        if (lightSource[1] > -0.99f)
        {
            up = pVector3(0, -1, 0);
        }
        else
        {
            up = pVector3(-1.0f, 0.0f, 0.0f);
        }
    }

    up.normalize();

    // Generate the camera matrix
    m_localTransform.setLookAt(eye[0], eye[1], eye[2], center[0], center[1], center[2], up[0], up[1], up[2]);

    PBox bboxInCameraSpace(*bbox);
    bboxInCameraSpace.transform(cameraTransform());

    // Generate the projection matrix
    m_projection.orthogonal(bboxInCameraSpace.min()[0],
                            bboxInCameraSpace.max()[0],
                            bboxInCameraSpace.min()[1],
                            bboxInCameraSpace.max()[1],
                            bboxInCameraSpace.min()[2] - 0.01f,
                            bboxInCameraSpace.max()[2] + 0.01f);
}
コード例 #7
0
void PDirectionalLight::setDirection(pfloat32 x, pfloat32 y, pfloat32 z)
{
    PVector3 v = pVector3(x, y, z);
    v.normalize();
    m_direction = v;
}
コード例 #8
0
PVector3 PPropertyTransform::scaling() const
{
    return pVector3(m_scalingx.toFloat(),
                    m_scalingy.toFloat(),
                    m_scalingz.toFloat());
}
コード例 #9
0
PVector3 PPropertyTransform::rotation() const
{
    return pVector3(m_rotationx.toFloat(),
                    m_rotationy.toFloat(),
                    m_rotationz.toFloat());
}
コード例 #10
0
MyScene::MyScene(PContext *context)
    : PScene("my-scene", context)
{
	PResourceManager *resMgr = context->module<PResourceManager>("resource-manager");
    
    // -------------------------------------------------------------- 
    // Add camera
    // -------------------------------------------------------------- 
    const puint32 *rect = context->rect();

    PCamera *camera = PNEW(PCamera("camera", this));
    camera->setFixed(true);
    camera->transform().setLookAt(0.0f, 0.0f, 10.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f);
    camera->projection().orthogonal((pfloat32)rect[2] / (pfloat32)rect[3], 0.1f, 100.0f);
    setMainCamera(camera);
    
    // -------------------------------------------------------------- 
    // Scene background
    // -------------------------------------------------------------- 
    setBackgroundColor(P_COLOR_BLACK_TRANSPARENT);    

    // -------------------------------------------------------------- 
    // Scene objects
    // -------------------------------------------------------------- 
    PMaterial *material; 
    PAbstractGeometry *geometry;

    material = PNEW(PMaterial("color.pmt", resMgr));
    material->parameter("color") = pColorRGBA(1.0f, 0.0f, 0.0f, 1.0f);
    geometry = PNEW(PGeometryPlane(resMgr));
    PDrawable *plane1 = PNEW(PDrawable("plane1", this));
    plane1->setMaterial(material);
    plane1->setGeometry(geometry);
    plane1->transform().setScaling(pVector3(0.2f, 0.2f, 1.0f));
    plane1->transform().setTranslation(pVector3(0.0f, -0.6f, 0.0f));
    
    material = PNEW(PMaterial("color.pmt", resMgr));
    material->parameter("color") = pColorRGBA(0.0f, 1.0f, 0.0f, 1.0f);
    geometry = PNEW(PGeometryPlane(resMgr));
    PDrawable *plane2 = PNEW(PDrawable("plane2", this));
    plane2->setMaterial(material);
    plane2->setGeometry(geometry);
    plane2->transform().setScaling(pVector3(0.2f, 0.2f, 1.0f));
    plane2->transform().setTranslation(pVector3(0.0f, 0.0f, 0.0f));
    
    material = PNEW(PMaterial("color.pmt", resMgr));
    material->parameter("color") = pColorRGBA(0.0f, 0.0f, 1.0f, 1.0f);
    geometry = PNEW(PGeometryPlane(resMgr));
    PDrawable *plane3 = PNEW(PDrawable("plane3", this));
    plane3->setMaterial(material);
    plane3->setGeometry(geometry);
    plane3->transform().setScaling(pVector3(0.2f, 0.2f, 1.0f));
    plane3->transform().setTranslation(pVector3(0.0f, 0.6f, 0.0f));

    // -------------------------------------------------------------- 
    // Global post processing effect.
    // -------------------------------------------------------------- 
    PEffectGlow *glow;
    glow = PNEW(PEffectGlow(this));
    glow->setBlendMode(P_EFFECTBLEND_MIX);
    glow->setBlurIterations(1);
    glow->setBlurKernelSize(5);
    glow->setBlurDistance(2);
}