BENG's questions

Existe uma maneira rápida de abrir chaves para uma função e terminar no modo de inserção recuado na próxima linha. Então, por exemplo:

void myFunc(int arg) {
    <cursor>
}

Especificamente, estou pedindo uma moção para ser executada depois de escrever os argumentos dentro de ().

No momento, a única maneira que consigo pensar é a direta, insira colchetes abertos e fechados, mova o segundo duas linhas para baixo, suba uma e depois tabule. {}<esc>i<enter><enter><esc>ki<tab>

Isso parece realmente redundante. Acho que também posso esperar para escrever a segunda curva depois de criar as novas linhas e salvar uma opção de modo. Mas existe uma maneira mais inteligente de fazer isso?

Estou usando Objective-C e Metal para renderizar em uma janela, porém todo o código do meu aplicativo está escrito em C++. Portanto, toda a manipulação dos dados internos da CPU MTLBufferé feita em C++. Isso é feito passando o conteúdo dos buffers (que é um void*) para o código C++, onde ele lança o ponteiro do conteúdo para MyVertex*gravar novos dados de vértice. No meu arquivo de cabeçalho, apenas adicionei condições do compilador para digitar as estruturas de vértice corretamente.

#ifdef __IN_OBJC__
#define V2 vector_float2
#define V4 vector_float4
#endif

#ifdef __IN_CPP__
#define V2 vec2
#define V4 vec4
#endif

typedef struct {
    V2 position;
    V4 color;
} MyVertex;

Aqui vec2estão vec4basicamente estruturas de 2, 4 carros flutuantes implementadas em meu código C++. Mas neste exemplo, Objective-C e C++ pensam que MyVertexsão de tamanhos diferentes. Estou compilando com clang e clang++. E o compilador Objective-C deseja preencher a estrutura para que ela tenha tamanho 32, enquanto C++ diz que a estrutura é de tamanho 24. Atualmente, corrigi isso com #pragma pack, mas parece uma solução fraca. Na verdade, eu preferiria que minha implementação C++ fosse preenchida em vez de compactada para otimizar melhor os buffers nos shaders. Mas não posso preencher deliberadamente uma estrutura como posso empacotar uma.

Devo tornar meus próprios vetores ( vec2…) compatíveis com Objective-C? No momento, eles são escritos como classes. Dessa forma, não terei que fazer declarações condicionais. Eu preferiria que a solução otimizasse melhor o desempenho do buffer no shader.

Eu tenho uma lista de fontes em um conjunto de diretórios por

SOURCES = $(wildcard src/**/*.cpp)

Digamos, por exemplo, que temos um diretório como este

src
|- dir_one
|  |- file_one.cpp
|  `- file_two.cpp
|
|- dir_two
|  |- file_three.cpp
|  `- file_four.cpp
|
`- dir_three
   `-file_five.cpp

então $(SOURCES)é igual a

src/dir_one/file_one.cpp
src/dir_one/file_two.cpp
src/dir_two/file_three.cpp
src/dir_two/file_four.cpp
src/dir_three/file_five.cpp

Quero usar funções Makefile para obter uma lista apenas dos nomes dos arquivos, MAS não sei quais diretórios existem. Então, por exemplo, eu quero obter

NAMES = <some makefile functions>

então $(NAMES) é igual a

file_one file_two file_three file_four file_five

Quero ter um template com parâmetros typename T e um objeto do tipo T que represente um null_object. O objetivo é criar uma classe contêiner na qual, para cada tipo, um determinado null_value seja fornecido para o construtor vazio. Por exemplo

template<typename T, T null_value>
class MyObject {
private:
     std::array<T,4> data;

public:
    MyObject() {
        data.fill(null_value);
    }
};

No entanto, não posso fazer isso com a sintaxe fornecida acima. Como posso fazer isso? Se isso não for possível com modelos aninhados, existe uma maneira de definir construtores distintos para alguns valores de modelo específicos? Por exemplo

template<typename T>
class MyObject {
private:
    std::array<T,4> data;

public:
    MyObject<int>() {
        data.fill(0);
    }

    MyObject<float>() {
        data.fill(0.0f);
    }

    MyObject<char>() {
        data.fill('a');
    }
};

EDIT: Para alguns tipos como int, o primeiro pedaço de código será compilado. No entanto, para tipos como float, o pedaço não será compilado.