Desactivar Opciones De La Targeta

[Mars Attacks]

 Pues desde mi ignorancia suprema veo ilógico que el Clear tarde más que pintar un quad, dudo que sea así.
Lo que sí veo lógico es que si se va a redibujar toda la pantalla se pueda obviar el Clear.

Ahora bien, luego igual me hace cosas extrañas el resultado, como degradados superchulos que no estaban programados (y que quedan realmente bien) o tonos distintos en los planos con transparencia (que también quedan bien XD)...

[Loover]

 Ahora que lo pienso, es verdad lo de que el quake  no limpia el framebuffer. Basta con no poner cielo en un mapa para ver ese efecto rarito al dibujarse una cosa después de otra...
Lo que no entiendo, es si poner el quad es más rápido, qué sentido tiene poner esa función. ¿Realmente es más rápido?

[[EX3]]

 Hombre, pues yo acabo de hacer la prueba y ke kereis ke os diga, me va mas rapido con el clear ke con un quad (Test3, el de primitivas, con Clear() = 343 FPS, sin clear usando mi funcion DRAW_Fill_Screen() = 263 FPS)

Mi funcion, DRAW_Fill_Screen() simplemente pinta un poligono de 4 lados con el color especificado ocupando toda la pantalla, pero visto lo visto ahora cambiare esto por un clear, ke parece mas agil.

Por cierto, otra definicion ke no tengo muy clara, cuando hablais de un quad estais hablando de un poligono de 4 lados (usease dos triangulos)?, por que si no es asi he metido la gamba con mi funcion hasta limites insospechados xDDD

Salu2...

[Haddd]

 A ver, Berserker no quería decir que era más rápido un Quad(es decir, 2 triángulos) que un Clear. Lo que quería decir es que si después del Clear dibujar un Quad para el bitmap de fondo que ocupa toda la pantalla, te puedes ahorrar el Clear. Pero un Clear es muuuucho más rápido que un Quad.

[Loover]

 ¿Por cierto [EXT] que filtros has usado para las imágenes? Estoy usando filtros Linear de Direct3d y me lo deja todo demasiado difuminado. Esto no me pasaba en OGL. Es decir, cuando tenía la imagen en su tamaño normal sin escalado ni rotación en OGL con los filtros linear se veía perfecta, en Direct3d se me ve difuminada :S. ¿Alguien sabe pq pasa esto?

[BeRSeRKeR]

 He hecho un timedemo para saber con mayor precisión la diferencia de rendimiento y el resultado es:

Con limpieza del frame buffer -> 134,4 fps
Sin limpieza del frame buffer -> 157,4 fps

O sea 23 fps más si no limpias el frame buffer...

Saludos.

[BeRSeRKeR]

"] Hombre, pues yo acabo de hacer la prueba y ke kereis ke os diga, me va mas rapido con el clear ke con un quad (Test3, el de primitivas, con Clear() = 343 FPS, sin clear usando mi funcion DRAW_Fill_Screen() = 263 FPS)

Supongo que tienes desactivado la escritura en el zbuffer. Eso también ayuda a incrementar el rendimiento. Sobre todo cuando no necesitas el depth buffer para nada...

Saludos.

[[EX3]]

 Loover, yo no uso filtros por ke trabajo con la interfaz DXSprite para el dibujo de todo tipo de graficos, de ahi ke tuviese ke usar escalas para dibujar correctamente los graficos, y esta interfaz no trabaja con los filtros (o por lo menos yo no veo ke le afecte) y el resultado es el ke ves, ni muy difuminado ni muy pixelizado, lo justo jeje.

BeRSeRKeR dijo:

Supongo que tienes desactivado la escritura en el zbuffer. Eso también ayuda a incrementar el rendimiento. Sobre todo cuando no necesitas el depth buffer para nada...

dx_lib32 al trabajar solo en 2D no usa el zbuffer para nada y como tu bien dices gana asi mas velocidad.

Salu2...

[Loover]

 Hi again.
Una pregunta, ¿como has implementado lo de las primitivas?

