Sugerencias con directX 7

Hola, pues quería aprender un poco a manejar la librería de DirectX desde C++ para poder crear.dll para Blitz3d. Si alguien a echo alguna librería o sabe manejar DirectX le estaría muy agradecido si pusiera algún código fuente (aunque sea dibujar un cubo solamente) y que includes hay que hacer.

Tengo un compilador y editor para C++ que se llama devc ++, pero no he conseguido aún instalar las librerías de DirectX.

Me descargue Microsoft DirectX SDK (june 2010), pero no sé cómo vincular esa descarga con el programa que compila, y por otro lado, no sé dónde puedo ver las funciones y comandos para dibujar, por ejemplo, un cubo. Gracias a todos.

Bueno ya he conseguido instalar DirectX en el Dev-C++ y también SDL y también OpenGL. Ahora voy a navegar un poco por los códigos de ejemplos y por los códigos que traen por defecto de proyectos nuevos para ver si esto es tan difícil como dicen.

Por si alguien necesita estos paquetes de instalación para el programa gratuito Dev-c, aquí los dejo: http://www.programacióngráfica.com/m...download&cid=2.

Y dos dudas a ver si alguien puede ayudarme:
¿Dónde se pueden encontrar todas, pero todas las funciones que permite usar, por ejemplo, DirectX? ¿o OpenGL? Y si fueran acompañadas de la explicación de lo que hacen pues mejor.

Y otra duda: ¿cómo se crea una Api? Es decir, ¿en qué lenguaje se crea una Api, por ejemplo, DirectX?
No quiero decir que quiera hacer una Api, pero me hace curiosidad saber cómo se fabrica eso. Porque si para usarlas se hace con C++, pues para crearlas no sé cómo se hará eso.

Bueno, si alguien pudiera poner un código de una.dll para Blitz3d, aunque simplemente fuera crear unas cajas y moverlas, o cualquier cosa sencilla, pues con eso ya tendría para arrancar.

De todas formas, sigo buscando códigos fuente para la.dll.

Y ya sé que hay librerías ya echas para Blitz3d, pero me interesa aprender a hacerlas por dos motivos:
-Aprender c.

Saber lo que hacen realmente las funciones y evitarme fallos en su uso. Gracias a todos.

Bueno ahora mismo estoy aprendiendo C++ con un manual bastante extenso. La verdad que está interesante, en cuanto acabe el manual (que tiene ejemplos y todo) pues podré entender algunos códigos que trae por defecto al iniciar un proyecto en DirectX. Y luego seguro que encuentro otros códigos fuente hechos en DirectX. Y luego podré hacer una.dll de gráficos para Blitz3d.

Bueno ya he encontrado códigos fuente para c en el sitio oficial de Blitz3d, ya solo queda entenderlos, y parece más complicado de lo que parecía.

Le seguiré dando al manual, y cuando consiga algún pequeño avance lo público por aquí.

De todas formas, estaría muy bien si alguien ya ha hecho algo con las (*.dll) en Blitz3d y no le importa colgar un código para hacer algo y explicarlo un poco por encima. Saludos a todos.

Pues esto de la programación es increíble, y yo que pensaba que sabía mucho. He encontrado esta página para todos aquellos que quieran aprender OpenGL o DirectX: http://www.programacióngráfica.com/index.php.

Es increíble lo que estoy aprendiendo en ella, y más increíble es que para abrir una ventana se necesiten unos cuantos ficheros fuente.

Lo que me pierde un poco en el manual (que no la página) es el uso de memoria y bytes y demás, aunque nada que no llegue a entender con un poco de practica.

Ya conseguí abrir una ventana y dibujar unas líneas, pero siento decirlo, solo he conseguido presionando f9 para compilar, ya que el código ni idea (de momento). Me recuerda a cuando presione f5 en Blitz3d por primera vez, que bonito es aprender.

Cuando logre algún avance propio lo pondré por aquí, aunque de momento me queda un poco mucho.

Posdata: sigo diciendo que si alguien gusta en poner alguna (*.dll) y explicarla pues mil gracias, me ahorraría algo de tiempo.

Hacer un.dll de DirectX no es moco de pavo, en general, y este foro es más de 3d desde punto de vista de grafistas más que de otra cosa. Hay algún que otro coder, pero pocos.

Quizás puedes publicar la duda en algún foro de programadores más bien. Saludos.

Gracias por el consejo, pero ya me di cuenta de eso, pero digo yo que si la gente las hace, pues yo soy gente, y por intentarlo no se pierde nada.

Total, que lo aprendido en Blitz3d no se me va a olvidar, pero gracias.

Vaya, pues a mí se me había pasado por completo este hilo. De todas formas, te sugiero que te pases por Stratos (www.stratos-ad.com) dónde está el 3dpoder de los programadores de juegos de habla hispana, con gente que pilota un montón de un montón de aspectos relacionados con el desarrollo.

Sobre cómo se hace una librería, es tan simple o tan complicado como una recopilación de funciones. En el momento en el que creas el proyecto, en lugar de decirle al sistema que genere un (*.exe), le dices que genere un.dll. En otros programas que quieras usarla, se la añadirás en su sección de librerías, y a partir de ahí es tan simple cómo hacer llamadas a funciones como si las tuvieras definidas internamente. Quien dice funciones dice clases, estructuras, lo que quieras tener allí.

Gracias Mars, que compilador usas tú? Yo uso uno gratis llamado Dev-C++.

Gc y g++, los compiladores libres para Unix/GNU Linux. En Windows (en el trabajo) suelo usar visual Studio con el que trae de serie.

Yo también uso codeblocks (esta basado en Dev++) para chorradas en c(solo llego a chorradas), y notepad++/Shader FX para hlsl y c-g.

Pero el 99% de programadores te dirán que usan visualstudio para el trabajo.

Supongo es mucho mejor para gestionar proyectos grandes.

Edito: raro, el foro me cambia palabras automáticamente.

Muchas gracias, pero de momento eso es lo que quiero hacer, chorradas sencillas. Veré entonces de conseguir el visualstudio más adelante, muchas gracias.

Y una cosa, has echo alguna dll?

Como dice Mars, una dll no es más que una bilbioteca de funciones. Supongo tendrá un Header en particular, pero el resto es igual al código de un exe.

Hasta donde yo entiendo, que es poco.

Ya sé, si he creado una que suma dos números. Pero lo que realmente quiero saber, es las funciones que hay que usar para tratar directamente con los vértices, con las luces, con el render, etc.

Y no sé dónde encontrar documentación extensa y en español sobre el uso de todas esas funciones necesarias.

En la página esa, ponen códigos, y me es útil por eso. Pero me gustaría tener un manual extenso de todas las funcionalidades de DirectX.

Posdata: por cierto, IkerClon¿dirás Mars ¿no?

Me suena que el SDK de DirectX trae un montón de ejemplos y documentación muy extensa (ingles), seguro que hay algo de manipulación de vértices y tal, pero no se ayudarte. Esto está mucho más, allá de lo que yo llego.

Si, es Mars, se me confunden estos muchachos.

Bueno pues muchas gracias, ando algo perdidillo en todo este tema, de momento me centrare en aprender C++, estoy realizando ejemplos ya con punteros, cadenas, estructuras etc, y es muy apasionante.

Más adelante veré eso de SDK, pero otra duda (tonta seguro,):
Las funciones de skd valen para hacer una librería con DirectX? Es que no entiendo bien lo de la tarjeta gráfica, me podrías explicar un poco así a tu modo de ver.

El SDK es el material necesario para desarrollar apps en DirectX. Muy a Grosso modo, es una gigantesca biblioteca de funciones, documentación y módulos.

La parte gráfica se encarga de tratar, justamente con la tarjeta gráfica, porque Direct3D está pensado más que nada para videojuegosy apps en tiempo real. Programar una gráfica directamente seria un marrón, así que, DirectX hace gran parte del trabajo sucio.

Lo puedes bajar gratis de la página de Microsoft.

