Minimal example

[andrewerf]

I am new to filament, and I am trying to complete a minimal sample, that would draw something on the screen. Unfortunately, the samples are all based on the FilamentApp which is somewhat big to understand it at once, so I decided to go from scratch.
Here are my tries:

#include <fstream>
#include <iostream>

#include <filament/Engine.h>
#include <filament/View.h>
#include <filament/Renderer.h>
#include <filament/Scene.h>
#include <filament/Camera.h>
#include <filament/Viewport.h>
#include <filament/LightManager.h>
#include <filament/RenderableManager.h>
#include <filament/IndexBuffer.h>

#include <filamat/MaterialBuilder.h>

#include <utils/EntityManager.h>

#include <math/norm.h>

#include <gltfio/AssetLoader.h>
#include <gltfio/ResourceLoader.h>

#include <SDL.h>
#include <SDL_video.h>
#include <SDL_syswm.h>


void* getNativeWindow(SDL_Window* sdlWindow) {
    SDL_SysWMinfo wmi;
    SDL_VERSION(&wmi.version);
    SDL_GetWindowWMInfo(sdlWindow, &wmi);
    if (wmi.subsystem == SDL_SYSWM_X11) {
        Window win = (Window) wmi.info.x11.window;
        return (void *) win;
    }
    else {
        std::cout << "Unknown SDL subsystem";
    }
    return nullptr;
}

SDL_Window *createSDLwindow()
{

    const uint32_t windowFlags = SDL_WINDOW_SHOWN | SDL_WINDOW_RESIZABLE | SDL_WINDOW_ALLOW_HIGHDPI;
    SDL_Window *win = SDL_CreateWindow("Hello World!", 100, 100, 1920, 1080, 0);
    if (win == nullptr)
    {
        std::cout << "SDL_CreateWindow Error: " << SDL_GetError() << std::endl;
        SDL_Quit();
        return NULL;
    }

    return win;
}