[[EX3]]

 Te refieres al dibujo de primitivas? lo hago a traves de la funcion DrawPrimitiveUP() y dependiendo del tipo de primitiva ke fuese a dibujar (linea, punto, caja(doble triangulo)) cambio el primer parametro.

Aca te pongo el codigo de la funcion de dibujo de lineas como ejemplo:

Código [Seleccionar] Expand

Dim LineStrip(1) As TLVERTEX '//Para dibujar lineas.

'Dibuja una linea:
Public Function DRAW_Line(X1 As Long, Y1 As Long, X2 As Long, Y2 As Long, Color As Long) As Long

On Error GoTo Errout

   LineStrip(0) = CreateTLVertex(CLng(X1), CLng(Y1), 0, 1, Color, 0, 0, 0)
   LineStrip(1) = CreateTLVertex(CLng(X2), CLng(Y2), 0, 1, Color, 0, 0, 0)
       
   Device.SetRenderState D3DRS_ALPHABLENDENABLE, 1
   Device.DrawPrimitiveUP D3DPT_LINESTRIP, 1, LineStrip(0), Len(LineStrip(0))
   
   DRAW_Line = 1
Exit Function

Errout:
   DRAW_Line = 0
   
End Function
El AlphaBlend se desactiva en cada llamada a la funcion de renderizado Frame().

Salu2...

P.D.: Existe alguna manera mas agil de dibujar primitivas (en general), por ke mi funcion DRAW_Circle() peta ke da gusto ya que tiene ke dibujar cada punto a traves de DRAW_Point(), razon por la ke el Test 3 va mas lento de lo normal.

[Loover]

 No me refería a como dibujar primitivas con tu librería... sino a como has implementado esas primitivas usando direct3d.
Por ejemplo DRAW_Point()

[[EX3]]

 Pos igual pero para un punto:

Código [Seleccionar] Expand

Dim PointStrip As TLVERTEX '//Para dibujar puntos.

'Dibuja un punto:
Public Function DRAW_Point(X As Long, Y As Long, Color As Long) As Long
On Error GoTo Errout

   PointStrip = CreateTLVertex(CLng(X), CLng(Y), 0, 1, Color, 0, 0, 0)
       
   Device.SetRenderState D3DRS_ALPHABLENDENABLE, 1
   Device.DrawPrimitiveUP D3DPT_POINTLIST, 1, PointStrip, Len(PointStrip)

DRAW_Point = 1
Exit Function

Errout:
DRAW_Point = 0
End Function
y la funcion de dibujo de circulos, la ke tanto me peta jeje:

Código [Seleccionar] Expand

'Dibuja una circunferencia (By Luis):
Public Function DRAW_Circle(X As Long, Y As Long, Radio As Long, Color As Long) As Long
On Error GoTo Errout
Dim i As Long, j As Long

   For i = (X - Radio) To (X + Radio)
       For j = (Y - Radio) To (Y + Radio)
           If Abs((((i - X) * (i - X)) + ((j - Y) * (j - Y)) - (Radio * Radio))) < Radio Then
              Call DRAW_Point(i, j, Color)
           End If
       Next j
   Next i
   
DRAW_Circle = 1
Exit Function

Errout:
DRAW_Circle = 0
End Function
Salu2...

[Loover]

 Muchas gracias, aunque así de primeras al no estar en c++ me despista un poco. Probaré a ver.

[[EX3]]

 Venga, me lanzo a la aventura, voy a intentar pasar el codigo de la funcion a C++ xDDD

Código [Seleccionar] Expand

TLVERTEX PointStrip; //Para dibujar puntos.

//Dibuja un punto:
DWORD DRAW_Point(DWORD X, DWORD Y, DWORD Color); //Era DWORD lo mismo que Long en VB (Entero Largo)???
{  
  //NOTA: CreateTLVertex() es una funcion externa, no de DirectX.
  PointStrip==CreateTLVertex(X, Y, NULL, 1, Color, NULL, NULL, NULL);
     
  Device->SetRenderState(D3DRS_ALPHABLENDENABLE, 1);
  Device->DrawPrimitiveUP(D3DPT_POINTLIST, 1, PointStrip, Len(PointStrip)); //No se cual es el sustituto de la funcion Len() de VB.

Return = 0
}
Habra errores a tutiplen xDD, eske hace tela ke no toco el C++.

