Czy robię coś nie tak z tym programem CG?

Question

Używam Ogre3D jako silnika graficznego.

utworzyć siatkę ręcznie, co działa dobrze, UVS są poprawne i są ustawione do reprezentowania współrzędne siatki (w tym przykładzie siatka to 10 x 10)

zrobić nic w programie wierzchołków i mają bardzo prosty program fragmentów. Objaśniłem oba programy oraz plik materiałowy.

Mój problem polega na tym, że nawet przy ustawieniu filtrowania na none kolory nie wydają się być takie same, jak mój oryginalny obraz (jest to tylko obraz testowy, którego używam, ponieważ miałem problemy z ręcznym tworzeniem tekstury w ogr). Okazuje się, że problem nie jest moim kodem w ogre, ale bardziej prawdopodobny jest jakiś związek z plikiem materialnym lub programami fragment/vertex.

Mam również zrzut ekranu wyjścia po lewej stronie i oryginalny obraz po prawej stronie. Shader fragmentów rysuje prostą siatkę nad wierzchołkiem, dzięki czemu mogłem upewnić się, że współrzędne uv zostały poprawnie przekazane. Które wydają się być.

Każdy wgląd byłby znacznie ceniona, jak jestem naprawdę pewien, co robię źle.

Materiał file:

// CG Vertex shader definition 
vertex_program PlainTexture_VS cg    
{ 
    // Look in this source file for shader code 
    source GameObjStandard.cg 
    // Use this function for the vertex shader    
    entry_point main_plain_texture_vp  
    // Compile the shader to vs_1_1 format  
    profiles arbvp1  

    // This block saves us from manually setting parameters in code 
    default_params      
    { 
     // Ogre will put the worldviewproj into our 'worldViewProj' parameter for us. 
     param_named_auto worldViewProj worldviewproj_matrix   
     // Note that 'worldViewProj' is a parameter in the cg code. 
    } 
} 

// CG Pixel shader definition 
fragment_program PlainTexture_PS cg    
{ 
    // Look in this source file for shader code 
    source GameObjStandard.cg   
    // Use this function for the pixel shader  
    entry_point main_plain_texture_fp  
    // Compile to ps_1_1 format  
    profiles arbfp1    
} 

material PlainTexture 
{ 
    // Material has one technique 
    technique     
    { 
     // This technique has one pass 
     pass     
     { 
      // Make this pass use the vertex shader defined above 
      vertex_program_ref PlainTexture_VS  
      { 
      } 
      // Make this pass use the pixel shader defined above 
      fragment_program_ref PlainTexture_PS  
      { 
      } 
      texture_unit 0 
      { 
       filtering none 
       // This pass will use this 2D texture as its input 
       texture test.png 2d   
      } 
      texture_unit 1 
      { 
       texture textureatlas.png 2d 
       tex_address_mode clamp 
       filtering none 
      } 
     } 
    } 
} 

CG Plik:

void main_plain_texture_vp(
    // Vertex Inputs 
    float4 position  : POSITION, // Vertex position in model space 
    float2 texCoord0 : TEXCOORD0, // Texture UV set 0 

    // Outputs 
    out float4 oPosition : POSITION, // Transformed vertex position 
    out float2 uv0  : TEXCOORD0, // UV0 

    // Model Level Inputs 
    uniform float4x4 worldViewProj) 
{ 
    // Calculate output position 
    oPosition = mul(worldViewProj, position); 

    // Simply copy the input vertex UV to the output 
    uv0 = texCoord0; 
} 