Sigo recomendándote que te pases por Stratos. Hay muchos hilos dedicados a la programación gráfica, recursos de auto aprendizaje y demás.

Ya se gracias Mars, buscando por Google sobre programación a veces topo con ese foro, pero es difícil arrancar en un lenguaje nuevo, luego ya será más fácil. De todas formas, echaré un ojo por ahí, aunque si pudieras pasarme algún enlace para novatos en esto de DirectX y librerías y así, te lo agradezco.

Y oye Mars, podrías irte a un ordenador con Windows, y probar mi juego (cirujanos zombies), que le puse un modo de ojo mágico que seguro te gustaba.

Bueno, por fin he conseguido crear una.dll y que funcione en Blitz3d, pero no hace una simple suma, si no que inicia DirectX, carga una teterita y la renderiza y además la rota.

Me costó bastante encontrar un ejemplo de algo así, y es justo el archivo que adjunto.

Ahora ya tengo código donde investigar y además sé que funciona.

También encontré este enlace: http://msdn.Microsoft.com/en-us/libr...(v=vs.85).aspx.

Donde estoy aprendiendo también con tutoriales (aunque sean inglés) y además tiene todas las funciones que se pueden usar con su explicación.

La verdad que aún no acabé de leerme el manual de C++ pero no podía esperar para ver que realmente podía compilar una.dll y que funcionara, aunque ni idea del código (pero no es muy largo).

Y también me descargué el visual C++, ya que el Dev-C++ no funcionaba no sé porque.

Bueno por si alguien está pensando en hacer.dll para Blitz3d, pues ya tiene por dónde empezar con el archivo adjunto y el enlace.

Por cierto, con DirectX 9 SDK va perfectamente, no hace falta usar DirectX 7. Saludos.

-- IMÁGENES ADJUNTAS --
https://foro3d.com/attachment.php?attachmentid=157292

Me uno al tema, el cual es algo complicado, como bien sabemos Blitz3d va de la mano con las DirectX 7, esto fuera de ser una pesadilla para los usuarios noveles se desmerita erróneamente pensando que ya no sirve para nada, sin embargo, el fundamento de DirectX 11 son sus anteriores funciones guardadas en sus DirectX, ¿pero por que el cambio? Venga que soy un defensor de Blitz3d, y lo que nos ha jodido mentalmente es ver que las DirectX van adelante con el propósito de aprovechar al máximo el poder de hardware de hoy en día, como tarjetas aceleradoras y todo eso.

Mira, pienso muy subjetivamente que, que hemos caído en la trampa del consumismo y pensamos que los sistemas de videojuegos en la actualidad son solo Shaders cosas que ni siquiera comprendo porque solo soporta tarjetas Nvidia 9500 donde se puede correr GTA v, pero pienso que antes de explorar y ahondar temas más, allá de lo que ofrece Blitz3d estaría mejor profundizar en los comandos de Blitz3d y de sacarle el mejor provecho e intentar hacer algo, pues eso de programar en visual Studio con el SDK es algo que nos va a cortar la productividad, y es que no sé hasta dónde deseas llegar con esto, pero mi consejo y con sinceridad es que profundizs en Blitz3d a grado cabal pues está realizado para personas de a pie como nosotros y ya lo de DirectX para los eruditos en estudios de universidades y todo eso que al crear programas nos hacen la vida más fácil. Un saludo y creo que no he dicho nada que sirva de algo.

Hola, pues lo que pretendo hacer con DirectX es lograr los mismo efectos que hago con los comandos de Blitz3d, y otros nuevos efectos como sombras realistas, efecto de desenfoque, y todo efecto que se me pueda ocurrir.

Lo bueno de hacerlo con la.dll por lo que tengo entendido es que va mucho más rápido el procesado, y ahorras fps, estoy en lo cierto?

Lo de rápido depende, de cómo se implemente pues se está haciendo un puente entre Blitz3d para uso de las otras versiones de DirectX, si te fijas en shadow los efectos Dof, Glow, Bloom, sombras volumétricas se están haciendo en DirectX 7, lo que sucede es que se nos está pasando una función que nos facilita toda la cosa, por ejemplo, crear sombra (ente1), así que, todo es mucho más fácil, sobre la arquitectura y viabilidad tenemos que tomar como partida que el propio Blitz3d es lento pues está en un tercer nivel, por encima de C++, así que, en tal caso antes de dar un paso a para las DirectX, lo más viable que pienso yo, es tomar otro motor gráfico, por ejemplo, Ogre3d. El punto aquí es que de cierta manera Blitz3d nos hace la vida mucho más fácil, pero sus limitaciones de forma aparente nos conllevan a pensar que está como quedado, es el caso de Unity donde se promociona los efectos de luz en un molino y física de telas, cuando eso ya se podía hacer en Blitz3d, debido a que usuarios experimentados ya han creado (*.dll) para ese fin o cosas como esas.

Mira te pasaré un código que es esencial entender, como verás la velocidad de una aplicación es determinado por un conjunto de factores, como son velocidad de procesador, aceleradora 3d, memorias, velocidad de transferencia y etc.

Pero cuando se realiza una aplicación a veces nos sentimos frustrados por que como que esto va muy lento, y resulta que no hemos realizado nosotros las cosas bien, ok aquí va el código.

Código:

---

While not keyhit(1) trepeat : elapsed = millisecs() - Time : until elapsed tticks = elapsed / period ttwen# = float(elapsed mod period) / float(period) tfor k=1 todo ticks time = time + period if que = ticks then captureworld updateobjects, movimiento de entidades updateworld tnext trenderworld twen# ttext 10, 10, fps() tflip 0.
Wend.

---

Lo anterior implica que en el bucle principal de la aplicación dentro del for. Next se mete los movimientos de los objetos, entidades y sin importar los recursos del sistema la aplicación se acomoda para dar movimientos suaves, lo que quiero decir es que Blitz3d no es lento pues es tecnología realmente madurada con los años, otra cosa es si intentas hacer algo con DirectX 10 la lentitud te cagara el PC, pues para eso se necesita ciertos recursos de hardware y lo más importante experiencia.

Algo más para agregar es que entre más poderosa sea la máquina un juego puede ir más rápido, pero en exceso, es decri en tu ordenador un cubo puede estar girando muy bien, pero en un procesador de doble núcleo el cubo va mucho más rápido y esto no es viable, y en una máquina más lenta el cubo se mueve más lento, no sé qué más agregar, pero si deseas aprender DirectX, yo recomendaría pasarte a otro motor que cumpla esas expectativas y que nos facilitan la vida pues traen un montón de funciones como crear_sombra y listo todo arreglado. Un saludo.

Edito: algo para pensar : a los verdaderos artistas no se los mide por su herramientas, por sus tarros de pintura, sus pinceles o brochas, por el papel donde plasmaron su obra, se miden por el resultado de su trabajo, así que, sigue con Blitz3d y profundiza en el, yo buscaré un motón de ejemplos que tengo en Blitz3d usando libs externas, pero no centrándose en ellas y te los pasaré.

Muchas gracias por toda la información Blitz3d. El tema del renderizado por fases, con twen, lo conocía y de hecho lo uso normalmente en la mayoría de juegos.

Pero la duda que yo tenía, es que un código echo con el propio lenguaje de Blitz3d, ira más lento que el mismo código echo en una.dll, o ¿no?
Yo pienso que ira más lento por lo que tú has dicho, que la (*.dll) es lenguaje de bajo nivel.

Por ejemplo, yo se hacer un efecto de blur con sprites desde Blitz3d, pero me quita casi la mitad de fps.

Pienso que si logro hacerlo desde una dll, ahorraría frames por segundo y podría poner más efectos y no estar tan limitado, por eso mismo estoy investigando con C++ y DirectX.

Tu que crees sobre eso?
Posdata: muchas gracias por el programa shadermap, lo estoy probando ahora y está muy bien.