using namespace filament;
using namespace math;
using namespace utils;
int main()
{
    SDL_Init( SDL_INIT_EVERYTHING );
    const static uint32_t indices[] = {
            0, 1, 2, 2, 3, 0};

    const static math::float3 vertices[] = {
            {-10, 0, -10},
            {-10, 0, 10},
            {10, 0, 10},
            {10, 0, -10},
    };

    short4 tbn = math::packSnorm16(
            mat3f::packTangentFrame(
                    math::mat3f{
                            float3{1.0f, 0.0f, 0.0f}, float3{0.0f, 0.0f, 1.0f},
                            float3{0.0f, 1.0f, 0.0f}})
                    .xyzw);

    const static math::short4 normals[]{tbn, tbn, tbn, tbn};
    SDL_Window *window = createSDLwindow();
    Engine *engine = Engine::create( filament::backend::Backend::OPENGL );
    SwapChain *swapChain = engine->createSwapChain( getNativeWindow( window ) );
    Renderer *renderer = engine->createRenderer();

    auto cameraEntity = EntityManager::get().create();
    Camera *camera = engine->createCamera( cameraEntity );
    View *view = engine->createView();
    Scene *scene = engine->createScene();

    view->setCamera(camera);
    // Determine the current size of the window in physical pixels.
    uint32_t w, h;
    SDL_GL_GetDrawableSize(window, (int *)&w, (int *)&h);
    // mWidth = (size_t)w;
    // mHeight = (size_t)h;

    // Compute the "virtual pixels to physical pixels" scale factor that the
    // the platform uses for UI elements.
    // int virtualWidth, virtualHeight;
    // SDL_GetWindowSize(window, &virtualWidth, &virtualHeight);
    // float dpiScaleX = (float)w / virtualWidth;
    // float dpiScaleY = (float)h / virtualHeight;

    camera->setProjection(45.0, double(w) / h, 0.1, 50, Camera::Fov::VERTICAL);
    view->setViewport({0, 0, w, h});

    view->setScene(scene);

    VertexBuffer *vertexBuffer = VertexBuffer::Builder()
            .vertexCount(4)
            .bufferCount(2)
            .attribute(VertexAttribute::POSITION, 0, VertexBuffer::AttributeType::FLOAT3)
            .attribute(VertexAttribute::TANGENTS, 1, VertexBuffer::AttributeType::SHORT4)
            .normalized(VertexAttribute::TANGENTS)
            .build(*engine);

    vertexBuffer->setBufferAt(*engine, 0, VertexBuffer::BufferDescriptor(vertices, vertexBuffer->getVertexCount() * sizeof(vertices[0])));
    vertexBuffer->setBufferAt(*engine, 1, VertexBuffer::BufferDescriptor(normals, vertexBuffer->getVertexCount() * sizeof(normals[0])));

    IndexBuffer *indexBuffer = IndexBuffer::Builder()
            .indexCount(6)
            .build(*engine);

    indexBuffer->setBuffer(*engine, IndexBuffer::BufferDescriptor(
            indices, indexBuffer->getIndexCount() * sizeof(uint32_t)));

    filamat::MaterialBuilder::init();
    filamat::MaterialBuilder builder;
    builder
        .name( "Some material" )
        .material( "    void material(inout MaterialInputs material) {\n"
                   "        prepareMaterial(material);\n"
                   "        material.baseColor.rgb = materialParams.baseColor;\n"
                   "        material.metallic = materialParams.metallic;\n"
                   "        material.roughness = materialParams.roughness;\n"
                   "        material.reflectance = materialParams.reflectance;\n"
                   "    }" )
        .parameter( "baseColor", filament::backend::UniformType::FLOAT3 )
        .parameter( "metallic", filament::backend::UniformType::FLOAT )
        .parameter( "roughness", filament::backend::UniformType::FLOAT )
        .parameter( "reflectance", filament::backend::UniformType::FLOAT )
        .shading( filamat::MaterialBuilder::Shading::LIT )
        .targetApi( filamat::MaterialBuilder::TargetApi::ALL )
        .platform( filamat::MaterialBuilder::Platform::ALL );

    filamat::Package package = builder.build( engine->getJobSystem() );

    Material *material = Material::Builder()
            .package( package.getData(), package.getSize() )
            .build(*engine);
    material->setDefaultParameter("baseColor", RgbType::LINEAR, float3{ 0, 1, 0 });
    material->setDefaultParameter("metallic", 0.0f);
    material->setDefaultParameter("roughness", 0.4f);
    material->setDefaultParameter("reflectance", 0.5f);

    MaterialInstance *materialInstance = material->createInstance();

    Entity renderable = EntityManager::get().create();

    Entity light = EntityManager::get().create();

    LightManager::Builder(LightManager::Type::SUN)
            .color(Color::toLinear<ACCURATE>(sRGBColor(0.98f, 0.92f, 0.89f)))
            .intensity(110000)
            .direction({0.7, -1, -0.8})
            .sunAngularRadius(1.9f)
            .castShadows(true)
            .build(*engine, light);

    scene->addEntity(light);

    // build a quad
    RenderableManager::Builder(1)
            .boundingBox({{-1, -1, -1}, {1, 1, 1}})
            .material(0, materialInstance)
            .geometry(0, RenderableManager::PrimitiveType::TRIANGLES, vertexBuffer, indexBuffer, 0, 6)
            .culling(false)
            .build(*engine, renderable);
    scene->addEntity(renderable);

    // for (int i = 0; i < 6000; i++)
    while (1)
    {
        // beginFrame() returns false if we need to skip a frame
        if (renderer->beginFrame(swapChain))
        {
            // for each View
            renderer->render(view);
            renderer->endFrame();
        }
        SDL_Delay(16);
        // std::this_thread::sleep_for(std::chrono::milliseconds(20));
    }

    engine->destroy(cameraEntity);
    return 0;
}

This code is mostly taken from the issue, but I decided to construct material at run-time for the ease of the reproducibility. In spite of the fact that the issue is marked resolved, the code does not work on my machine (Linux, AMD video), with a strange behavior: I am getting either a red screen or strange pattern (looks like some uncleared GPU buffer) depending on the backend I use (opengl and vulkan correspondingly):

Built-in samples work correctly on my set-up, so I just miss something in my own implementation. Would be thankful for any help!

[poweifeng]

I made small changes to your code and made it work:

#include <fstream>
#include <iostream>

#include <filament/Engine.h>
#include <filament/View.h>
#include <filament/Renderer.h>
#include <filament/Scene.h>
#include <filament/Camera.h>
#include <filament/Viewport.h>
#include <filament/LightManager.h>
#include <filament/RenderableManager.h>
#include <filament/IndexBuffer.h>
#include <filament/Skybox.h>

#include <filamat/MaterialBuilder.h>

#include <utils/EntityManager.h>

#include <math/norm.h>

#include <gltfio/AssetLoader.h>
#include <gltfio/ResourceLoader.h>

#include <SDL.h>
#include <SDL_video.h>
#include <SDL_syswm.h>


