Changeset 541

Show
Ignore:
Timestamp:
05/18/08 06:03:34 (8 months ago)
Author:
LeoD
Message:

switched to OMG

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/src/defend/Camera.d

    r534 r541  
    3030     
    3131    // The modelview matrix 
    32     mat4 _modelview; 
     32    mat4 _modelview = mat4.identity; 
    3333     
    3434    // Projection matrix 
    35     mat4 _projection; 
     35    mat4 _projection = mat4.identity; 
    3636 
    3737    // Input 
    …… 
    160160                    cospitch * cosyaw); 
    161161 
    162         _modelview = mat4(right.x, up.x, dir.x, 0.0, 
     162        _modelview = createMat4(right.x, up.x, dir.x, 0.0, 
    163163                           right.y, up.y, dir.y, 0.0, 
    164164                           right.z, up.z, dir.z, 0.0, 
    165                            -(pos.dot(right)), 
    166                            -(pos.dot(up)), 
    167                            -(pos.dot(dir)), 
     165                           -(vec3.dot(pos, right)), 
     166                           -(vec3.dot(pos, up)), 
     167                           -(vec3.dot(pos, dir)), 
    168168                           1.0); 
    169169         

  • trunk/src/defend/Main.d

    r540 r541  
    2525import gen.util.Profiler : profile; 
    2626import gen.util.Wrapper : getTickCount; 
     27import gen.util.HardwareTimer : HardwareTimer; 
    2728import gen.util.Config : Config; 
    28  
    29 import defend.Loop : Loop; 
     29import gen.util.GameState : gameState; 
     30 
    3031import defend.Config : defendConfig, RuntimeException, DEFEND_NAME, DEFEND_VERSION; 
    3132import defend.com.TerrainInfo : TerrainInfo; 
    32 import defend.game.Game : game; 
     33import defend.game.Game : Game; 
    3334import defend.game.Config : GameMode, GameConfig, gameConfig; 
    3435import defend.player.Info : PlayerInfo; 
    35 import defend.demo.Demo : demoFile, demo; 
     36import defend.demo.Demo : demoFile, Demo; 
    3637import defend.objects.Import; 
    3738import defend.objects.Core; 
    …… 
    5051 
    5152    // Print a header to the console 
    52     Stdout.format("{} {} (built {})", DEFEND_NAME, DEFEND_VERSION, __DATE__); 
    53     Stdout.newline; 
    54     Stdout("----------------------------------------------------"); 
    55     Stdout.newline; 
    56     Stdout.newline; 
     53    Stdout.formatln("{} {} (built {})", DEFEND_NAME, DEFEND_VERSION, __DATE__); 
    5754 
    5855    // Load the config 
    …… 
    208205            "  --host=HOST\t\tconnect to HOST\n" 
    209206            "  --port=PORT\t\tset the port for multiplayer\n" 
    210             "  --player-count\tnumber of players which have to connect to the server\n"; 
     207            "  --player-count\tnumber of players which have to connect to the server"; 
    211208             
    212209            Stderr.newline; 
    …… 
    220217        { 
    221218        case GameStateType.Demo: 
     219            //assert(false); 
     220         
    222221            logger.info("playing demo `{}'", demoFile); 
    223222         
    …… 
    226225             
    227226            .demoFile = demoFile; 
    228             Loop.setMainFunction!(demo); 
     227            //Loop.setMainFunction!(demo); 
     228            gameState.change(new Demo); 
    229229             
    230230            break; 
    …… 
    239239             
    240240            .gameConfig = gameConfig; 
    241             Loop.setMainFunction!(game); 
     241            //Loop.setMainFunction!(game); 
     242            gameState.change(new Game); 
    242243        } 
    243244    } 
    …… 
    293294    logger.info("starting main loop"); 
    294295 
    295     Loop(); 
     296    //Loop(); 
     297     
     298    // Main loop 
     299    { 
     300        HardwareTimer timer; 
     301        uint frameTime; 
     302         
     303        while(!gameState.exit) 
     304        { 
     305            timer.start(); 
     306             
     307            InputChannel.global.dispatch(); 
     308             
     309            //Stdout(frameTime).newline; 
     310            taskManager.update(cast(double)frameTime * 0.000001); 
     311 
     312            FPSCounter.update(); 
     313             
     314            Thread.yield(); 
     315             
     316            timer.stop(); 
     317            frameTime = timer.microseconds(); 
     318        } 
     319    } 
     320     
     321    gameState.shutdown; 
    296322 
    297323    logger.info("program execution finished normally"); 

  • trunk/src/defend/Map.d

    r534 r541  
    7373    void copyTiles() 
    7474    { 
    75         foreach(x, y; size) 
    76         { 
    77             auto tile = getTile(x, y); 
    78             tile.height = terrain.getHeight(x, y); 
    79             tile.pos = MapPos(x, y); 
    80  
    81             if(tile.height < .3) 
    82                 tile.type = 0; 
    83             else if(tile.height < .7) 
    84                 tile.type = 1; 
    85             else 
    86                 tile.type = 2; 
     75        for(uint x = 0; x < size.x; x++) 
     76        { 
     77            for(uint y = 0; y < size.y; y++) 
     78            { 
     79                auto tile = getTile(x, y); 
     80                tile.height = terrain.getHeight(x, y); 
     81                tile.pos = MapPos(x, y); 
     82 
     83                if(tile.height < .3) 
     84                    tile.type = 0; 
     85                else if(tile.height < .7) 
     86                    tile.type = 1; 
     87                else 
     88                    tile.type = 2; 
     89            } 
    8790        } 
    8891    } 
    …… 
    9093    void calculateTileCosts() 
    9194    { 
    92         foreach(x, y; size) 
    93         { 
    94             auto tile = getTile(x, y); 
    95             float variance = 0; 
    96             uint count = 0; 
    97  
    98             void calcTileCost(MapPos neighbor) 
    99             { 
    100                 ++count; 
    101                 auto neighborTile = getTile(neighbor); 
    102                 final temp = neighborTile.height - 
    103                                 tile.height; 
    104                 variance += temp * temp; 
    105             } 
    106  
    107             foreach(neighbor; possibleNeighbors(x, y)) 
    108             { 
    109                 if(terrain.within(neighbor)) 
    110                     calcTileCost(neighbor); 
    111  
    112             } 
    113  
    114             assert(count > 0); 
    115  
    116             variance /= cast(float)count; 
    117             tile.cost = variance + 0.1; 
    118  
    119             if(tile.cost > 1) 
    120                 tile.cost = 1; 
    121  
    122             if(tile.cost < .5) 
    123                 tile.walkable = true; 
    124             else 
    125                 tile.walkable = false; 
     95        for(uint x = 0; x < size.x; x++) 
     96        { 
     97            for(uint y = 0; y < size.y; y++) 
     98            { 
     99                auto tile = getTile(x, y); 
     100                float variance = 0; 
     101                uint count = 0; 
     102 
     103                void calcTileCost(MapPos neighbor) 
     104                { 
     105                    ++count; 
     106                    auto neighborTile = getTile(neighbor); 
     107                    final temp = neighborTile.height - 
     108                                    tile.height; 
     109                    variance += temp * temp; 
     110                } 
     111 
     112                foreach(neighbor; possibleNeighbors(x, y)) 
     113                { 
     114                    if(terrain.within(neighbor)) 
     115                        calcTileCost(neighbor); 
     116 
     117                } 
     118 
     119                assert(count > 0); 
     120 
     121                variance /= cast(float)count; 
     122                tile.cost = variance + 0.1; 
     123 
     124                if(tile.cost > 1) 
     125                    tile.cost = 1; 
     126 
     127                if(tile.cost < .5) 
     128                    tile.walkable = true; 
     129                else 
     130                    tile.walkable = false; 
     131            } 
    126132        } 
    127133    } 
    …… 
    142148        bool changed = true; 
    143149 
    144         foreach(x, y; size) 
    145         { 
    146             getTile(x, y).set = counter++; 
     150        for(uint x = 0; x < size.x; x++) 
     151        { 
     152            for(uint y = 0; y < size.y; y++) 
     153            { 
     154                getTile(x, y).set = counter++; 
     155            } 
    147156        } 
    148157 
    …… 
    165174            changed = false; 
    166175 
    167             foreach(x, y; size) 
    168             { 
    169                 auto tile = getTile(x, y); 
    170  
    171                 if(tile.walkable) 
    172                     setSet(tile); 
     176            for(uint x = 0; x < size.x; x++) 
     177            { 
     178                for(uint y = 0; y < size.y; y++) 
     179                { 
     180                    auto tile = getTile(x, y); 
     181 
     182                    if(tile.walkable) 
     183                        setSet(tile); 
     184                } 
    173185            } 
    174186        } 

  • trunk/src/defend/demo/Demo.d

    r512 r541  
    1212import gen.scene.Graph; 
    1313import gen.scene.MeshNode; 
     14import gen.util.GameState; 
    1415 
    1516import defend.Map; 
    …… 
    2728char[] demoFile; 
    2829 
    29 void demo() 
     30class Demo : GameState 
    3031{ 
    3132    DemoPlayer demoPlayer; 
    …… 
    5657    } 
    5758 
    58     demoPlayer = new DemoPlayer(demoFile); 
    59     demoPlayer.TerrainInformation.connect(&onTerrainInformation); 
     59    void init() 
     60    { 
     61        demoPlayer = new DemoPlayer(demoFile); 
     62        demoPlayer.TerrainInformation.connect(&onTerrainInformation); 
    6063 
    61     players = new PlayerManager(demoPlayer); 
    62     simulation = new Simulation(demoPlayer); 
    63      
    64     gameObjects = new GameObjectManager(demoPlayer, players, simulation); 
     64       players = new PlayerManager(demoPlayer); 
     65       simulation = new Simulation(demoPlayer); 
     66        
     67       gameObjects = new GameObjectManager(demoPlayer, players, simulation); 
    6568 
    66     camera = new MainCamera; 
    67     camera.projection = mat4.projection(renderer.config.aspect, 45.0, 1.0, 100.0); 
    68     sceneGraph.addCamera("main", camera, vec3(0, 0, 0)); 
     69       camera = new MainCamera; 
     70       camera.projection = mat4.perspective(45.0, renderer.config.aspect, 1.0, 100.0); 
     71       sceneGraph.addCamera("main", camera, vec3.zero); 
    6972 
    70     MeshNode.memoryPool.create(20); 
     73       MeshNode.memoryPool.create(20); 
    7174 
    72     demoPlayer.init(); 
    73     assert(terrain !is null); 
     75       demoPlayer.init(); 
     76       assert(terrain !is null); 
    7477 
    75     taskManager.addRepeatedTask(&InputChannel.global.update, 100); 
    76     taskManager.addRepeatedTask(&gameObjects.update, 30); 
    77     taskManager.addRepeatedTask(&sceneGraph.update, 60); 
    78     taskManager.addRepeatedTask(&renderer.window.update, 60); 
    79     taskManager.addPostFrameTask(&render); 
     78        taskManager.addRepeatedTask(&InputChannel.global.update, 100); 
     79        taskManager.addRepeatedTask(&gameObjects.update, 30); 
     80        taskManager.addRepeatedTask(&sceneGraph.update, 60); 
     81        taskManager.addRepeatedTask(&renderer.window.update, 60); 
     82        taskManager.addPostFrameTask(&render); 
     83    } 
    8084 
    81     Fiber.yield(); 
     85    void done() 
     86    { 
     87        delete demoPlayer; 
     88        delete gameObjects; 
     89        delete players; 
     90        delete map; 
    8291 
    83     delete demoPlayer; 
    84     delete gameObjects; 
    85     delete players; 
    86     delete map; 
     92        sceneGraph.reset(); 
    8793 
    88     sceneGraph.reset(); 
    89  
    90     MeshNode.memoryPool.release(); 
     94        MeshNode.memoryPool.release(); 
     95    } 
    9196} 

  • trunk/src/defend/demo/Player.d

    r471 r541  
    2020private: 
    2121    FileConduit file; 
    22     float _speed = 1; 
     22    float _speed = 20; 
    2323 
    2424    ubyte[] dataBuffer; 

  • trunk/src/defend/game/Game.d

    r540 r541  
    3535import gen.util.Wrapper; 
    3636import gen.util.FPS; 
     37import gen.util.GameState; 
    3738 
    3839import defend.Camera; 
    3940import defend.Map; 
    4041import defend.MapGenerator; 
    41 import defend.Loop; 
    4242import defend.com.Gateway; 
    4343import defend.Config; 
    …… 
    5555import gen.scene.ModelNode; 
    5656 
    57 /*scope align(1) static public private package package package export export*/ void game() 
     57class Game : GameState 
    5858{ 
    5959    Logger logger; 
    …… 
    120120    void initShadowMapping() 
    121121    { 
    122         auto size = defendConfig("graphics")("shadowmapping").integer("size"); 
     122        auto size = defendConfig.graphics.shadowmapping.size; 
    123123        auto fb = renderer.createFramebuffer(vec2i(size, size), ImageFormat.A); 
    124124         
    125125        auto camera = new StaticCamera(vec3(-20, 40, -39), vec3(-0.9, -1.57, 0), 
    126                                        mat4.projection(1, 70, 50, 200)); 
    127  
    128         sceneGraph.addCamera("shadow", camera, vec3(0), fb, true); 
     126                                       mat4.perspective(70, 1, 50, 200)); 
     127 
     128        sceneGraph.addCamera("shadow", camera, vec3(0, 0, 0), fb, true); 
    129129    } 
    130130 
    …… 
    142142        /* TODO: Change to another gamestate here, maybe go back 
    143143           to the menu again */ 
    144         Loop.exit = true; 
    145144        gatewayShutdown = true; 
     145        gameState.exit = true; 
    146146    } 
    147147 
    …… 
    258258    } 
    259259     
    260     config = gameConfig; 
    261     logger = Log.getLogger("game"); 
    262      
    263     GC.collect(); 
    264      
    265     logMemoryUsage(); 
    266     logObjectUsage(); 
    267      
    268     // Preallocate objects 
    269     MeshNode.memoryPool.create(2000); 
    270      
    271     // Initialize scene graph 
    272     final aspect = renderer.config.aspect; 
    273     final fov = defendConfig("screen").integer("fov"); 
    274      
    275     mainCamera = new MainCamera; 
    276     mainCamera.projection = mat4.projection(aspect, fov * PI / 180, 1, 300); 
    277     sceneGraph.addCamera("main", mainCamera, vec3(0, 0, 0.2)); 
    278  
    279     if(defendConfig.graphics.shadowmapping.enable) 
    280         initShadowMapping(); 
    281  
    282     logger.info("initializing communication"); 
    283     initPlayerCommunication(); 
    284  
    285     gateway.ready(); 
    286     logger.info("waiting for communication process to finish"); 
    287     while(!startGame) 
    288     { 
    289         gateway.update(); 
    290         Thread.yield(); 
    291     } 
    292     logger.info("communication process finished"); 
    293  
    294     // Move the camera to the first object we find 
    295     foreach(object; gameObjects) 
    296     { 
    297         if(object.owner == gateway.id) 
    298         { 
    299             mainCamera.position = terrain.getWorldPos(object.mapPos) + vec3(5, 0, 5); 
    300             break; 
    301         } 
    302     } 
    303  
    304     // Create HUD and mouse 
    305     hud = new HUD(gameObjects); 
    306  
    307     particles = new ParticleSystemManager; 
    308     particles.addSystem("smoke", new SmokeParticleSystem("data/textures/smoke.bmp")); 
    309      
    310     logMemoryUsage(); 
    311      
    312     // Disable the GC 
    313     GC.collect(); 
    314     GC.disable(); 
    315  
    316     // Initialize input 
    317     bool exit = false; 
    318      
    319     keyboard = new KeyboardReader(InputChannel.global); 
    320      
    321     keyboard.keyDownHandlers[KeyType.L] = (KeyboardInput) 
     260    // Input 
     261    void toggleWireframe(KeyboardInput) 
    322262    { 
    323263        wireframe = !wireframe; 
    324     }; 
    325      
    326     keyboard.keyDownHandlers[KeyType.G] = (KeyboardInput) 
     264    } 
     265     
     266    void toggleSceneGraphDebug(KeyboardInput) 
    327267    { 
    328268        sceneGraph.debugVisible = !sceneGraph.debugVisible; 
    329     }; 
    330      
    331     keyboard.keyDownHandlers[KeyType.Escape] = (KeyboardInput) 
    332     { 
    333         Loop.exit = true; 
    334     }; 
    335          
    336     //dumpGCStats(); 
    337      
    338     taskManager.addRepeatedTask(&InputChannel.global.update, 100); 
    339     taskManager.addRepeatedTask(&gameObjects.update, 30); 
    340     taskManager.addRepeatedTask(&sceneGraph.update, 60); 
    341     taskManager.addRepeatedTask(&gateway.update, 10); 
    342     taskManager.addRepeatedTask(&hud.update, 30); 
    343     taskManager.addRepeatedTask(&renderer.window.update, 60); 
    344     taskManager.addRepeatedTask(&particles.update, 20); 
    345     taskManager.addPostFrameTask(&render); 
    346  
    347     // All tasks have been set, let main run the main loop 
    348     Fiber.yield(); 
    349  
    350     taskManager.reset(); 
    351  
    352     logger.info("game shutting down"); 
    353     logMemoryUsage(); 
    354  
    355     if(server !is null) 
    356     { 
    357         logger.info("shutting down server"); 
    358  
    359         server.shutdown(); 
    360     } 
    361  
    362     logger.info("disconnecting gateway"); 
    363     gateway.disconnect(); 
    364  
    365     delete gameObjects; 
    366     delete map; 
    367     delete players; 
    368     delete gateway; 
    369     delete server; 
    370     delete hud; 
    371      
    372     keyboard.remove(); 
    373      
    374     if(demoRecorder) 
    375         delete demoRecorder; 
    376      
    377     sceneGraph.reset(); 
    378     MeshNode.memoryPool.release(); 
    379  
    380     delete particles; 
    381  
    382     GC.enable(); 
    383     GC.collect(); 
    384  
    385     logMemoryUsage(); 
    386     logObjectUsage(); 
    387      
    388     //dumpGCStats(); 
     269    } 
     270     
     271    void inputExit(KeyboardInput) 
     272    { 
     273        gameState.exit = true; 
     274    } 
     275     
     276    override void init() 
     277    { 
     278        config = gameConfig; 
     279        logger = Log.getLogger("game"); 
     280         
     281        GC.collect(); 
     282         
     283        logMemoryUsage(); 
     284        logObjectUsage(); 
     285         
     286        // Preallocate objects 
     287        MeshNode.memoryPool.create(2000); 
     288         
     289        // Initialize scene graph 
     290        mainCamera = new MainCamera; 
     291        mainCamera.projection = mat4.perspective(defendConfig("screen").integer("fov"), 
     292                                                 renderer.config.aspect, 1, 300); 
     293        sceneGraph.addCamera("main", mainCamera, vec3(0, 0, 0.2)); 
     294         
     295        if(defendConfig.graphics.shadowmapping.enable) 
     296            initShadowMapping(); 
     297 
     298        logger.info("initializing communication"); 
     299        initPlayerCommunication(); 
     300 
     301        gateway.ready(); 
     302        logger.info("waiting for communication process to finish"); 
     303        while(!startGame) 
     304        { 
     305            gateway.update(); 
     306            Thread.yield(); 
     307        } 
     308        logger.info("communication process finished"); 
     309 
     310        // Move the camera to the first object we find 
     311        foreach(object; gameObjects) 
     312        { 
     313            if(object.owner == gateway.id) 
     314            { 
     315                mainCamera.position = terrain.getWorldPos(object.mapPos) + vec3(5, 0, 5); 
     316                break; 
     317            } 
     318        } 
     319 
     320        // Create HUD and mouse 
     321        hud = new HUD(gameObjects); 
     322 
     323        particles = new ParticleSystemManager; 
     324        particles.addSystem("smoke", new SmokeParticleSystem("data/textures/smoke.bmp")); 
     325         
     326        logMemoryUsage(); 
     327         
     328        // Disable the GC 
     329        GC.collect(); 
     330        GC.disable(); 
     331 
     332        // Initialize input 
     333        bool exit = false; 
     334         
     335        keyboard = new KeyboardReader(InputChannel.global); 
     336         
     337        keyboard.keyDownHandlers[KeyType.L] = &toggleWireframe; 
     338        keyboard.keyDownHandlers[KeyType.G] = &toggleSceneGraphDebug; 
     339        keyboard.keyDownHandlers[KeyType.Escape] = &inputExit; 
     340             
     341        //dumpGCStats(); 
     342         
     343        taskManager.addRepeatedTask(&InputChannel.global.update, 100); 
     344        taskManager.addRepeatedTask(&gameObjects.update, 30); 
     345        taskManager.addRepeatedTask(&sceneGraph.update, 60); 
     346        taskManager.addRepeatedTask(&gateway.update, 10); 
     347        taskManager.addRepeatedTask(&hud.update, 30); 
     348        taskManager.addRepeatedTask(&renderer.window.update, 60); 
     349        taskManager.addRepeatedTask(&particles.update, 20); 
     350        taskManager.addPostFrameTask(&render); 
     351    } 
     352 
     353    override void done() 
     354    { 
     355        logger.info("game shutting down"); 
     356        logMemoryUsage(); 
     357 
     358        if(server !is null) 
     359        { 
     360            logger.info("shutting down server"); 
     361 
     362            server.shutdown(); 
     363        } 
     364 
     365        logger.info("disconnecting gateway"); 
     366        gateway.disconnect(); 
     367 
     368        delete gameObjects; 
     369        delete map; 
     370        delete players; 
     371        delete gateway; 
     372        delete server; 
     373        delete hud; 
     374         
     375        keyboard.remove(); 
     376         
     377        if(demoRecorder) 
     378            delete demoRecorder; 
     379         
     380        sceneGraph.reset(); 
     381        MeshNode.memoryPool.release(); 
     382 
     383        delete particles; 
     384 
     385        GC.enable(); 
     386        GC.collect(); 
     387 
     388        logMemoryUsage(); 
     389        logObjectUsage(); 
     390         
     391        //dumpGCStats(); 
     392    } 
    389393} 

  • trunk/src/defend/game/hud/Hud.d

    r524 r541  
    9999                { 
    100100                    smallFont.write(guiRenderer, button.widget.globalPosition + vec2i(12, 15), 
    101                                     vec3(1), "{}", index); 
     101                                    vec3(1, 1, 1), "{}", index); 
    102102                } 
    103103            } 
    …… 
    107107            { 
    108108                auto pos = vec2i(240, renderer.height - HUD_HEIGHT + 10 + i * 15); 
    109                 auto color = vec3(1); 
     109                auto color = vec3.one; 
    110110                auto format = "{}: {}"; 
    111111                 
    …… 
    123123                p.y = renderer.height - p.y; 
    124124                 
    125                 smallFont.write(guiRenderer, vec2i(p.x, p.y), vec3(1), "[{}]", obj.id); 
     125                smallFont.write(guiRenderer, vec2i(p.x, p.y), vec3.one, "[{}]", obj.id); 
    126126            } 
    127127        } 
    …… 
    130130    void renderDebugInfo() 
    131131    { 
    132         bigFont.write(guiRenderer, vec2i(10, 10), vec3(1), "FPS: {}", FPSCounter.get()); 
     132        bigFont.write(guiRenderer, vec2i(10, 10), vec3.one, "FPS: {}", FPSCounter.get()); 
    133133         
    134134        debug 

  • trunk/src/defend/game/hud/Mouse.d

    r529 r541  
    420420        auto pt = mouse.mousePos; 
    421421         
    422         auto modelview = camera.modelview().convert!(double); 
    423         auto projection = camera.projection().convert!(double); 
     422        //Stdout(camera.modelview()).newline; 
     423        //Stdout(camera.projection()).newline; 
     424         
     425        auto modelview = mat4d.from(camera.modelview()); 
     426        auto projection = mat4d.from(camera.projection()); 
    424427 
    425428        viewport[2] = renderer.width; 
    …… 
    584587        mouseCube = new ModelNode(sceneGraph.root, "data/models/box/box.obj"); 
    585588         
    586         mouseCube.scaling = vec3(0.05); 
     589        mouseCube.scaling = vec3(0.05, 0.05, 0.05); 
    587590        mouseCube.hide = true; 
    588591        mouseCube.renderShadow = true; 
    …… 
    617620        GLint[4] viewport; 
    618621 
    619         auto modelview = camera.modelview().convert!(double); 
    620         auto projection = camera.projection().convert!(double); 
     622        auto modelview = mat4d.from(camera.modelview()); 
     623        auto projection = mat4d.from(camera.projection()); 
    621624 
    622625        viewport[2] = renderer.width; 

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

    r524 r541  
    3636import defend.objects.Effector; 
    3737 
    38 // TODO: Find a way to split this fucking file into multiple files, without circular imports. 
     38// TODO: Find a way to split this file into multiple files, without circular imports. 
    3939 
    4040// ------------------------------------------------------------------------------------------------ 

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

    r540 r541  
    2727    { 
    2828        bbox = model.boundingBox; 
    29          
     29 
    3030        bbox.min *= scaling; 
    3131        bbox.max *= scaling; 
    …… 
    4747        foreach(mesh; model.meshes) 
    4848            new GameObjectMesh(this, mesh); 
     49             
     50        calcBoundingBox(); 
    4951    } 
    5052     
    …… 
    6264    override void process(Camera camera) 
    6365    { 
     66        //Stdout("check for ")(camera)(" = ")(camera.frustum.boundingBoxVisible(bbox)).newline; 
     67 
    6468        visible = camera.frustum.boundingBoxVisible(bbox); 
    6569    } 
    …… 
    120124            if(defendConfig.graphics.shadowmapping.enable) 
    121125            { 
    122                 shadowCamera = sceneGraph.getCamera("shadow"); 
     126                if(!shadowCamera) 
     127                    shadowCamera = sceneGraph.getCamera("shadow"); 
    123128             
    124129                shader.setUniform("shadowTexture", 2); 
    125                 shader.setUniform("lightTransform", shadowCamera.core.projection * shadowCamera.core.modelview); 
     130                shader.setUniform("lightTransform", shadowCamera.core.projection * 
     131                                                    shadowCamera.core.modelview); 
    126132                shader.setUniform("modelTransform", absoluteModelview); 
    127133                 
    …… 
    142148        else 
    143149        { 
     150            Stdout("ok.").newline; 
     151         
    144152            renderer.setTexture(0, null); 
    145153            renderer.setShader(null); 
    146154        } 
    147155         
    148         //mesh.texture = Texture.loadResource("data/models/house/model.png"); 
    149         //mesh.render(); 
    150         renderer.draw(mesh.vertices, null, mesh.type); 
     156        mesh.render(); 
     157 
     158        debug 
     159        { 
     160            if(sceneGraph.debugNodeVisible(this)) 
     161                renderer.drawBoundingBox(mesh.boundingBox, vec3(1, 0, 1)); 
     162        } 
    151163 
    152164        renderer.popMatrix(); 

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

    r524 r541  
    566566        sceneNode.translation = realPos + buildingInfo.posOffset; 
    567567        sceneNode.scaling = buildingInfo.scale; 
    568         sceneNode.rotation = vec3(0); 
     568        sceneNode.rotation = vec3.zero; 
    569569 
    570570        buildSteps = buildingInfo.buildSteps / 10; 

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

    r521 r541  
    3030            parentType = "unit"; 
    3131            posOffset = vec3(0, 1, 0); 
    32             scale = vec3(1); 
     32            scale = vec3.one; 
    3333            developmentSteps = 18; 
    3434            canBuild = [ "house" ]; 

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

    r521 r541  
    2121            dimension = vec2i(5, 6); 
    2222            posOffset = vec3(2, 0.2, -2.5); 
    23             scale = vec3(0.4); 
     23            scale = vec3(0.4, 0.4, 0.4); 
    2424            buildSteps = 10000; 
    2525            canBuild = [ "sheep", "citizen" ];      

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

    r485 r541  
    3737            model = "data/models/box/box.obj"; 
    3838            posOffset = vec3(0, 0.5, 0); 
    39             scale = vec3(0.5); 
     39            scale = vec3(0.5, 0.5, 0.5); 
    4040            dimension = vec2i(1, 1); 
    4141            initialAmount = 1000; 
    …… 
    124124        sceneNode.translation = realPos + typeInfo.posOffset; 
    125125        sceneNode.scaling = typeInfo.scale; 
    126         sceneNode.rotation = vec3(0); 
     126        sceneNode.rotation = vec3.zero; 
    127127 
    128128        markMap(false); 

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

    r521 r541  
    11module defend.objects.types.Sheep; 
    2  
    3 import tango.io.Stdout; 
    42 
    53import gen.scene.Graph; 
    …… 
    3028            parentType = "unit"; 
    3129            posOffset = vec3(0, 1, 0); 
    32             scale = vec3(1); 
     30            scale = vec3.one; 
    3331            developmentSteps = 18; 
    3432            properties[GameObject.Property.MaxLife] = 500; 

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