void main_plain_texture_fp(
    // Pixel Inputs 
    float2 uv0  : TEXCOORD0, // UV interpolated for current pixel 

    // Outputs 
    out float4 color : COLOR, // Output color we want to write 

    // Model Level Inputs 
    uniform sampler2D Tex0: TEXUNIT0, 

uniform sampler2D Tex1: TEXUNIT1)  // Texture we're going to use 
{ 

//get the index position by truncating the uv coordinates 
float2 flooredIndexes = floor(uv0); 

if((uv0.x > 0.9 && uv0.x < 1.1) 
|| (uv0.x > 1.9 && uv0.x < 2.1) 
|| (uv0.x > 2.9 && uv0.x < 3.1) 
|| (uv0.x > 3.9 && uv0.x < 4.1) 
|| (uv0.x > 4.9 && uv0.x < 5.1) 
|| (uv0.x > 5.9 && uv0.x < 6.1) 
|| (uv0.x > 6.9 && uv0.x < 7.1) 
|| (uv0.x > 7.9 && uv0.x < 8.1) 
|| (uv0.x > 8.9 && uv0.x < 9.1)) { 
    float4 color1 = {1.0,0,0,0}; 
    color = color1; 
} else if((uv0.y > 0.9 && uv0.y < 1.1) 
|| (uv0.y > 1.9 && uv0.y < 2.1) 
|| (uv0.y > 2.9 && uv0.y < 3.1) 
|| (uv0.y > 3.9 && uv0.y < 4.1) 
|| (uv0.y > 4.9 && uv0.y < 5.1) 
|| (uv0.y > 5.9 && uv0.y < 6.1) 
|| (uv0.y > 6.9 && uv0.y < 7.1) 
|| (uv0.y > 7.9 && uv0.y < 8.1) 
|| (uv0.y > 8.9 && uv0.y < 9.1)) { 
    float4 color1 = {1.0,0,0,0}; 
    color = color1; 
} else { 
    //get the colour of the index texture Tex0 at this floored coordinate 
    float4 indexColour = tex2D(Tex0, (1.0/10)*flooredIndexes); 
    color = indexColour; 
} 
} 

Answer 1

Ok więc jej było dawno znalazłem rozwiązanie moich problemów niestety nie byl online więc nadzieję, że to pomoże nikogo z podobnymi problemami .

Tworząc każdą fakturę należy zawsze upewnić tekstury rozmiar w tekseli 2^n * 2^m gdzie m i n są szerokość i wysokość tekstury. To był mój pierwszy błąd, chociaż nie zdawałem sobie z tego sprawy w tym czasie.

Powodem, dla którego nie zauważyłem tego, był mój główny atlas teksturalny oparty na tej zasadzie i miał strukturę 1024 x 1024. To, czego nie brałem pod uwagę, to rozmiar tekstury, którą stworzyłem jako indeks tekstury. Ponieważ moja mapa miała wymiary 10 x 10, tworzyłem dla indeksów teksturę 10 x 10, to zakładam, że jestem w jakiś sposób rozciągana (nie wiem, jak działa w backendach) na 16 x 16 lub 8 x 8, łącząc teksle razem, jak to zrobili.

Pierwszą rzeczą, która dała mi wskazówkę było, kiedy przeskalowałem moje płótno w programie Photoshop i odkryłem, że mieszane kolory, które tworzył, były takie same jak te, które otrzymywałem na moim wyjściu ogre3d.

Zresztą przejściem ..

Raz ja to zorientowali się, że jestem w stanie stworzyć teksturę w Ogre i przekazać ją w poprzek następująco

//Create index material 
Ogre::TexturePtr indexTexture = Ogre::TextureManager::getSingleton().createManual("indexTexture","General",Ogre::TextureType::TEX_TYPE_2D, 16, 16, 0, Ogre::PixelFormat::PF_BYTE_BGRA, Ogre::TU_DEFAULT); 

Ogre::HardwarePixelBufferSharedPtr pixelBuffer = indexTexture->getBuffer(); 
pixelBuffer->lock(Ogre::HardwareBuffer::HBL_NORMAL); 

const Ogre::PixelBox& pixelBox = pixelBuffer->getCurrentLock(); 
Ogre::uint8* pDest = static_cast<Ogre::uint8*>(pixelBox.data); 

Ogre::uint8 counter = 0; 
for (size_t j = 0; j < 16; j++) { 
for(size_t i = 0; i < 16; i++) 
{  
     if(i==8 || i==7) { 
    *pDest++ = 3; // B 
    *pDest++ = 0; // G 
    *pDest++ = 0; // R 
    *pDest++ = 0; // A 
    } else { 
    *pDest++ = 1; // B 
    *pDest++ = 0; // G 
    *pDest++ = 0; // R 
    *pDest++ = 0; // A 
    } 
    counter++; 
} 
} 

pixelBuffer->unlock(); 

Więc teraz mam tekstury można użyć jako indeks z niektórymi wartościami, które dodałem do testowania, wartości te zostaną ostatecznie zapełnione w środowisku wykonawczym, klikając kafelek.

teraz, aby przekazać tę strukturę całej musiałem przekazać go do prawidłowej techniki i przekazać w moim materiale, stało się to w następujący sposób:

