Ejemplo n.º 1
0
void SceneCloudView::updateMesh(const cvpr_tum::TsdfVolume::TsdfVolumeConstPtr& volume)
{
    if (!marching_cubes_)
        marching_cubes_ = CUDAMarchingCubes::Ptr(new CUDAMarchingCubes());

    unsigned int maxverts;
    float* vertOut;
    if (marching_cubes_->computeIsosurface((float *)volume->data(),
                                           volume->getResolution()(0), volume->getSize()(0),
                                           vertOut, maxverts))
        cout << "marching cubes computed!" << endl;

    if (!vertOut)
        return;

    mesh_ptr_ = convertToMesh(vertOut, maxverts);

    free(vertOut);

}
Ejemplo n.º 2
0
	void TriangleClipper2D::clip(UINT8* vertices, UINT8* uvs, UINT32 numTris, UINT32 vertexStride, const Vector<Plane>& clipPlanes,
		const std::function<void(Vector2*, Vector2*, UINT32)>& writeCallback)
	{
		// Add vertices
		UINT32 numVertices = numTris * 3;
		mesh.verts.resize(numVertices);

		if (uvs != nullptr)
		{
			for (UINT32 i = 0; i < numVertices; i++)
			{
				ClipVert& clipVert = mesh.verts[i];
				Vector2 vector2D = *(Vector2*)(vertices + vertexStride * i);

				clipVert.point = Vector3(vector2D.x, vector2D.y, 0.0f);
				clipVert.uv = *(Vector2*)(uvs + vertexStride * i);
			}
		}
		else
		{
			for (UINT32 i = 0; i < numVertices; i++)
			{
				ClipVert& clipVert = mesh.verts[i];
				Vector2 vector2D = *(Vector2*)(vertices + vertexStride * i);

				clipVert.point = Vector3(vector2D.x, vector2D.y, 0.0f);
			}
		}

		addEdgesAndFaces();

		for (int i = 0; i < 4; i++)
		{
			if (clipByPlane(clipPlanes[i]) == -1)
				return;
		}

		convertToMesh(writeCallback);
	}