http://blitzmirror, ueuo.com/ en esta web encontraras libs para Blitz3d. Las libs le dan cierta funcionalidad a Blitz que no pose, y al hacer el ingerto ira más lento debido a que las funciones se pasan de bajo nivel a alto nivel, sin embargo, debemos tener en cuenta que la velocidad es predeterminad como mencione por un gran número de factores, es diferente manejar un modelo de 50.000 polígonos en Blitz que hacerlo directamente en DirectX, hablo de mi experiencia, pues si metes un cubo para una caja, va lo más de bien, ya si la caja necesita texturas con dot3d, también ira bien, ahora queremos que tenga sombra, shadowmap? O sombras volumétricas? Eso depende de cómo implementemos las cosas, de no renderizar lo que no se visualiza, por ejemplo, el nivel anterior que se paso es innecesario tenerlo en la memoria, o el túnel que el protagonista dejo atrás, así que, es bueno usar ntityautofade o hidentity etc.

Lo que te dijo no es que sea un erudito en el tema, sin embargo, es mi propio punto de vista. Un saludo.

Edito: sobre el fps, te comento que en el vídeo del molino, me va a 18 o 15 frames por segundo cuando pongo Bloom y todo eso, pero con la técnica anterior se ve los más de bien, es decri el usuario no se fija en eso, lo que necesita es que le ande bien la cosa en su ordenador.

No sé si a esto te refieres con sombras realistas en Blitz3d.

Archivo adjunto 158107

-- IMÁGENES ADJUNTAS --
https://foro3d.com/attachment.php?attachmentid=158107

Me refiero al tipo de sombras que usa la librería shadow. En una explicación que habías dado, dijiste que había dos tipos de sombra, las ortográficas y las volumétricas.

Las ortográficas se hacerlas porque son muy fáciles, pero aún sabiendo hacerlas las frames por segundo se bajan mucho debido a que hay que renderizar todo a una textura.

Y las otras creo que es calculando un volumen para la geometría y calculando las interseciones con las mallas que reciben la sombra para dibujar la textura, creo que es así por lo que deduzco, pero quiero aprender a hacer eso con una librería.

Vale, ya te paso un ejemplo en Blitz de sombras volumétricas. Edito: mira lo de la bajada del frames por segundo no interesa mucho si usas la técnica del tew, donde, aunque el frames por segundo decienda no afecta la suavidad de los movimientos.

Como mencione en el ejemplo del molino, el frames por segundo va a 15 18, con todo activado, si no usara ese técnica todo se relentiza.

Ya voy con el ejemplo.

Sombras cartográficas, no sé de dónde sacan que ortográficas.

Código:

---

Attempt at explaining directional shadows.

Kevin laherty (kalisme@hotmail.com).

This is mearly a re-reléase of a pseudo-tutorial i released ages ago.

I refur todo this as a pseudo-tutorial because im actually quite.

Concerned that ;this Will sem like total utter jibberish.

Since im horrible at explaining things.

This is based of code that someone posted in a forum.

A few years hago (great learning material).

I dont know his name, but if you know who im talking about.

Por favor inform me, he deserves alot of credit.

Anywho, this code casts a directional shadow from a caster entity.

Onto a receiver entity. It may not be the most stunning style.

Of casting shadows, but it quite fast (when coded right).

And sems todo blend quite well into a Blitz3d Game Engine.

I hope i help at least one person and someone uses it todo.

Fancy-up a game.

This was a los the basis of my shakal library i was working on.

A long time ago. (if anyone remembers it).

Graphics3d 800,600.

Setbuffer backbuffer().

Ambientlight 0,0,0.

Ssize:
The size of the shadows texture.
(Remember todo use base 2, eg: 2 4 8 16 32 64 128 256 512).

Make sure it smaller than the games resolution.

Eg: you cant render a 512 por 512 map on a 320 por 240 screen.

Global ssize=64.

Global shadow_tex=createtexture (ssize, ssize,16+32) ;create the shadow texture.

Xscale:
Lets say the default zoom the shadow Camera is 1.(it actually.06, but 1 sounds easyier).

So if xscale = 1, the zoom = 1/xscale# = 1.

But if xscale is smaller than 1 it Will make the Camera zoom in more.

It hard for me todo explain, play with it, youll get it in time.

Global xscale#=1*(.8/4).

Creating and setting up the shadow rendering Camera.

Shadowcam=createcamera ().

Cameraviewport shadowcam,0,0, ssize, ssize ;the viewport the shadows Will be rendered though.

Cameraclscolor shadowcam,255,255,255 ;yup, white background for shadow textures.

Cameraprojmode shadowcam,2 ;orthographic view, lo siento, ive only figured out very simple directional shadows.

Camerazom shadowcam.06/xscale# ;though the function shadow_test does this every time it used, here it is for you todo se anyway. It not neded here.

Camerafogmode shadowcam,1 ;the Fog is put on so it sems like everythings white, todo make a caster visable todo the Camera, disable fogging todo that object.

Camerafogrange shadowcam,1,1.

Camerafogcolor shadowcam,255,255,255.

Hideentity shadowcam ;we dont want it onscren now.

Just setting up the scene========
Camera=createcamera () ;<-the game Camera.

Positionentity Camera,0,5,-15.

Scene=createsphere () ;<-later used as the receiver.

Scaleentity scene,20,1,20.

Caster=createcone () ;<-the object that shall cast a shadow.

Updatenormals caster.

Entityshininess caster. 2.

Entitycolor caster,200,0,0.

Rotateentity caster,40,90,60.

Positionentity caster, 0,2,0.

Scaleentity caster, 1,2,1.5.

Light=createlight(2) ;<-the light source.

Vis_light = createsphere (12, light) ;<-sphere used todo make the light source visable.

Entitycolor vis_light,0,200,0.

Entityfx vis_light,1.

Positionentity light,-20,8,-1.
=================================
Placing the shadow texture onto the receiver.

But if you make a shadow lib for a game.

Youll probably want this in the actual function, not here.

Entitytexture scene, shadow_tex.

Main loop============================================
While quit=0 tcls tmoveentity light,0,0,1:turnentity light,0,-5,0 ;a rotating light source. Much more intresting tturnentity caster,0,0.5 trenderworld tupdateworld tif keyhit(1) then quit=1 tshadow_test(shadowcam, Camera, light, caster, scene) ;<- Our function ttext 500,10,xscale#: + xscale# ttext 500,20,zoom: +.06/xscale# ttext 300,30,hit <- & -> todo change the xscale# tflip tif keyhit(203) then xscale#=xscale#*.8 tif keyhit(205) then xscale#=xscale#*1.2.
Wend.

End.
=====================================================
Shadow_test function:
I made this todo help explain the how the real magic is done.

Used like so:
Shadow_test(s_camera, g_camera, s_light, s_caster, s_receiver).
>s_camera.

The shadow Camera used todo render the shadows.
>g_camera.

The in game Camera used todo render the game.
>s_light.

The light source.
>s_caster.

The object that shadows are casted from.
>s_receiver.
Where the shadows Land onto.

Function shadow_test(s_camera, g_camera, s_light, s_caster, s_receiver) tcamerazom s_camera.06/xscale# ;<-setting up the zoom for the shadow rendering Camera tcleartexture (shadow_tex) ;<- I added this because alot of graphics cards sem todo render Fog diferant todo mine, hopefully this fixes the blurring problem thideentity g_camera ;the in game Camera must be hidden tshowentity s_camera ;and the shadow Camera must become visable tentityfx s_caster,1+8 ;<- Setting up the caster:
Entitycolor s_caster,0,0,0 ;it neds todo be black and unnefexted by Fog and lights t.

The shadow rendering Camera must be placed at.

The light source then pointed at the caster tpositionentity s_camera,entityx(s_light,1),entityy(s_light,1),entityz(s_light,1) tpointentity s_camera, s_caster t.

Here we render the Camera and convert it todo a texture trenderworld() tcolor 255,255,255: rect 0,0, ssize, ssize,0 ;<-this rectangle is used todo Cull anything that tries todo poke outside of the textures boundry box tcopyrect 0,0, ssize, ssize,0,0,backbuffer(),texturebuffer(shadow_tex) t.