Aki te posteo en VB el codigo de esa funcion, ke no es mas ke un wraper, creo ke lo llaman, nuse xDD:

Código [Seleccionar] Expand

'This structure describes a transformed and lit vertex - it's identical to the DirectX7 type "D3DTLVERTEX"
   Private Type TLVERTEX
       X As Single
       Y As Single
       z As Single
       rhw As Single
       Color As Long
       specular As Long
       tu As Single
       tv As Single
   End Type

'//This is just a simple wrapper function that makes filling the structures much much easier...
Private Function CreateTLVertex(X As Single, Y As Single, z As Single, rhw As Single, Color As Long, specular As Long, tu As Single, tv As Single) As TLVERTEX
   '//NB: whilst you can pass floating point values for the coordinates (single)
   '       there is little point - Direct3D will just approximate the coordinate by rounding
   '       which may well produce unwanted results....
CreateTLVertex.X = X
CreateTLVertex.Y = Y
CreateTLVertex.z = z
CreateTLVertex.rhw = rhw
CreateTLVertex.Color = Color
CreateTLVertex.specular = specular
CreateTLVertex.tu = tu
CreateTLVertex.tv = tv
End Function
Salu2...

P.D.: Ke alguien me lo corrija, ke kiero saber si todavia conservo algo de la sintaxis de C++ xDD.

[Loover]

 Gracias [EX3] No andaba muy desencaminada tu forma:

Código [Seleccionar] Expand


>> Esto en el .h:

// Pixel
struct structPixel
{
 // Posición
 float mX, mY, mZ;

 // Coordenadas de textura
 //float mU, mV;

 // Color
 DWORD mColor;
};
typedef struct structPixel PIXEL;
#define D3DFVF_PIXEL (D3DFVF_XYZ | D3DFVF_DIFFUSE)

>> Esto en el .cpp

/*
==================
Coloca un pixel en pantalla con el color y coordenada especificados
==================
*/
inline void LOV_Render::PutPixel (int pX,
         int pY,
         byte pR,
         byte pG,
         byte pB,
         byte pA)
{
// Pixel
PIXEL mPixel;

// Rellenamos la estructura
mPixel.mX = (float) pX;
mPixel.mY = (float) pY;
mPixel.mZ = (float) 0.0f;
mPixel.mColor = D3DCOLOR_RGBA (pR, pG, pB, pA);

// Color
mInfo.mDevice->SetTextureStageState (0, D3DTSS_COLORARG1, D3DTA_DIFFUSE);

// Dibujamos el pixel
mInfo.mDevice->SetFVF (D3DFVF_PIXEL);
mInfo.mDevice->DrawPrimitiveUP (D3DPT_POINTLIST, 1, &mPixel, sizeof (PIXEL));
}


/*
==================
Dibuja un círculo
==================
*/
inline void LOV_Render::Circle  (int pX,
         int pY,
         int pRadius,
         byte pR,
         byte pG,
         byte pB,
         byte pA)
{
for (int i = pX - pRadius; i < pX + pRadius + 1; i++)
{
 for (int j = pY - pRadius; j < pY + pRadius + 1; j++)
 {
  if (abs ((((i - pX) * (i - pX)) + ((j - pY) * (j - pY)) - (pRadius * pRadius))) < pRadius)
  {
   PutPixel (i, j, pR, pG, pB, pA);
  }
 }
}
}


Y si que es verdad, va más lento que el caballo del malo. Pero si haces pruebas verás que es el PutPixel, (prueba a quitar el PutPixel al dibujar el círculo y verás que no baja ni un fps) parece ser que Direct3D no está pensado para este tipo de menesteres, con 6 o 7 círculos bajan uno 300fps  (nooo) Ya me veo dibujando circulos sobre una textura y escalándolos... ummmm Vivan los métodos cutre salchicheros.