Changeset 555

Show
Ignore:
Timestamp:
05/23/08 05:50:23 (8 months ago)
Author:
LeoD
Message:

combining the terrain's lightmap and fog of war textures into one texture

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/run/data/shaders/model-pixel.glsl

    r551 r555  
    2424#if defined(OBJECTS_LIGHTMAP) 
    2525    vec4 light = texture2D(lightTexture, vec2(gl_TexCoord[1])); 
    26     gl_FragColor *= light; 
     26    gl_FragColor *= light * 2; 
    2727#endif 
    2828     

  • trunk/run/data/shaders/modelGlow.cfg

    r552 r555  
    1 pixel_shader = "modelglow-pixel.glsl" 
    2 vertex_shader = "modelglow-vertex.glsl" 
     1pixel_shader = "modelGlow-pixel.glsl" 
     2vertex_shader = "modelGlow-vertex.glsl" 

  • trunk/run/data/shaders/terrain-pixel.glsl

    r551 r555  
    1919     
    2020    vec4 a = texture2D(alphaMap, coord0); 
     21    vec4 l = texture2D(lightMap, coord0); 
     22     
    2123    vec4 c1 = texture2D(texture1, coord1); 
    2224    vec4 c2 = texture2D(texture2, coord1); 
    2325    vec4 c3 = texture2D(texture3, coord1); 
    24     vec4 l = texture2D(lightMap, coord0); 
    2526     
    2627    float inverse = 1.0f / (a.r + a.g + a.b); 
    …… 
    2829    c2 *= a.g * inverse; 
    2930    c3 *= a.b * inverse; 
    30      
    31     gl_FragColor = (c1 + c2 + c3) * l; 
     31 
     32    gl_FragColor = (c1 + c2 + c3) * (l * 2); 
    3233     
    3334#if defined(SHADOWMAPPING) 

  • trunk/src/defend/FogOfWar.d

    r551 r555  
    55import gen.core.TaskManager; 
    66import gen.rend.Renderer; 
     7import gen.image.Image; 
    78import gen.util.Log; 
    89import gen.util.Sprite; 
    9 import gen.image.Image; 
     10import gen.util.Profiler; 
     11import gen.util.Bind; 
    1012import gen.math.Vector; 
    1113import gen.math.Rectangle; 
    …… 
    3335    void update() 
    3436    { 
    35         auto ratio = vec2.from(lightmap.dimension) / vec2.from(dimension); 
    36         auto scaleToOne = vec2(1.0f / sprite.width, 1.0f / sprite.height); 
    37          
    38         with(renderer) 
    39         { 
    40             setRenderState(RenderState.Blending, true); 
    41             setRenderState(RenderState.ZWrite, false); 
    42             setRenderState(RenderState.DepthTest, false); 
    43          
    44             // Render the visible texture 
    45             orthogonal(visibleBuffer.texture.dimension); 
    46             identity(); 
    47          
    48             setFramebuffer(visibleBuffer); 
    49             clear(); 
     37        profile!("fog of war") 
     38        ({ 
     39            auto ratio = vec2.from(lightmap.dimension) / vec2.from(dimension); 
     40            auto scaleToOne = vec2(1.0f / sprite.width, 1.0f / sprite.height); 
    5041             
    51             setBlendFunc(BlendFunc.One, BlendFunc.One); 
     42            with(renderer) 
     43            { 
     44                setRenderState(RenderState.Blending, true); 
     45                setRenderState(RenderState.ZWrite, false); 
     46                setRenderState(RenderState.DepthTest, false); 
    5247             
    53             foreach(object; gameObjects) 
    54             { 
    55                 if(object.mayBeOrdered) 
     48                // Render the visible texture 
     49                orthogonal(visibleBuffer.texture.dimension); 
     50                identity(); 
     51             
     52                setFramebuffer(visibleBuffer); 
     53                clear(); 
     54                 
     55                setBlendFunc(BlendFunc.One, BlendFunc.One); 
     56                 
     57                foreach(object; gameObjects) 
    5658                { 
    57                     auto ti = object.typeInfo; 
     59                    if(object.mayBeOrdered) 
     60                    { 
     61                        auto ti = object.typeInfo; 
     62                     
     63                        auto sight = object.property(GameObject.Property.Sight); 
     64                        auto scaling = scaleToOne * sight; 
     65                        sprite.scaling = scaling * ratio; 
     66                         
     67                        auto position = (vec2(object.center.x, 
     68                                              dimension.y + object.center.z) - 
     69                                          
     70                                         scaling * sprite.width * 0.5f) * ratio; 
     71                         
     72                        sprite.render(position, circleTexture); 
     73                    } 
     74                } 
    5875                 
    59                     auto sight = object.property(GameObject.Property.Sight); 
    60                     auto scaling = scaleToOne * sight; 
    61                     sprite.scaling = scaling * ratio; 
     76                unsetFramebuffer(visibleBuffer); 
     77                 
     78                // Combine visible texture and lightmap 
     79                setFramebuffer(framebuffer); 
     80                clear(); 
     81                identity(); 
     82                 
     83                { 
     84                    auto shader = Shader.get("data/shaders/combineLightmaps.cfg"); 
     85                    setShader(shader); 
    6286                     
    63                     auto position = (vec2(object.center.x, 
    64                                           dimension.y + object.center.z) - 
    65                                       
    66                                      scaling * sprite.width * 0.5f) * ratio; 
     87                    with(shader) 
     88                    { 
     89                        setUniform("lightmap", 0); 
     90                        setUniform("fogVisible", 1); 
     91                    } 
    6792                     
    68                     sprite.render(position, circleTexture); 
     93                    setTexture(1, visibleBuffer.texture); 
     94                     
     95                    sprite.scaling = vec2.one; 
     96                    sprite.render(vec2.zero, lightmap); 
     97                     
     98                    setShader(null); 
    6999                } 
     100 
     101                unsetFramebuffer(framebuffer); 
     102                 
     103                setRenderState(RenderState.Blending, false); 
     104                setRenderState(RenderState.ZWrite, true); 
     105                setRenderState(RenderState.DepthTest, true); 
    70106            } 
    71              
    72             unsetFramebuffer(visibleBuffer); 
    73              
    74             // Combine visible texture and lightmap 
    75             setFramebuffer(framebuffer); 
    76             clear(); 
    77             identity(); 
    78              
    79             //sprite.render(vec2.zero, lightmap); 
    80              
    81             //setBlendFunc(BlendFunc.SrcAlpha, BlendFunc.OneMinusSrcAlpha); 
    82             //sprite.render(vec2.zero, visibleBuffer.texture); 
    83              
    84             unsetFramebuffer(framebuffer); 
    85              
    86             setRenderState(RenderState.Blending, false); 
    87             setRenderState(RenderState.ZWrite, true); 
    88             setRenderState(RenderState.DepthTest, true); 
    89         } 
    90          
    91         //terrain.lightmapTexture = texture; 
     107        }); 
    92108    } 
    93109 
    94110    // Generate a circle, which can be rendered on the fog of war texture 
    95     Texture generateCircle(vec2i size = vec2i(64, 64), float intensity = 1.5) 
     111    static Texture generateCircle(vec2i size = vec2i(64, 64), float intensity = 1.3) 
    96112    { 
    97113        scope image = new Image(size.tuple, ImageFormat.A); 
    98114        vec2 center = vec2.from(size) / 2.f; 
    99115 
    100         for(uint x = 0; x < size.x; x++) 
    101         { 
    102             for(uint y = 0; y < size.y; y++) 
    103             { 
    104                 auto value = cast(ubyte)clamp((center.x - (center - vec2(x, y)).length()) / center.y * 255.0f * intensity, 0, 255); 
    105                 image.setAlpha(x, y, value); 
    106             } 
    107         } 
     116        for(uint x = 0; x < size.x; x++) for(uint y = 0; y < size.y; y++) 
     117            image.setAlpha(x, y, cast(ubyte)clamp((center.x - (center - vec2(x, y)).length()) / center.y * 255.0f * intensity, 0, 255)); 
    108118         
    109119        return renderer.createTexture(image); 
    …… 
    122132        visibleBuffer = renderer.createFramebuffer(lightmap.dimension); 
    123133        circleTexture = generateCircle(); 
    124         sprite = new Sprite(lightmap.dimension); 
     134        sprite = new Sprite(lightmap.dimension, true); 
    125135         
    126         taskManager.addRepeatedTask(&update, 25); 
     136        taskManager.addRepeatedTask(&update, 15); 
    127137    } 
    128138     
    …… 
    137147    Texture texture() 
    138148    { 
    139         return visibleBuffer.texture; 
     149        //return lightmap; 
     150        return framebuffer.texture; 
    140151    } 
    141152} 

  • trunk/src/defend/Main.d

    r550 r555  
    1818import gen.rend.opengl.Renderer : OGLRenderer; 
    1919import gen.scene.Graph : SceneGraph, sceneGraph; 
    20 import gen.sound.SoundSystem : SoundSystem; 
     20import gen.sound.SoundSystem : SoundSystem, soundSystem; 
    2121import gen.sound.openal.SoundSystem : OALSoundSystem; 
    2222import gen.util.FPS : FPSCounter; 
    …… 
    286286    // Create the sound system 
    287287    logger.info("creating sound system"); 
    288     //soundSystem = new OALSoundSystem(); 
     288    soundSystem = new OALSoundSystem(); 
    289289 
    290290    // Create the scene graph 

  • trunk/src/defend/objects/SceneNode.d

    r551 r555  
    177177        { 
    178178            if(defendConfig.graphics.objects_glow) 
    179                 glowShader = Shader.acquire("data/shaders/modelglow.cfg"); 
     179                glowShader = Shader.acquire("data/shaders/modelGlow.cfg"); 
    180180        } 
    181181         
    …… 
    195195                function(NodeHolder[] nodes, Camera camera) 
    196196                { 
    197                     auto shader = Shader.acquire("data/shaders/modelglow.cfg"); 
     197                    auto shader = Shader.acquire("data/shaders/modelGlow.cfg"); 
    198198                    renderer.setShader(shader); 
    199199                }, 
    …… 
    201201                function 
    202202                { 
    203                     Shader.release(Shader.get("data/shaders/modelglow.cfg")); 
     203                    Shader.release(Shader.get("data/shaders/modelGlow.cfg")); 
    204204                    renderer.setShader(null); 
    205205                     

  • trunk/src/defend/objects/types/Building.d

    r551 r555  
    448448         
    449449        if(status == Status.BuildUp) 
     450        { 
    450451            _sceneNode.scaling = vec3(typeInfo.scale.x, 
    451452                                      typeInfo.scale.y * 0.1f, 
    452453                                      typeInfo.scale.z); 
     454                                       
     455            propertyFactors[GameObject.Property.Sight] = 0.1; 
     456        } 
    453457    } 
    454458 
    …… 
    469473            _sceneNode.scaling = typeInfo.scale; 
    470474            status = Status.Finished; 
     475            propertyFactors[GameObject.Property.Sight] = 1; 
    471476        } 
    472477    } 

  • trunk/src/defend/objects/types/Citizen.d

    r551 r555  
    9898    override OrderError checkOrder(GameObject[] objects, OrderPlaceObject* order) 
    9999    { 
    100         return OrderError.Okay; 
     100        auto ti = gameObjects.getTypeInfo(owner, order.objectType); 
     101         
     102        return ti.isPlaceable(MapPos(order.x, order.y)) ? OrderError.Okay : OrderError.Error; 
    101103    } 
    102104     
    …… 
    109111    { 
    110112        auto owner = objects[0].owner; 
    111          
    112         auto ti = gameObjects.getTypeInfo(owner, order.objectType); 
    113         if(!ti.isPlaceable(MapPos(order.x, order.y))) 
    114             return; 
    115113         
    116114        auto building = cast(Building)gameObjects.localCreate(owner, order.objectType, 
    …… 
    262260                if(building.status != Building.Status.BuildUp) 
    263261                { 
    264                     debug(citizen) 
    265                         trace("building is finished, stopping to build"); 
     262                    debug(gameoobjects) 
     263                        logger.info("building is finished, stopping to build"); 
    266264                     
    267265                    status = Unit.Status.Idle; 
    …… 
    273271                    { 
    274272                        // TODO: uhm, where's logger gone? D: 
    275                         trace("trying to build while not staying nearby a building"); 
     273                        debug(gameoobjects) 
     274                            logger.warn("trying to build while not staying nearby a building"); 
     275                         
    276276                        status = Unit.Status.Idle; 
    277277                    } 
    …… 
    303303                if(resource.whacked) 
    304304                { 
    305                     debug(citizen) 
    306                         trace("resource is whacked, stopping to mine it"); 
     305                    debug(gameoobjects) 
     306                        logger.info("resource is whacked, stopping to mine it"); 
    307307                         
    308308                    status = Unit.Status.Idle; 

  • trunk/src/defend/objects/types/House.d

    r551 r555  
    1919            model = "data/models/house/model.obj"; 
    2020            parentType = "building"; 
    21             dimension = vec2i(4, 6); 
     21            dimension = vec2i(5, 6); 
    2222            posOffset = vec3(2, 0.2, -2.5); 
    2323            scale = vec3(0.4, 0.4, 0.4); 

  • trunk/src/defend/objects/types/Resource.d

    r549 r555  
    66import gen.scene.Graph; 
    77import gen.scene.Node; 
    8 import gen.scene.ModelNode; 
    98 
    109import defend.terrain.Terrain; 
     10import defend.player.Manager; 
    1111import defend.objects.Core; 
    12 import defend.player.Manager; 
     12import defend.objects.SceneNode; 
    1313 
    1414static this() 
    …… 
    8181{ 
    8282protected: 
    83     ModelNode _sceneNode; 
     83    GameObjectModel _sceneNode; 
    8484    ResourceTypeInfo resourceInfo; 
    8585 
    …… 
    9898        amountLeft = resourceInfo.initialAmount; 
    9999         
    100         _sceneNode = new ModelNode(sceneGraph.root, typeInfo.model); 
     100        _sceneNode = new GameObjectModel(sceneGraph.root, typeInfo.model, vec3.one); 
    101101         
    102102        realPos = terrain.getWorldPos(mapPos); 

  • trunk/src/defend/objects/types/Unit.d

    r551 r555  
    1818import gen.scene.ModelNode; 
    1919import gen.rend.Renderer; 
     20import gen.sound.SoundSystem; 
    2021 
    2122import defend.Map; 
    …… 
    157158     
    158159    override void onOrder(GameObject[] objects, OrderMapRightClick* order) 
    159     { 
     160    {   
    160161        // TODO: Group pathfinding 
    161162        iterateObjects(objects, (Unit object) 

  • trunk/src/defend/terrain/Ranges.d

    r507 r555  
    33//float[3] terrainMinRange = [ 0, 5, 12 ]; 
    44//float[3] terrainMaxRange = [ 10, 16, 21 ]; 
    5 float[3] terrainMinRange = [ 0, 1, 15 ]; 
     5float[3] terrainMinRange = [ 0, 1.7, 15 ]; 
    66float[3] terrainMaxRange = [ 2, 16, 21 ]; 

  • trunk/src/gen/gui/Renderer.d

    r541 r555  
    105105         
    106106        glDisable(GL_BLEND); 
    107         renderer.setColor(vec3.one); 
     107        renderer.setColor(vec4.one); 
    108108    } 
    109109} 

  • trunk/src/gen/rend/Renderer.d

    r551 r555  
    435435    Window window(); 
    436436 
    437     /** 
    438      * Temporary 
    439      */ 
    440     void setColor(vec3 color); 
     437    // tmp 
     438    void setColor(vec4 color); 
     439    final void setColor(vec3 color) { setColor(vec4(color.tuple, 1)); } 
    441440     
    442441    /** 

  • trunk/src/gen/rend/opengl/Renderer.d

    r551 r555  
    643643    } 
    644644 
    645     override void setColor(vec3 color) 
    646     { 
    647         glColor3f(color.tuple); 
     645    override void setColor(vec4 color) 
     646    { 
     647        glColor4f(color.tuple); 
    648648    } 
    649649     

  • trunk/src/gen/sound/SoundSystem.d

    r343 r555  
    1313 * May be used by SoundSystem implementations. 
    1414 */ 
    15 template MSoundManager() 
     15template MSoundManager() // TODO: MResource should be used 
    1616{ 
    1717    import gen.sound.data.Wav; 
    …… 
    2525        if(sound is null) 
    2626        { 
     27            logger.info("loading sound from `{}'", file); 
    2728            SoundData data = new WAVSoundData(file); 
    2829             
    …… 
    6263     * Set the listener's position. 
    6364     */ 
    64     void setListenerPosition(float x, float y, float z); 
     65    void setListenerPosition(vec3 v); 
    6566     
    6667    /** 
    6768     * Set the listener's velocity. 
    6869     */ 
    69     void setListenerVelocity(float x, float y, float z); 
     70    void setListenerVelocity(vec3 v); 
    7071     
    7172    /** 
    7273     * Set the listener's orientation. 
    7374     */ 
    74     void setListenerOrientation(float dx, float dy, float dz, float ux, float uy, float uz); 
     75    void setListenerOrientation(vec3 d, vec3 u); 
    7576     
    7677    /** 
    7778     * Play a sound. 
    7879     */ 
     80    void play(char[] file); 
    7981    void play(SoundSource sound); 
    8082} 

  • trunk/src/gen/sound/data/Wav.d

    r343 r555  
    88import gen.sound.data.Data; 
    99 
    10 private align(1) struct RIFFHeader 
     10private extern(C) 
    1111{ 
    12     char[4] riff; 
    13     uint size; 
    14     char[4] format; 
    15 } 
     12    struct RIFFHeader 
     13    { 
     14        char[4] riff; 
     15        uint size; 
     16        char[4] format; 
     17    } 
    1618 
    17 private align(1) struct ChunkHeader 
    18 { 
    19     char[4] type; 
    20     uint size; 
    21 } 
     19   struct ChunkHeader 
     20   { 
     21       char[4] type; 
     22       uint size; 
     23   } 
    2224 
    23 private align(1) struct WaveFormat 
    24 { 
    25     short format; 
    26     short channels; 
    27     uint samples; 
    28     uint bytes; 
    29     short blockalign; 
    30     short bits; 
    31     short size; 
     25    struct WaveFormat 
     26    { 
     27        short format; 
     28        short channels; 
     29        uint samples; 
     30        uint bytes; 
     31        short blockalign; 
     32        short bits; 
     33        short size; 
     34    } 
    3235} 
    3336 
    …… 
    4447    this(char[] name) 
    4548    { 
    46         scope auto file = new FileConduit(name); 
     49        scope file = new FileConduit(name); 
     50        scope(exit) file.close(); 
    4751         
    4852        { 
    4953            RIFFHeader header; 
    5054            file.input.read((cast(void*)&header)[0 .. header.sizeof]); 
     55             
    5156            assert(toLower(header.riff) == "riff"); 
    5257            assert(toLower(header.format) == "wave"); 
     58             
     59            _size = header.size; 
    5360        }    
    5461         
    5562        WaveFormat format; 
     63        bool hasFormat; 
    5664 
    5765        while(true) 
    …… 
    6674                assert(header.size <= format.sizeof); 
    6775                file.input.read((cast(void*)&format)[0 .. header.size]); 
     76                hasFormat = true; 
     77                 
    6878                break; 
    6979                 
    7080            case "data": 
    7181                assert(_data is null); 
     82                assert(hasFormat); 
    7283                 
    7384                _data.alloc(header.size); 
    7485                file.input.read(_data); 
    75                 _size = header.size; 
     86                 
    7687                break; 
    7788                 

  • trunk/src/gen/sound/openal/SoundSystem.d

    r343 r555  
    77 
    88import gen.util.Log; 
     9import gen.math.Vector; 
    910import gen.sound.Buffer; 
    1011import gen.sound.Source; 
    …… 
    3031 
    3132        if(error) 
    32             logger.warn("error: " ~ Integer.toString(error)); 
     33            logger.warn("error: {}", error); 
    3334    } 
    3435 
    …… 
    5051        } 
    5152 
    52         device = alcOpenDevice("DirectSound3D"); 
     53        device = alcOpenDevice(null); 
    5354         
    5455        if(!device) 
    …… 
    8586    override SoundSource createSource(SoundBuffer buffer) 
    8687    { 
    87         if(!initialized) 
     88        if(!initialized || buffer is null) 
    8889            return null; 
    8990 
    …… 
    102103    } 
    103104 
    104     override void setListenerPosition(float x, float y, float z) 
     105    override void setListenerPosition(vec3 v) 
    105106    { 
    106107        if(!initialized) 
    107108            return null; 
    108109 
    109         alListener3f(AL_POSITION, x, y, z); 
     110        alListener3f(AL_POSITION, v.tuple); 
    110111    } 
    111112 
    112     override void setListenerVelocity(float x, float y, float z) 
     113    override void setListenerVelocity(vec3 v) 
    113114    { 
    114115        if(!initialized) 
    115116            return null; 
    116117 
    117         alListener3f(AL_VELOCITY, x, y, z); 
     118        alListener3f(AL_VELOCITY, v.tuple); 
    118119    } 
    119120 
    120     override void setListenerOrientation(float dx, float dy, float dz, float ux, float uy, float uz) 
     121    override void setListenerOrientation(vec3 d, vec3 u) 
    121122    { 
    122123        if(!initialized) 
    123124            return null; 
    124125 
    125         float[] array = [ dx, dy, dz, ux, uy, uz ]; 
     126        float[6] array = [ d.tuple, u.tuple ]; 
    126127 
    127128        alListenerfv(AL_ORIENTATION, array.ptr); 
    128129    } 
    129130 
     131    override void play(char[] file) 
     132    { 
     133        if(!initialized) 
     134            return; 
     135             
     136        play(createSource(getBuffer(file))); // TODO: i r evul GC abuser! 
     137    } 
     138 
    130139    override void play(SoundSource sound) 
    131140    { 
    132         if(!initialized) 
    133             return null; 
     141        if(!initialized || sound is null) 
     142            return; 
    134143 
    135144        alSourcePlay((cast(OALSoundSource)sound).id); 

  • trunk/src/windefend.cbp

    r551 r555  
    182182        <Unit filename="gen\rend\Framebuffer.d" /> 
    183183        <Unit filename="gen\rend\IndexBuffer.d" /> 
    184         <Unit filename="gen\rend\PrimitiveType.d" /> 
    185184        <Unit filename="gen\rend\Renderer.d" /> 
    186185        <Unit filename="gen\rend\Shader.d" />