Ejemplo n.º 3
0
void Layer::surfaceLineDraw(
    Ogre::SceneManager* sm,
    Ogre::SceneNode* sn,
    const surface2d_t& sl
) const {

    assert( (sl.size() > 1) && "Линия поверхности не получена, образ не может быть создан." );

    // Рисуем образ линии поверхности
    auto slImage = sm->createManualObject();
    int i = 0;


    // Подготавливаем и накладываем текстуру
    // @see http://www.gamedev.ru/code/articles/?id=4191\
    // @see Тест-блоки ниже.
    // Достаточно указать текстурные координаты для каждой вершины. Наложение
    // размазано по построению вершин. См. ниже.

    // @todo Текстура должна заполнять поверхность. Получается - только границы поверхности.

    // Размер объекта, по крайним координатам
    const box2d_t slBox = calcBox( sl );
    const size2d_t slSize = calcSize( slBox );

    // Размер текстуры (материала)
    const std::string materialName = "landscape25/test";
    const size2d_t texture( 1024.0f, 1024.0f );
    // Накладываем 1 текстуру на 1 объект: вычисляем масштаб
    const scale2d_t ts = ONE2D / slSize;

    // Текстурные координаты для вершин
    coord2d_t uv( 0.0f, 0.0f );


    // Рисуем поверхность
    slImage->begin( "BaseWhiteNoLighting", Ogre::RenderOperation::OT_LINE_STRIP );
    //slImage->begin( materialName, Ogre::RenderOperation::OT_TRIANGLE_FAN );
    //slImage->begin( materialName, Ogre::RenderOperation::OT_TRIANGLE_STRIP );
    const int firstIndexSL = i;

    /* @test
    slImage->position( 0.0f,    0.0f,  0.0f   ); slImage->index( i ); ++i;
    slImage->position( 100.0f,  0.0f,  0.0f   ); slImage->index( i ); ++i;
    slImage->position( 100.0f,  0.0f, -200.0f ); slImage->index( i ); ++i;
    slImage->position( 0.0f,    0.0f, -200.0f ); slImage->index( i ); ++i;
    slImage->index( 0 );
    */

    /*
    // Создаём текстуру для слоя
    // @source http://www.ogre3d.ru/forum/viewtopic.php?f=8&t=4345
    Ogre::ColourValue diffuse;
    diffuse.a = 0.5f;
    Ogre::MaterialPtr materialPtr =
        Ogre::MaterialManager::getSingleton().create( "Red", "General" );
    Ogre::TextureUnitState* Texture =
        materialPtr->getTechnique(0)->getPass(0)->createTextureUnitState();
    // Задаём параметры отображения текстуры, цвет
    Texture->setColourOperationEx(
        Ogre::LBX_SOURCE1, 
        Ogre::LBS_MANUAL,
        Ogre::LBS_CURRENT, 
        Ogre::ColourValue::Red
    );
    // Режим прозрачности
    materialPtr->getTechnique(0)->getPass(0)->setSceneBlending( Ogre::SBT_TRANSPARENT_ALPHA );
    materialPtr->getTechnique(0)->getPass(0)->setDepthWriteEnabled( false );
    materialPtr->getTechnique(0)->getPass(0)->setDiffuse( diffuse );
    */

    // Получаем координаты крайних точек
    //const coord2d_t first = sl.front();
    //const coord2d_t last = sl.back();
    //const size2d_t size = calcSize( std::make_pair( last, first ) );

    // Рисуем полученную выше линию поверхности
    for (auto itr = sl.cbegin(); itr != sl.cend(); ++itr) {
        const coord2d_t coord = *itr;
        slImage->position( coord.get<0>(), 0.0f, coord.get<1>() );
        slImage->index( i ); ++i;
        // Текстура
        uv = coord * ts;
        slImage->textureCoord( uv.get<0>(), uv.get<1>() );
    }


    // Замыкаем образ внизу по крайним точкам 'sl'
    const coord2d_t lastCoord = sl.back();
    const coord2d_t firstCoord = sl.front();
    const int bottomSpace = 500;
    //const coord2d_t bottomCoord = std::min( lastCoord.get<1>(), firstCoord.get<1>() );
    //const float bottomCoordZ = min<1>( sl ) - bottomSpace;
    // Стабильная нижняя координата смотрится красивее скачущего слоя
    const float bottomCoordZ = -bottomSpace;
    slImage->position(
        lastCoord.get<0>(),
        0.0f,
        bottomCoordZ
    );
    slImage->index( i ); ++i;
    uv = lastCoord * ts;
    slImage->textureCoord( uv.get<0>(), uv.get<1>() );

    slImage->position(
        firstCoord.get<0>(),
        0.0f,
        bottomCoordZ
    );
    slImage->index( i ); ++i;
    uv = firstCoord * ts;
    slImage->textureCoord( uv.get<0>(), uv.get<1>() );

    slImage->index( firstIndexSL );


    // Завершаем построение
    slImage->end();
    slImage->setCastShadows( false );


    const std::string meshName = sn->getName() + "-layer.mesh";
    auto mesh = slImage->convertToMesh( meshName );

    
    // Помещаем объект на сцену
    auto e = sm->createEntity( meshName );
    //e->setMaterialName( "landscape25/test" );
    sn->attachObject( e );



    // <@test>
    // @source http://www.packtpub.com/article/materials-ogre-3d
    /*{
    auto manual = sm->createManualObject( "Quad" );
    manual->begin( "BaseWhiteNoLighting", Ogre::RenderOperation::OT_TRIANGLE_LIST );
    manual->position( 50.0, 0.0, 0.0 );
    manual->textureCoord( 0, 2 );
    manual->position( -50.0, 0.0, 100.0 );
    manual->textureCoord( 2, 0 );
    manual->position( -50.0, 0.0, 0.0 );
    manual->textureCoord( 2, 2 );
    manual->position( 50.0, 0.0, 100.0 );
    manual->textureCoord( 0, 0 );

    manual->index( 0 );
    manual->index( 1 );
    manual->index( 2 );

    manual->index( 0 );
    manual->index( 3 );
    manual->index( 1 );

    manual->end();

    manual->convertToMesh( "Quad" );

    auto e = sm->createEntity( "Quad" );
    e->setMaterialName( "landscape25/test" );
    //auto node = sn->createChildSceneNode();
    auto node = sm->getRootSceneNode()->createChildSceneNode( "Node1" );
    node->showBoundingBox( true );
    //const Ogre::Quaternion rx( Ogre::Degree( -90 ), Ogre::Vector3::UNIT_X ); 
    //node->rotate( rx );
    node->attachObject( e );
    }*/
    // </@test>


    // <@test>
    // @example http://pastebin.com/MZVQDENZ
    /*{
    const std::string name = "Test2";
    try {
        sm->destroyManualObject( name );
        sm->destroyEntity( name );
        sm->destroySceneNode( name );
    } catch ( ... ) {
    }
    auto m = sm->createManualObject( name );
    m->begin( "BaseWhiteNoLighting", Ogre::RenderOperation::OT_TRIANGLE_STRIP );
    m->position(   0.0f,  0.0f,    0.0f );  m->textureCoord( 0, 0 );
    m->position(   0.0f,  0.0f, -200.0f );  m->textureCoord( 0, 1 );    
    m->position( 100.0f,  0.0f,    0.0f );  m->textureCoord( 1, 0 );
    m->position( 100.0f,  0.0f, -200.0f );  m->textureCoord( 1, 1 );
    m->index( 0 );  m->index( 1 ); m->index( 2 );
    m->index( 1 );  m->index( 3 ); m->index( 2 );
    m->end();
    auto mesh = m->convertToMesh( name );
    auto e = sm->createEntity( name );
    e->setMaterialName( "landscape25/test" );
    auto node = sm->getRootSceneNode()->createChildSceneNode( name );
    node->showBoundingBox( true );
    node->attachObject( e );
    }*/
    // <@test>


    // <@test>
    // 1 треугольник
    /*{
    const std::string name = "Test3";
    try {
        sm->destroyManualObject( name );
        sm->destroyEntity( name );
        sm->destroySceneNode( name );
    } catch ( ... ) {
    }

    // @source http://www.gamedev.ru/code/articles/?id=4191
    // Вершины треугольника в плоскости XZ
    const coord2d_t a(   0.0f, 0.0f );
    const coord2d_t b(   0.0f, 300.0f );
    const coord2d_t c( 100.0f, 200.0f );

    // Размер объекта, по крайним координатам
    const size2d_t object( 100.0f, 300.0f );

    // Размер текстуры
    const size2d_t texture( 1024.0f, 1024.0f );

    // Накладываем текстуру на объект целиком: вычисляем масштаб
    //const scale2d_t s = texture / object;

    // Размер текселя
    //const size2d_t texel( 1.0f, 1.0f );

    // Рисуем объект, вычисляя текстурные координаты грани
    coord2d_t uv( 0.0f, 0.0f );
    auto m = sm->createManualObject( name );
    m->begin( "BaseWhiteNoLighting", Ogre::RenderOperation::OT_TRIANGLE_LIST );

    m->position( a.get<0>(), 0.0f, a.get<1>() );
    uv = a / object;
    m->textureCoord( uv.get<0>(), uv.get<1>() );

    m->position( b.get<0>(), 0.0f, b.get<1>() );
    uv = b / object;
    m->textureCoord( uv.get<0>(), uv.get<1>() );

    m->position( c.get<0>(), 0.0f, c.get<1>() );
    uv = c / object;
    m->textureCoord( uv.get<0>(), uv.get<1>() );

    m->triangle( 1, 0, 2 );
    m->end();
    auto mesh = m->convertToMesh( name );
    auto e = sm->createEntity( name );
    e->setMaterialName( "landscape25/test" );
    auto node = sm->getRootSceneNode()->createChildSceneNode( name );
    node->showBoundingBox( true );
    node->attachObject( e );
    }*/
    // <@test>


    // <@test>
    // Фигура из 3 треугольников
    /*{
    const std::string name = "Test3-3";
    try {
        sm->destroyManualObject( name );
        sm->destroyEntity( name );
        sm->destroySceneNode( name );
    } catch ( ... ) {
    }

    // @source http://www.gamedev.ru/code/articles/?id=4191
    // Вершины треугольника в плоскости XZ
    const coord2d_t a(   0.0f,   0.0f );
    const coord2d_t b(   0.0f, 300.0f );
    const coord2d_t c( 100.0f, 200.0f );
    const coord2d_t d( 400.0f, 200.0f );
    const coord2d_t e( 400.0f,   0.0f );

    // Размер объекта, по крайним координатам
    const size2d_t object( 400.0f, 300.0f );

    // Размер текстуры
    const size2d_t texture( 1024.0f, 1024.0f );

    // Накладываем 1 текстуру на 1 объект: вычисляем масштаб
    const scale2d_t s = ONE2D / object;

    // Размер текселя
    //const size2d_t texel( 1.0f, 1.0f );

    // Рисуем объект, вычисляя текстурные координаты грани
    coord2d_t uv( 0.0f, 0.0f );
    auto m = sm->createManualObject( name );
    m->begin( "BaseWhiteNoLighting", Ogre::RenderOperation::OT_TRIANGLE_FAN );
    int i = 0;

    // 1-й треугольник
    m->position( a.get<0>(), 0.0f, a.get<1>() );
    m->index( i );  ++i;
    uv = a * s;
    m->textureCoord( uv.get<0>(), uv.get<1>() );

    m->position( b.get<0>(), 0.0f, b.get<1>() );
    m->index( i );  ++i;
    uv = b * s;
    m->textureCoord( uv.get<0>(), uv.get<1>() );

    m->position( c.get<0>(), 0.0f, c.get<1>() );
    m->index( i );  ++i;
    uv = c * s;
    m->textureCoord( uv.get<0>(), uv.get<1>() );

    m->index( 0 );  m->index( 2 ); m->index( 1 );

    // 2-й треугольник
    m->position( d.get<0>(), 0.0f, d.get<1>() );
    m->index( i );  ++i;
    uv = d * s;
    m->textureCoord( uv.get<0>(), uv.get<1>() );

    m->index( 0 );  m->index( 3 ); m->index( 2 );

    // 3-й треугольник
    m->position( e.get<0>(), 0.0f, e.get<1>() );
    m->index( i );  ++i;
    uv = e * s;
    m->textureCoord( uv.get<0>(), uv.get<1>() );

    m->index( 0 );  m->index( 4 ); m->index( 3 );

    m->end();

    auto mesh = m->convertToMesh( name );
    auto entity = sm->createEntity( name );
    entity->setMaterialName( "landscape25/test" );
    auto node = sm->getRootSceneNode()->createChildSceneNode( name );
    node->showBoundingBox( true );
    node->attachObject( entity );
    }*/
    // <@test>


    


    /* - ?
    unsigned short src, dest;
    if (!mesh->suggestTangentVectorBuildParams( Ogre::VES_TANGENT, src, dest) ) {
        mesh->buildTangentVectors( Ogre::VES_TANGENT, src, dest );
    }
    */

}