void* getNativeWindow(SDL_Window* sdlWindow) {
    SDL_SysWMinfo wmi;
    SDL_VERSION(&wmi.version);
    SDL_GetWindowWMInfo(sdlWindow, &wmi);
    if (wmi.subsystem == SDL_SYSWM_X11) {
        Window win = (Window) wmi.info.x11.window;
        return (void *) win;
    }
    else {
        std::cout << "Unknown SDL subsystem";
    }
    return nullptr;
}

SDL_Window *createSDLwindow()
{

    const uint32_t windowFlags = SDL_WINDOW_SHOWN | SDL_WINDOW_RESIZABLE | SDL_WINDOW_ALLOW_HIGHDPI;
    SDL_Window *win = SDL_CreateWindow("Hello World!", 100, 100, 600, 400, 0);
    if (win == nullptr)
    {
        std::cout << "SDL_CreateWindow Error: " << SDL_GetError() << std::endl;
        SDL_Quit();
        return NULL;
    }

    return win;
}

using namespace filament;
using namespace math;
using namespace utils;
int main()
{
    SDL_Init( SDL_INIT_EVERYTHING );
    const static uint32_t indices[] = {
            0, 1, 2, 2, 3, 0};

    const static math::float3 vertices[] = {
            {-10, 0, -10},
            {-10, 0, 10},
            {10, 0, 10},
            {10, 0, -10},
    };

    short4 tbn = math::packSnorm16(
            mat3f::packTangentFrame(
                    math::mat3f{
                            float3{1.0f, 0.0f, 0.0f}, float3{0.0f, 0.0f, 1.0f},
                            float3{0.0f, 1.0f, 0.0f}})
                    .xyzw);

    const static math::short4 normals[]{tbn, tbn, tbn, tbn};
    SDL_Window *window = createSDLwindow();
    Engine *engine = Engine::create( filament::backend::Backend::VULKAN );
    SwapChain *swapChain = engine->createSwapChain( getNativeWindow( window ) );
    Renderer *renderer = engine->createRenderer();

    auto cameraEntity = EntityManager::get().create();
    Camera *camera = engine->createCamera( cameraEntity );
    View *view = engine->createView();
    Scene *scene = engine->createScene();

    view->setCamera(camera);
    // Determine the current size of the window in physical pixels.
    uint32_t w, h;
    SDL_GL_GetDrawableSize(window, (int *)&w, (int *)&h);
    // mWidth = (size_t)w;
    // mHeight = (size_t)h;

    // Compute the "virtual pixels to physical pixels" scale factor that the
    // the platform uses for UI elements.
    // int virtualWidth, virtualHeight;
    // SDL_GetWindowSize(window, &virtualWidth, &virtualHeight);
    // float dpiScaleX = (float)w / virtualWidth;
    // float dpiScaleY = (float)h / virtualHeight;
    camera->lookAt(float3(0, 50.5f, 0), float3(0, 0, 0), float3(1.f, 0, 0));
    camera->setProjection(45.0, double(w) / h, 0.1, 50, Camera::Fov::VERTICAL);
    view->setViewport({0, 0, w, h});



    view->setScene(scene);

    VertexBuffer *vertexBuffer = VertexBuffer::Builder()
            .vertexCount(4)
            .bufferCount(2)
            .attribute(VertexAttribute::POSITION, 0, VertexBuffer::AttributeType::FLOAT3)
            .attribute(VertexAttribute::TANGENTS, 1, VertexBuffer::AttributeType::SHORT4)
            .normalized(VertexAttribute::TANGENTS)
            .build(*engine);

    vertexBuffer->setBufferAt(*engine, 0, VertexBuffer::BufferDescriptor(vertices, vertexBuffer->getVertexCount() * sizeof(vertices[0])));
    vertexBuffer->setBufferAt(*engine, 1, VertexBuffer::BufferDescriptor(normals, vertexBuffer->getVertexCount() * sizeof(normals[0])));

    IndexBuffer *indexBuffer = IndexBuffer::Builder()
            .indexCount(6)
            .build(*engine);

    indexBuffer->setBuffer(*engine, IndexBuffer::BufferDescriptor(
            indices, indexBuffer->getIndexCount() * sizeof(uint32_t)));

    auto skybox = Skybox::Builder().color({0.5, 0.5, 0.5, 1.0}).build(*engine);
    scene->setSkybox(skybox);

    filamat::MaterialBuilder::init();
    filamat::MaterialBuilder builder;
    builder
        .name( "Some material" )
        .material( "    void material(inout MaterialInputs material) {\n"
                   "        prepareMaterial(material);\n"
                   "        material.baseColor.rgb = materialParams.baseColor;\n"
                   "        material.metallic = materialParams.metallic;\n"
                   "        material.roughness = materialParams.roughness;\n"
                   "        material.reflectance = materialParams.reflectance;\n"
                   "    }" )
        .parameter( "baseColor", filament::backend::UniformType::FLOAT3 )
        .parameter( "metallic", filament::backend::UniformType::FLOAT )
        .parameter( "roughness", filament::backend::UniformType::FLOAT )
        .parameter( "reflectance", filament::backend::UniformType::FLOAT )
        .shading( filamat::MaterialBuilder::Shading::LIT )
        .targetApi( filamat::MaterialBuilder::TargetApi::ALL )
        .platform( filamat::MaterialBuilder::Platform::ALL );

    filamat::Package package = builder.build( engine->getJobSystem() );

    Material *material = Material::Builder()
            .package( package.getData(), package.getSize() )
            .build(*engine);
    material->setDefaultParameter("baseColor", RgbType::LINEAR, float3{ 0, 1, 0 });
    material->setDefaultParameter("metallic", 0.0f);
    material->setDefaultParameter("roughness", 0.4f);
    material->setDefaultParameter("reflectance", 0.5f);

    MaterialInstance *materialInstance = material->createInstance();

    Entity renderable = EntityManager::get().create();

    Entity light = EntityManager::get().create();

    LightManager::Builder(LightManager::Type::SUN)
            .color(Color::toLinear<ACCURATE>(sRGBColor(0.98f, 0.92f, 0.89f)))
            .intensity(110000)
            .direction({0.7, -1, -0.8})
            .sunAngularRadius(1.9f)
            .castShadows(true)
            .build(*engine, light);

    scene->addEntity(light);

    // build a quad
    RenderableManager::Builder(1)
            .boundingBox({{-1, -1, -1}, {1, 1, 1}})
            .material(0, materialInstance)
            .geometry(0, RenderableManager::PrimitiveType::TRIANGLES, vertexBuffer, indexBuffer, 0, 6)
            .culling(false)
            .build(*engine, renderable);
    scene->addEntity(renderable);

    // for (int i = 0; i < 6000; i++)
    while (1)
    {
        // beginFrame() returns false if we need to skip a frame
        if (renderer->beginFrame(swapChain))
        {
            // for each View
            renderer->render(view);
            renderer->endFrame();
        }
        SDL_Delay(16);
        // std::this_thread::sleep_for(std::chrono::milliseconds(20));
    }

    engine->destroy(cameraEntity);
    return 0;
}