Ogre::MaterialPtr material = Ogre::MaterialPtr(Ogre::MaterialManager::getSingleton().getByName("PlainTexture")); 
float mapSize = 16; 
float tas = 2; 
material->getTechnique(0)->getPass(0)->getFragmentProgramParameters()->setNamedConstant("mapSize",mapSize); 
material->getTechnique(0)->getPass(0)->getFragmentProgramParameters()->setNamedConstant("tas",tas); 
material->getTechnique(0)->getPass(0)->getTextureUnitState(0)->setTextureName("indexTexture");  

To przechodzi dwie wartości też mapSize jest wielkość samej mapy w kaflach (zakładając, że jest kwadratem) i tas będącym rozmiarem atlasu tekstury (liczba różnych kwadratów tekstur na całej szerokości atlasu).

Aby umożliwić mój materiał, aby zrozumieć, co właśnie przeszedł w Musiałam zmodyfikować mój plik materiału lekko następująco:

// CG Pixel shader definition 
fragment_program PlainTexture_PS cg    
{ 
    source GameObjStandard.cg  
    entry_point main_plain_texture_fp 
    profiles arbfp1 
default_params 
{ 
    param_named tas float 
    param_named 
}    
} 

I moje podanie zostało nowo nieco zbyt

pass     
{ 
        // Make this pass use the vertex shader defined above 
    vertex_program_ref PlainTexture_VS  
    { 
    } 
        // Make this pass use the pixel shader defined above 
    fragment_program_ref PlainTexture_PS  
    { 
    } 
    texture_unit 0 
    { 
     filtering none   
    } 
texture_unit 1 
{ 
    texture textureatlas.png 2d 
    tex_address_mode clamp 
    filtering anisotropic 
} 
} 

Potem przepisał program fragmentacji tekstury cg, aby uwzględnić zmiany, które wprowadziłem.

void main_plain_texture_fp(
    float2 uv0 : TEXCOORD0, // UV interpolated for current pixel 
    out float4 color : COLOR, // Output color we want to write 
uniform float tas, 
uniform float mapSize, 

    // Model Level Inputs 
    uniform sampler2D Tex0: TEXUNIT0, 
uniform sampler2D Tex1: TEXUNIT1) 
{ 
//get the index position by truncating the uv coordinates 
float2 flooredIndexes = floor(uv0); 

//get the colour of the index texture Tex0 at this floored coordinate 
float4 indexColour = tex2D(Tex0, ((1.0/mapSize) * flooredIndexes)+(0.5/mapSize)); 

//calculate the uv offset required for texture atlas range = 0 - 255 
float indexValue = (255 * indexColour.b) + (255 * indexColour.g) + (255 * indexColour.r); 

//float indexValue = (tas * tas) - indexValue0; 

if(indexValue < tas*tas) { 
    float row = floor(indexValue/tas); 
    float col = frac(indexValue/tas) * tas; 

    float uvFraction = 1.0/tas; 

    float uBase = col * uvFraction; 
    float vBase = 1 - ((tas - row) * uvFraction); 

    float uOffset = frac(uv0.x)/tas; 
    float vOffset = (frac(uv0.y))/tas; 

    float uNew = uBase + uOffset; 
    float vNew = vBase + vOffset; 

    float2 uvNew = {uNew, vNew}; 

    if(frac(uv0.x) > 0.99 || frac(uv0.x) < 0.01) { 
    float4 color1 = {1,1,1,0}; 
    color = (0.2*color1) + (0.8*tex2D(Tex1,uvNew)); 
    } else if(frac(uv0.y) > 0.99 || frac(uv0.y) < 0.01) { 
    float4 color1 = {1,1,1,0}; 
    color = (0.2*color1) + (0.8*tex2D(Tex1,uvNew)); 
    } else { 
    color = tex2D(Tex1,uvNew); 
    } 


} else { 
    float4 color2 = {0.0,0,0,0}; 
    color = color2; 
} 
} 

obliczane prawidłowe Texel potrzebne z atlasu teksturę, również nałożony na słabe grid przez górze łącząc 80% kolor teksela i 20% bieli.

Jeśli atlasu tekstur nie posiada indeks koloru określonego przez tekstury indeksu to właśnie wyprowadza czarny (Dzieje się tak głównie dlatego jego bardzo łatwe do wykrycia.

Poniżej jest przykład wyjścia za pomocą . 2 x 2 atlas tekstury