The surface and verticy loop.

This loops th rouge every surface of the receiver Mesh.

Then every surfaces vertecies.

Our main focus should be the.

Tformpoint and vertextexcords commands.

These commands actually Paint the texture onto the.

Receiver correctly tfor s=1 todo countsurfaces(s_receiver) surf=getsurface (s_receiver, s) for v=0 todo countvértices(surf)-1 tformpoint vertexx(surf),vertexy(surf),vertexz(surf), s_receiver, s_camera vertextexcords surf, (tformedx()/xscale#)/32+0.5,1-((tformedy()/xscale#)/32+.5) next tnext t.

Here we just switch the attributes of the caster bak todo normal.

In an actual Game Engine you might have todo make this more complex.

I suggest keping the old attributes in tempory memory then.

Calling them bak at about this point tentityfx s_caster,0 tentitycolor s_caster,200,0,0 t.

Here we hide the shadow Camera and bring bak the game Camera.

Ready todo go bak todo the main game loop like nothing ever happend tshowentity g_camera thideentity s_camera t.

End function.

This last Little function Holds no real importance, it just clears a texture and makes it white.

I added this because when i first released this code i found alot of graphics cards dont make.

The Fog as thik as mine (im guessing it because my card it cheap), and the shadow texture.

Grabbed the old shadow texture of the Ground and blurred with the new one.

Very annoying and unpretty. Oh well. Hope this works much better.

Function cleartexture (TeX) tsetbuffer texturebuffer(TeX) tcolor 255,255,255 trect 0,0,texturewidth(TeX)+1,textureheight(TeX)+1 tsetbuffer backbuffer().

End function

---

Actualización de sombras cartográficas.

Código:

---

Type shadow tfield obj tfield shwtexsize tfield shwtex tfield shwinit t.

End type.

Graphics3d 1024,768,32,2.

Setbuffer backbuffer().

Ambientlight 0,0,0.

Global xscale#=1*(.8/2).

Shadowcam=createcamera ().

Cameraprojmode shadowcam,2.

Camerafogmode shadowcam,1.

Camerafogrange shadowcam,1,1.

Camerafogcolor shadowcam,255,255,255.

Hideentity shadowcam.

Local Camera=createcamera () ;<-the game Camera.

Positionentity Camera,0,5,-15.

Scene=createsphere () ;<-later used as the receiver.

Local scene=createcube () ;<-later used as the receiver.

Scaleentity scene,20,1,20.

Positionentity scene,0,-1,0.

Local idscene. Shadow = sw_addobject(scene).

Local caster=createcone (32) ;<-the object that shall cast a shadow.

Positionentity caster, 0,3,0.

Rotateentity caster,40,90,60.

Scaleentity caster, 1,2,1.5.

Updatenormals caster.

Entitycolor caster,200,0,0.

Local idcaster. Shadow = sw_addobject(caster).

Local caster1=createsphere (32) ;<-the object that shall cast a shadow.

Positionentity caster1,0,1,0.

Entitycolor caster1,0,0,200.

Updatenormals caster1.

Local idcaster1. Shadow = sw_addobject(caster1).

Local light=createlight(2) ;<-the light source.

Local vis_light = createsphere (12, light) ;<-sphere used todo make the light source visable.

Entitycolor vis_light,0,200,0.

Entityfx vis_light,1.

Positionentity light,-20,8,-1.
=================================
While quit=0 t;===> tif keyhit(1) then quit=1 tif keyhit(203) then xscale#=xscale#*.9 tif keyhit(205) then xscale#=xscale#*1.1 t;===> tsw_resetshadow(), t;===> tmoveentity light,0,0,0.25:turnentity light,0,-1.25,0 ;a rotating light source. Much more intresting tturnentity caster,0,0.5 tupdateworld tshadow_test1(shadowcam, Camera, light,idcaster,idscene) ;<- Our function tshadow_test1(shadowcam, Camera, light,idcaster1,idscene) ;<- Our function tshadow_test1(shadowcam, Camera, light,idcaster,idcaster1) ;<- Our function trenderworld() t;===> ttext 500,10,xscale#: + xscale# ttext 500,20,zoom: +.06/xscale# ttext 300,30,hit <- & -> todo change the xscale# tflip t;===>.
Wend.

End.
=====================================================
Function shadow_test1(s_camera, g_camera, s_light, caster. Shadow, s_receiver. Shadow) t;===> t;stop t;===> thideentity g_camera ;the in game Camera must be hidden tshowentity s_camera ;and the shadow Camera must become visable t;===> tif s_receiver\shwinit=true then cameraclsmode s_camera, false, true telse cameraclsmode s_camera, true, true s_receiver\shwinit = true tendif t;===> tlocal tsize = s_receiver\shwtexsize t;===> tcameraclscolor s_camera,255,255,255 tcamerazom s_camera.06/xscale# ;<-setting up the zoom for the shadow rendering Camera tcameraviewport s_camera,0,0,tsize,tsize ;the viewport the shadows Will be rendered though tcameraprojmode s_camera,2 ;orthographic view, lo siento, ive only figured out very simple directional shadows t;===> tsw_hideobject() t;===> tlocal s_caster=copyentity(caster\obj) tentityfx s_caster,1+8 ;<- Setting up the caster:
Entitycolor s_caster,0,0,0 ;it neds todo be black and unnefexted by Fog and lights tshowentity s_caster t;===> tpositionentity s_camera,entityx(s_light,true),entityy(s_light,true),entityz(s_light,true) tpointentity s_camera, s_receiver\obj trenderworld() t;===> tcopyrect 0,0,tsize,tsize,0,0,backbuffer(),texturebuffer(s_receiver\shwtex) t;===> tlocal curobj = s_receiver\obj tfor s=1 todo countsurfaces(curobj) local surf=getsurface (curobj, s) for v=0 todo countvértices(surf)-1 tformpoint vertexx(surf), vertexy(surf), vertexz(surf), curobj, s_camera vertextexcords surf, (tformedx()/xscale#)/32+0.5,1-((tformedy()/xscale#)/32+.5) next tnext t;===> tsw_showobject() t;===> tshowentity g_camera thideentity s_camera tfreentity s_caster t;===> t.

End function.

Function sw_addobject. Shadow(obj) tlocal sw_size = 512 tlocal curmodel. Shadow = new shadow tcurmodel\obj = obj tcurmodel\shwinit = false tcurmodel\shwtex = createtexture (sw_size, sw_size, 16+32) tcurmodel\shwtexsize = sw_size tentitytexture curmodel\obj,curmodel\shwtex t;===> tsetbuffer(texturebuffer(curmodel\shwtex)) tclscolor 255,64,255 tcls tsetbuffer(backbuffer()) t;===> treturn curmodel.

End function.

Function sw_resetshadow() tlocal curmodel. Shadow tfor curmodel=each shadow curmodel\shwinit = false tnext.

End function.

Function sw_hideobject() tlocal curmodel. Shadow tfor curmodel=each shadow hideentity curmodel\obj tnext.

End function.

Function sw_showobject() tlocal curmodel. Shadow tfor curmodel=each shadow showentity curmodel\obj tnext.

End function.

---

Ahora las volumétricas, un tantico.

Una nota, si se trata de rendimiento las volumétricas consumen mayores recursos, pero si tienes una máquina de doble núcleo y tarjeta aceleradora 3d de última generación sin problemas, pero como la idea es que corra en todas las máquinas posibles lo mejor es usar mapas de sombras dínamicos o estáticos.

Sombras volumetricas, si ves el ejemplo te parecerá familiar (shadow).

Código:

---

Graphics3d 1024, 768, 32, 2. Setbuffer backbuffer().

Globs.

Dim edge#(65000, 7).

Camera.

Cam = createcamera ().

Caster.

Cube = createsphere ().

Positionentity Cube, 0, 0, 7.

Light.

Light = createlight().

Positionentity light, 3, 3, 7.

Pointentity light, Cube.
While not keyhit(1) tturnentity Cube, 1. 5, 1.5 tvol = createvolume (Cube, light) trenderworld tfreentity vol tflip.
Wend.

End.

Function createvolume (model, light, volume_lenght = 1000000).

Volumemesh = createmesh().

Volumesurface = createsurface (volumemesh).

Entityalpha volumemesh. 5.

Entitycolor volumemesh, 255, 0, 0.

Entityfx volumemesh, 1.

Light_x# = entityx(light).

Light_y# = entityy(light).

Light_z# = entityz(light).

For n = 1 todo countsurfaces(model) tsurf = getsurface (model, n) tdwnumfaces = counttriangles(surf) - 1 tfor v = 0 todo dwnumfaces vert0 = trianglevertex(surf, v, 0) vert1 = trianglevertex(surf, v, 1) vert2 = trianglevertex(surf, v, 2) tformpoint vertexx(surf, vert0), vertexy(surf, vert0), vertexz(surf, vert0), model, 0 v1_x# = tformedx() v1_y# = tformedy() v1_z# = tformedz() tformpoint vertexx(surf, vert1), vertexy(surf, vert1), vertexz(surf, vert1), model, 0 v2_x# = tformedx() v2_y# = tformedy() v2_z# = tformedz() tformpoint vertexx(surf, vert2), vertexy(surf, vert2), vertexz(surf, vert2), model, 0 v3_x# = tformedx() v3_y# = tformedy() v3_z# = tformedz() a_x# = v3_x# - V2_x# a_y# = v3_y# - V2_y# a_z# = v3_z# - V2_z# bb_x# = v2_x# - V1_x# bb_y# = v2_y# - V1_y# bb_z# = v2_z# - V1_z# norm_x# = a_y# * bb_z# - A_z# * bb_y# norm_y# = a_z# * bb_x# - A_x# * bb_z# norm_z# = a_x# * bb_y# - A_y# * bb_x# normlight_x# = (v1_x# + v2_x# + v3_x#) / 3 - Light_x# normlight_y# = (v1_y# + v2_y# + v3_y#) / 3 - Light_y# normlight_z# = (v1_z# + v2_z# + v3_z#) / 3 - Light_z# if (norm_x# * normlight_x# + norm_y# * normlight_y# + norm_z# * normlight_z#) * (1.0 / float(sqr(norm_x# * norm_x# + norm_y# * norm_y# + norm_z# * norm_z#))) * (1.0 / float(sqr(normlight_x# * normlight_x# + normlight_y# * normlight_y# + normlight_z# * normlight_z#))) => 0 then Edge (cntfront, 0) = surf Edge (cntfront, 1) = Tri Edge (cntfront, 2) = v1_x# Edge (cntfront, 3) = v1_y# Edge (cntfront, 4) = v1_z# Edge (cntfront, 5) = v2_x# Edge (cntfront, 6) = v2_y# Edge (cntfront, 7) = v2_z# cntfront = cntfront + 1 Edge (cntfront, 0) = surf Edge (cntfront, 1) = Tri Edge (cntfront, 2) = v2_x# Edge (cntfront, 3) = v2_y# Edge (cntfront, 4) = v2_z# Edge (cntfront, 5) = v3_x# Edge (cntfront, 6) = v3_y# Edge (cntfront, 7) = v3_z# cntfront = cntfront + 1 Edge (cntfront, 0) = surf Edge (cntfront, 1) = Tri Edge (cntfront, 2) = v3_x# Edge (cntfront, 3) = v3_y# Edge (cntfront, 4) = v3_z# Edge (cntfront, 5) = v1_x# Edge (cntfront, 6) = v1_y# Edge (cntfront, 7) = v1_z# cntfront = cntfront + 1 endif tnext.

Next.

For a = 0 todo cntfront tif Edge (a, 0) > 0 then diverso = true p0_x# = Edge (a, 2) p0_y# = Edge (a, 3) p0_z# = Edge (a, 4) p1_x# = Edge (a, 5) p1_y# = Edge (a, 6) p1_z# = Edge (a, 7) for b = a + 1 todo cntfront p0_2_x# = Edge (b, 2) p0_2_y# = Edge (b, 3) p0_2_z# = Edge (b, 4) p1_2_x# = Edge (b, 5) p1_2_y# = Edge (b, 6) p1_2_z# = Edge (b, 7) if Edge (b, 0) > 0 then if (p0_x# = p0_2_x# and p0_y# = p0_2_y# and p0_z# = p0_2_z# and p1_x# = p1_2_x# and p1_y# = p1_2_y# and p1_z# = p1_2_z#) = false then if p0_x# = p1_2_x# and p0_y# = p1_2_y# and p0_z# = p1_2_z# and p1_x# = p0_2_x# and p1_y# = p0_2_y# and p1_z# = p0_2_z# then Edge (a, 0) = surf = 0 Edge (b, 0) = surf = 0 diverso = false exit endif endif endif next if diverso then pe0_x# = p0_x# - Light_x# pe0_y# = p0_y# - Light_y# pe0_z# = p0_z# - Light_z# do# = 1.0 / float(sqr(pe0_x# * pe0_x# + pe0_y# * pe0_y# + pe0_z# * pe0_z#)) pe0_x# = pe0_x# * do# * volume_lenght + p0_x# pe0_y# = pe0_y# * do# * volume_lenght + p0_y# pe0_z# = pe0_z# * do# * volume_lenght + p0_z# pe1_x# = (p1_x# - Light_x#) * volume_lenght + p1_x# pe1_y# = (p1_y# - Light_y#) * volume_lenght + p1_y# pe1_z# = (p1_z# - Light_z#) * volume_lenght + p1_z# va = addvertex(volumesurface, p0_x#, p0_y#, p0_z#) vb = addvertex(volumesurface, pe1_x#, pe1_y#, pe1_z#) addtriangle (volumesurface, va, addvertex(volumesurface, pe0_x#, pe0_y#, pe0_z#), vb) addtriangle (volumesurface, va, vb, addvertex(volumesurface, p1_x#, p1_y#, p1_z#)) Edge (a, 0) = 0 endif tendif.

Next.

Return volumemesh.

End function

---

Lo importante aquí comprender es que Blitz3d es como un automóvil de ciudad, tiene un fin que es transportarnos, pero el problema es cuando lo comparamos con un formula uno, y nos machacamos los huevos pensando que el otro es mejor, pero si bien es cierto que es fácil de manejar, toco profundizar en ciertos temas.

Bueno no sé qué más decir, usa la técnica del tewwn y el capturaworld por dios. Un saludo.

Blitz3d te enseña a pensar cómo programador y no ser un usuario de software de desarrollo.

Blur motion.

Código:

---

14 real-time 3d Motion Blur FX presets by Matt merkulov. The size of a structure, number of effect, the order of a portrayal(-1 or 1).

Const texsize=1024, FX=7, o =-1.

Graphics3d 800,600,32.

Cam=createcamera ().

Positionentity Cam, 0,0,-6.

Rotateentity createlight(), 45,0,0.

Creation of a stage.

Cube=createcube ().

Entitycolor Cube, 255,128,0.

Cone1=createcone (20).

Entitycolor cone1,0,255,255.

Positionentity cone1,-4,0,0.

Cone2=createcone (20).

Entitycolor cone2,0,255,0.

Positionentity cone2,4,0,0.

P=createpivot().

Sph=createsphere (20, p).

Positionentity SPH, 0,0,-4.

Select FX tcase 1:bl=createblurlayer(Cam, 1,0,1,1. 95,1, o) tcase 2:bl=createblurlayer(Cam, 1,0,1. 97,1,3, o) tcase 3:bl=createblurlayer(Cam, 1. 2,1.02. 97,1,3, o) tcase 4:bl=createblurlayer(Cam, 1,0,1.01,1. 95,1, o) tcase 5 bl=createblurlayer(Cam, 1,0,1.01,1. 9,1, o) entitycolor bl, 240,255,225 tcase 6 bl=createblurlayer(Cam, 1.1,0,1,1. 95,1, o) rotateentity bl, 1,1,0 tcase 7 bl=createblurlayer(Cam, 1.01,1,1,1. 9,1, o) bl2=createblurlayer(Cam, 1.02,-1,1,1. 8,1, o).

End select.

Setbuffer backbuffer().
While not keyhit(1) tturnentity Cube. 1. 2. 3 tturnentity p. 55. 35. 2 trenderworld tbltex=updateblurlayer(bl, bltex) tif bl2 then entitytexture bl2, bltex tif FX=4 then positionentity bl, rnd(-.01. 01), rnd(-.01. 01), 1 tflip.
Wend.

Function of creation of a layer of the degradation adhered todo the Chamber - Returns the address of a layer.

Function createblurlayer(Cam, z#, ang#, mgn#, bright#, alpha#, bmode, ord) tlocal xres=graphicswidth() tlocal yres=graphicsheight() tlayer=createmesh(Cam) ts=createsurface (layer).

Calculation of coordinates of a structure tvx#= 1.0*xres/texsize tvy#= 1.0*yres/texsize taddvertex,-1,-1,0,0,0 taddvertex, 1,-1,0, vx#, 0 taddvertex,-1,1,0,0, vy# taddvertex, 1,1,0, vx#, vy# taddtriangle, 0,1,2 taddtriangle, 3,2,1.

Definition of sizes for installation of a rectangular directly in front of the Chamber by.

Calculations of screen coordinates of a point of the thre-dimensional world tpositionentity layer, 1,1, z# tcameraproject Cam, entityx(layer, true), entityy(layer, true), entityz(layer, true) trx#= projectedx#()-.5*xres try#= projectedy#()-.5*yres.

Scaling a layer tscalemesh layer. 5*xres/rx#.5*yres/ry#, 1.

Sdlvig a rectangular on polpiksela todo the left-upwards that it(he) was in the center of the screen tpositionentity layer,-.5/rx#,-.5/ry#, z# trotateentity layer, 0,0, ang#.

The tasque of effects of a layer tscaleentity layer, mgn#, mgn#, mgn# tentityalpha layer, alpha# tentityblend layer, bmode tcol=255*bright# tentitycolor layer, col, col, col tentityfx layer, 1 tentityorder layer, ord treturn layer.

End function.

Function of updating of a layer(returns the address of a structure).

It is necessary todo cause each time After renderworld.

Function updateblurlayer(layer, TeX) tif TeX=0 then TeX=createtexture (texsize, texsize) tentitytexture layer, TeX tcopyrect 0,0, graphicswidth(), graphicsheight(), 0,0, backbuffer(), texturebuffer(TeX) treturn TeX.

End function.

---

Si perdona me confundí con lo de ortográficas. Bueno gracias por los códigos,) en un rato los investigo y a ver qué saco.

Edito: (ya los conocía los 3 códigos del otro hilo, pero gracias igualmente sobre todo por recordarme las volumétricas, a ver si logro algo con las DirectX o no).

Agua.

Código:

---

Lobal fxwater_max = 5 ;max number of active surfaces/effects at one time. Global fxwater_num = 0 ;current number of active water effects.

Global fxwater_max_width = 100 ;max sub-división for water meshes.

Global fxwater_max_depth = 100 ;max sub-división for water meshes.

Global fxwater_max_banks = fxwater_max * 2.

Global fxwater_num_banks = 0.

Global demo_water_width = 40 ;--> adjust these for diferent plane sizes / Mesh resolution.

Global demo_water_depth = 40.

Reserve memory banks for vértice altitudes.

Dim fxwaterbank#(fxwater_max_banks, fxwater_max_width, fxwater_max_depth).

Type fxwaterwave tfield id tfield name$ tfield active ;if not ripples then FX is not actiave tfield parent ;parent entity (if any) tfield entity ;water Mesh tfield surface ;water surface tfield bank1 ;pointers todo array for mem estorage tfield bank2 tfield width ;width of plane / surface tfield depth ;depth of plane / surface tfield dampening# ;water dynamics t.

End type.

Demo options.

Global opt_wireframe = 0.

Global opt_refrsh = 0.

Global opt_ballfreze= 0.

Global opt_ceiling = 1.

Graphics3d 640,480,32,1.

Graphics3d 640,480,0,2.

Camera + light.

Global campivot = createpivot().

Global Camera = createcamera (campivot).

Positionentity Camera, 0, 0, -35.

Pointentity Camera, campivot.

Light = createlight(2).

Positionentity light,-60,0,100.

Lightcolor light,240,240,210.

Pointentity light, campivot.

Light = createlight(2).

Positionentity light,50,0,-50.

Lightcolor light,150,150,180.

Pointentity light, campivot.

Ambientlight 40,40,40.

Load texture.

Tex = loadtexture (water, (*.tga),1+64).

Tex = create_noise_map().

Create water planes.

Global w1 = fxwater_create (flor, demo_water_width, demo_water_depth, 0.025).
Water = fxwater_get_entity(w1).

Positionentity water, 0, -10, 0.

Entitycolor water, 30,50,200.

Entityshininess water, 0.1.

Entitytexture water, TeX.

Global w2 = fxwater_create (ceiling, demo_water_width, demo_water_depth, 0.025).
Water = fxwater_get_entity(w2).

Flipmesh water, flip it because the Camera is underneath it.

Positionentity water, 0, 10, 0.

Entitycolor water, 250,100,100.

Entitycolor water, 140,130,20.

Entityshininess water, 0.1.

Entitytexture water, TeX.

Force refresh.

Fxwater_dimple (w1, 1,1, 0.001, 0.001).

Fxwater_dimple (w2, 1,1, 0.001, 0.001).

Set random ball direction/speed.

Global bx#= 0.2.

Global by#= -1.75.

Global bz#= -0.25.

Global bmaxx# = demo_water_width * 0.5 ;half the width of the water plane.

Global bmaxy# = 10.0.

Global bmaxz# = demo_water_depth * 0.5 ;half the depth of the water plane.

Create ball.

Ball = createsphere (6).

Entitycolor ball, 0,0,0.

Entityshininess ball, 1.0.

Entitytexture ball, TeX.

Sedrnd millisecs().

Main loop.

Tstart = millisecs() + 1000.

Frame = 0.

Global lastx# = 0.

Global lasty# = 0.

Global lastz# = 0.

Tim = createtimer(50).

L$ = wavywaterfx by Danny van der ark.
While not keyhit(1) t;update bouncing ball tupdate_ball(ball) t;update fxwater tfxwater_update () t;render.

Updateworld.

Renderworld t;debug tcolor 000,000,000 ttext 2,1, l$ tcolor 255,255,255 ttext 2,0, l$ tcolor 100,100,100 ttext 2,12, based on samples from reda borchardt and rob cummings tcolor 20,140,255 ttext 2,454, [esc] todo kit - [d] for fast but Dirty refresh( + opt_refresh + ) - [w] todo toggle wireframe ( + opt_wireframe + ) ttext 2,466, [p] todo pause - [b] todo pause/reset ball - [c] todo toggle ceiling tcolor 250,250,220 ttext 10,220,fps + frames por segundo ttext 10,232,tris + trisrendered() t;orbit Camera t;turnentity campivot, 0, 0.25, 0 t;chek frames por segundo tframe = frame + 1 tif millisecs() >= tstart then frames por segundo = frame frame = 0 tstart = millisecs() + 1000 tendif t;toggle ceiling [c] tif keyhit(46) then opt_ceiling = 1 - Opt_ceiling if opt_ceiling then water = fxwater_get_entity(w2) showentity water else water = fxwater_get_entity(w2) hideentity water endif tendif t;pause all [p] tif keyhit(25) then flushkeys while not keyhit(25) wend tendif t;pause ball [b] tif keyhit(4 then opt_ballfreze = 1 - Opt_ballfreze if opt_ballfreze then positionentity ball, 0,0,0 bx# = 0 by# = 0 bz# = 0 else bx#=rnd#(-1,1) by#=rnd#(-2,2) bz#=rnd#(-1,1) endif tendif t;wireframe [w] tif keyhit(17) then opt_wireframe = 1 - Opt_wireframe wireframe opt_wireframe tendif t;Dirty refresh [d] tif keyhit(32) then opt_refresh = 1 - Opt_refresh tendif t;chek refresh mode tif opt_refresh then ;fast and Dirty (pot nodle style) flip false telse ;Slow but clean flip true waittimer(tim) tendif tif mousehit(1) then x = rnd(1,demo_water_width) z = rnd(1,demo_water_depth) fxwater_dimple (w1, x, z, 1, 5) tendif.
Wend.

End.

Function update_ball(ent) t;move the ball ttranslateentity Ent, bx, by, bz tdodimple = false t;chek left/right Walls tif entityx#(ent) > bmaxx-2 then bx# = bx# * -1 tif entityx#(ent) < -bmaxx+2 then bx# = bx# * -1 t;chek ceiling bounce tif entityy#(ent) > bmaxy-2 then ;reverse vertical direction by# = by# * -1.0 ;create dimple fxwater_dimple (w2, entityx(ent)+bmaxx,entityz(ent)+bmaxz, -1.0, 5.0) ;slightly alter direction bx# = bx# + rnd#(-0.25, 0.25) bz# = bz# + rnd#(-0.25, 0.25) tendif t;chek flor bounce tif entityy#(ent) < -bmaxy+2 then ;reverse vertical direction by# = by# * -1.0 ;create dimple fxwater_dimple (w1, entityx(ent)+bmaxx,entityz(ent)+bmaxz, 1.0, 5.0) ;slightly alter direction bx# = bx# + rnd#(-0.25, 0.25) bz# = bz# + rnd#(-0.25, 0.25) tendif t;chek front/bak Walls tif entityz#(ent) > bmaxz-2 then bz# = bz# * -1 tif entityz#(ent) < -bmaxz+2 then bz# = bz# * -1 t.

End function.

Function fxwater_create (name$=, width=1, depth=1, Damp#=0.01, parent=0) t t;create new wavy water effect plane tw.fxwaterwave = new fxwaterwave tw\id = 1 tw\nAme$ = name$ tw\active = true t;create rectangular grid Mesh tw\width = width tw\depth = depth tw\dampening#= 1 - Damp# tw\parent = parent tw\entity = create_mesh_plane (w\width, w\depth, false, parent) tw\surface = getsurface (w\entity,1) t;estore handle for quik retrieval during collision tnameentity w\entity, handle (w) t;reserve memory banks todo hold vertex energy tw\bank1 = fxwater_create_buffer() tw\bank2 = fxwater_create_buffer() t;return Mesh handle treturn handle (w) t.

End function.

Function fxwater_update () tfor w.fxwaterwave = each fxwaterwave t ;if the surface is perfectly flat then this value remains 0 dyna# = 0 t ;process water for x = 1 todo w\width-1 for z = 1 todo w\depth-1 fxwaterbank#(w\bank2,x, z) = (fxwaterbank#(w\bank1,x-1, z) + fxwaterbank#(w\bank1,x+1, z) + fxwaterbank#(w\bank1,x, z+1) + fxwaterbank#(w\bank1,x, z-1)) / 2.1-fxwaterbank#(w\bank2,x, z) fxwaterbank#(w\bank2,x, z) = fxwaterbank#(w\bank2,x, z) * w\dampening# dyna# = dyna# + fxwaterbank#(w\bank2,x, z) next next t ;only deform patch if necesary if dyna# <> 0 then ;patchtransform k=0 for i = 0 todo w\depth for = 0 todo w\width vertexcords(w\surface, k,vertexx(w\surface, k), fxwaterbank#(w\bank2, i),vertexz(w\surface, k)) k=k+1 next next endif t ;should be optional - Depending on type of texture (slows down seriously) updatenormals w\entity t ;swapwaterbuffer tmp = w\bank1 w\bank1 = w\bank2 w\bank2 = tmp tnext t.

End function.

Function fxwater_dimple (hand, x, z, force#=1.0, range#=1.0) tw.fxwaterwave = object, fxwaterwave (hand) tfor xg = x - Range# * 0.5 todo x+range# * 0.5 for zg = z - Range# * 0.5 todo z+range# * 0.5 if xg> 0 and xg < w\width and zg>0 and zg<w\depth then fxwaterbank#(w\bank2, xg, zg) = force# endif next tnext t.

End function.

Function fxwater_get_surface (hand) tw.fxwaterwave = object, fxwaterwave (hand) treturn w\surface t.

End function.

Function fxwater_get_entity(hand) tw.fxwaterwave = object, fxwaterwave (hand) treturn w\entity t.

End function.

Function fxwater_create_buffer(), xsize=1, zsize=1) tif fxwater_num_banks >= fxwater_max_banks then runtimeerror [fxwater:create_buffer] max amount of fxwater memory banks reached telse ;create a new memory banque and resize it todo fit fxwater_num_banks = fxwater_num_banks + 1 ;note: convert array into memory bank tendif treturn fxwater_num_banks t.

End function.

Function fxwater_fre_buffers() t.
| fres all buffers. Call as a part of when scene/level is removed from memory t t;note: resize memory banks todo 0 (once implemented) treturn 0 t.

End function.

Creates a flat grid Mesh.

Function create_mesh_plane (width=1, depth=1, doublesided=false, parent=0) ttot = width + (depth*width) tmix#= (width+depth) * 0.5 tmesh=createmesh(parent) tsurf=createsurface (Mesh) tstx#=-.5 tsty#=stx tstp#=float(1)/float(mix#) ty#=sty# tfor a=0 todo depth x#=stx v#=a/float(depth) t for b=0 todo width u#=b/float(width) addvertex(surf,x,0 y, u) x=x+stp next y=y+stp tnext tfor a=0 todo depth-1 for b=0 todo width-1 v0=a*(width+1)+b:v1=v0+1 v2=(a+1)*(width+1)+b+1:v3=v2-1 addtriangle (surf, 0, 2, 1) addtriangle (surf, 0, 3, 2) next tnext tupdatenormals Mesh tif doublesided=true then entityfx Mesh,16 tfitmesh Mesh, -width*0.5, 0, -depth*0.5, width, 1, depth treturn Mesh t.

End function.

Function create_noise_map() t.

Creates a noise map todo be used as a generic reflection map tsque = 128 ttex = createtexture (sq, sq,65,1) ttbuf = texturebuffer(TeX) tsetbuffer(tbuf) tfor x = 0 todo sq-1 for y = 0 todo sq-1 r = rnd(100,120) g = rnd(100,130) b = rnd(190,240) color R, G, B rect x y,1,1 next tnext tsetbuffer(backbuffer()) treturn TeX t.

End function.

---

Código:

---

Twening const & variables. Const fps=60, si pones 10 todo ira más lento. Global period=1000/fps. Global time=millisecs()-period.

Main loop with classic twening.
While not keyhit(1) trepeat : elapsed = millisecs() - Time : until elapsed tticks = elapsed / period ttwen# = float(elapsed mod period) / float(period) tfor k=1 todo ticks time = time + period if que = ticks then captureworld updategame, si un cubo hace personaje, sus movimientos van aquí.

Junto con enemigos, etc updateworld tnext trenderworld twen tflip 1.
Wend.

---

Ese código de agua fue el que modifiqué para crear la barrera láser de mi último juego. Me costó entenderlo bastante, pero es muy interesante.

Si tienes algo sobre.dll mejor que mejor Blitz3d y gracias por toda la ayuda.

Bueno, lo que te puedo recomendar es usar shadow, o en tal caso una biblioteca llamada devil que hace lo mismo, ya te paso los enlaces.

http://devil-engines, Dev-ch.de/. Encontraras dll, que te dan funciones para crear sombras volumétricas, y un montón de cosas más. Un saludo.

Algo para leer. http://en.wikipedia.org/wiki/shadow_volume#depth_fail. Ha lo olvidada la web oficial de shadow. http://andreyman, ucoz.ru/. Un saludo y todo por hoy.

Sombras simples. (Shadow Map).

http://www.youtube.com/watch?v=k3zhfgazoea Un saludo.

Eso que son sombras cartográficas? O es otro tipo de sombra que no es ni cartográfica ni volumétrica?

Es shadowmap (cartográficas).

Pues ese tipo de sombra lo se implementar, de hecho lo he puesto en varios juegos. Los problemas que tengo con esas sombras son muchos:
Aun usando twenn para renderizar, las frames por segundo bajan mucho.

Las sombras no cubren cualquier distancia, si no que dependen del tamaño de la textura que cubre el escenario, y cuanto más amplia sea la zona, más pixelada queda la sombra.

También solo permiten sombra en una única dirección, como si fuera la luz del sol, por lo que al usar una luz foco no queda realista.

Mira no sé si abras jugado GTA sa, donde las sombras de los coches en nivel de detalle bajo aparecen de esa manera, aquí explica todo sobre este tipo http://en.wikipedia.org/wiki/shadow_mapping.

El caso es que solo se renderiza lo que tenemos en pantalla y solo es cuestión de implementarlas correctamente, ahora bien, si queremos alargar la distancia usamos dos texturas, una para el lumbral más, allá y esta es de menor calidad.

A este tipo de sombra se le puede aplicar blur.

Edito: además ten en cuenta que la cámara sigue al protagonista, y solo se aplica a modelos dinámicos, ya para estáticos podemos usar mapas de sombras estáticos, y usamos el desvanecimiento para otros objetos.

-- IMÁGENES ADJUNTAS --
https://foro3d.com/attachment.php?attachmentid=158123

Sobre el frames por segundo si miras en el video va a 14 Marcos por segundo, sin embargo, me va bien, ya que el fraps baja un poco. http://en.wikipedia.org/wiki/shadow_mapping. http://en.wikipedia.org/wiki/shadow_volume.

Esto es un foco.

-- IMÁGENES ADJUNTAS --
https://foro3d.com/attachment.php?attachmentid=158124

No había yo pensado en lo de usar dos texturas para cerca y lejos. Para una luz del sol o así, está muy bien la solución de usar dos texturas de sombra.

Vale, aquí estoy incrementando la distancia por medio de dos texturas, mañana subo el video para ver qué tal. La primer textura es de máxima calidad y la segunda de mediana, esto incrementa la visibilidad de la textura en gran manera. Un saludo ya mañana subo el video.

-- IMÁGENES ADJUNTAS --
https://foro3d.com/attachment.php?attachmentid=158125

Bueno, anoche me puse a pensar y no puedo ni estoy en el punto de convencerte que las sombras se pueden implementar correctamente, así que, creo que es mejor dejar así, lo que puedo decir es que yo no he tenido problemas y eso que la ordenador de este ciber tiene un procesador de 1.1 AMD y memoria de 256 y una aceleradora de 32.

Ahora bien lo de DirectX sería para trabajar sombras de volúmenes ¿verdad? Si es ese el caso lo más recomendable sería usar las libs antes mencionadas, pues ya tienen todo el listo, o en tal caso pasarse a otro engine donde las sombras son más realistas, como, por ejemplo, UDK, Unity bueno en fin, pero si te sientes capaz de lidiar con C++ y las funciones de DirectX, creo que es un buen punto de partida para entrarse en ese megauniverso de coder.

Así que finalizo con este vídeo.

http://www.youtube.com/watch?v=l7ulfkrejo Un saludo.

http://www.youtube.com/watch?v=fors0wivyf4

Lo que me interesa es meterme en ese superuniverso coder en C++, por lo menos lo voy a intentar, ya que me encanta comprender y fabricar códigos.

Realmente mi objetivo no es crear un juego, si no que mi objetivo es aprender cada vez más y cosas nuevas, y estar pensando continuamente nuevos acertijos, códigos, etc.

Podría ponerme a hacer un nuevo juego en Blitz3d, usando librerías y demás, y seguramente no deje de hacer juegos en Blitz por que es muy relajante. Pero lo que realmente quiero es profundizar más en el tema de programación.

De todas formas, muchas gracias por el tiempo que te estás tomando Blitz3d.

Ok, no problema, de igual forma te deseo suerte en tus metas, por otro lado, te comento que he logrado implementar sombras al estilo GTA IV, con mapas de protuberancias (ruido), mira el vídeo.

http://www.youtube.com/watch?v=uks-xco6stw Un saludo.

Está bueno el video, pero como hiciste? Y el agua sigo sin saber que librería usaste o cómo hiciste ese efecto de textura.

Las sombras son shadowmap (cartográficas) con texturas Bump, el agua es un cubeface con texturas Bump, las cuales muevo con positiontexture y les aplico dot3 en la mezcla, las texturas se mueven en el bucle principal con positiontexture.

Pues si tienes a mano la textura que usas para hacer el blend con dot3, me sería de gran ayuda, aunque me imagino más o menos como será.

Ok ya te la paso.

-- IMÁGENES ADJUNTAS --
https://foro3d.com/attachment.php?attachmentid=158146

Con este programa haces las texturas azules, llamadas normales.

-- IMÁGENES ADJUNTAS --
https://foro3d.com/attachment.php?attachmentid=158148

Pues yo pensaba que para hacer el agua sería mucho más complicado. Bueno tengo que hacer pruebas con todas estas cosas nuevas que me dijiste.

Existe un demo de agua que creo está en la web oficial de Blitz BASIC, donde era un Cube face reflejando, sin embargo, el movimiento de las olas se hace mediante un Mesh dinámico, moviendo sus vértices, si descargas la demo de la web oficial estoy seguro que ese demo viene con esa versión.

Ahora bien el dot3d sirve para emula protuberancias en las paredes, como rocas, ladrillos o cosas como esas.

Bueno retornando al tema de las sombras cartográficas, siempre me he topado con un problema, pero ya le he encontrado solución.

El problema era que las sombras se reflejan por ambos lados de una pared, es decir puedes estar de la pared y al otro lado un personaje que proyecta una sombra y en la pared se veía la sombra del otro lado, algo, así como un cristal, pero la sombra solo la silueta, la solución para esto fue que el modelo de la pared está modelado por grupos y de acuerdo a ángulo de la luz se establece el grupo de las caras que reciben luz y de las que no así que, esto ya está solucionado. Un saludo.

Mira estoy probando con el dot3 y no me funciona el efecto del agua. Tengo un plano. En la capa 0 de textura tengo la textura Bump con modo de mezcla dot3.

En la capa 1 tengo la textura cubemap.

Luego mediante positiontexture muevo la textura dot3 y no funciona.

También probé bajándole el alpha al plano, pero de ninguna manera consigo deformar la textura del cubemap de manera que, parezca una deformación producida por la luz al atravesar el agua.

Yo creo que para hacer ese efecto de deformación de la textura necesitas un shader, es decir, manipular píxeles, no basta con desplazar una textura sobre otra, ya que la textura de abajo sigue conservando sus formas originales, y el efecto que se pretende es que esas formas se modifiquen y se ondulen.

Si puedes poner el código de cómo hiciste, porque no lo consigo.

Sé que hay muchos (o al menos algunos) libros sobre DirectX. De hecho, tengo descargado algunos, pero no recuerdo de dónde lo he sacado.

En algún sitio me descargue todo un pack de libros de matemáticas para videojuegos, direct, C++, y algo de diseño. Ojalá pudiera decirte desde dónde (de todas formas, el enlace seguro que estaba en Megaupload).

Te paso algún título para que puedas buscar por internet o Amazon:
-DirectX 3d graphics programming Bible.

DirectX 8.1 programming for C++.

DirectX 9 graphics - The definitive guide todo DirectX.

Puede que los títulos tengan alguna errata, son copiados a mano, aunque me parece que no.

Muchas gracias por los manuales, sobre todo el último de los 3 que pusiste y, además así me veo obligado a aprender inglés. Pero de momento no puedo dedicarle tiempo al ordenador, pero en cuanto pueda me pongo a ello.