The difference is that I set the camera to be at the appropriate distance and orientation to bring the quad into the camera's view. Tested with both gl and vulkan on linux.

[trethaller]

Thanks for this sample, I'm trying to get it to run on OSX and have made the following changes:

    SDL_Window *window = createSDLWindow();
    void* nativeWindow = getNativeWindow(window);   // Borrowed from NativeWindowHelper.h
    setUpMetalLayer(nativeWindow);

    Engine *engine = Engine::create(  );
    SwapChain *swapChain = engine->createSwapChain(nativeWindow );
    Renderer *renderer = engine->createRenderer();

However I get the following crash:

 -[SDLView setFramebufferOnly:]: unrecognized selector sent to instance 0x101d75e60
*** Terminating app due to uncaught exception 'NSInvalidArgumentException', reason: '-[SDLView setFramebufferOnly:]: unrecognized selector sent to instance 0x101d75e60'
*** First throw call stack:
(
	0   CoreFoundation                      0x0000000183fa7104 __exceptionPreprocess + 176
	1   libobjc.A.dylib                     0x0000000183ac5fd0 objc_exception_throw + 60
	2   CoreFoundation                      0x000000018404e10c -[NSObject(NSObject) __retain_OA] + 0
	3   CoreFoundation                      0x0000000183f0f030 ___forwarding___ + 1600
	4   CoreFoundation                      0x0000000183f0e930 _CF_forwarding_prep_0 + 96
	5   sampleapp                           0x000000010004577c _ZN8filament7backend14MetalSwapChainC2ERNS0_12MetalContextEP12CAMetalLayery + 324
	6   libsystem_pthread.dylib             0x0000000183e4ada0 thread_start + 8
)

There seems to be an error with the SDL window but I'm not sure what

[trethaller]

Okay found it, I actually needed to pass the metal handle to createSwapChain like this:

    SDL_Window *window = createSDLWindow();
    void* nativeWindow = getNativeWindow(window);
    void* metalLayer = setUpMetalLayer(nativeWindow);

    Engine *engine = Engine::create(  );
    SwapChain *swapChain = engine->createSwapChain(metalLayer);