Changeset 580

Show
Ignore:
Timestamp:
05/27/08 07:13:03 (8 months ago)
Author:
LeoD
Message:

--

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/src/defend/Camera.d

    r576 r580  
    112112    } 
    113113 
    114     void collision() 
     114    void checkCollision() 
    115115    { 
    116116        if(pos.z < -cast(int)terrain.dimension.y + 18) 
    117117            pos.z = -cast(int)terrain.dimension.y + 18; 
    118118 
    119         if(pos.z >= 3) 
    120             pos.z = 3; 
     119        if(pos.z >= 0) 
     120            pos.z = 0; 
    121121 
    122122        if(pos.x <= 0) 
    …… 
    126126            pos.x = terrain.dimension.x - 18; 
    127127 
    128         auto tempPos = pos; 
    129  
    130         if(tempPos.z > 0) 
    131             tempPos.z = 0; 
    132  
    133         auto rayDown = Ray!(float)(vec3(tempPos.x, 10_000, tempPos.z), 
    134                                    vec3(0, -1, 0)); 
     128        auto rayDown = Ray!(float)(vec3(pos.x, 10_000, pos.z), vec3(0, -1, 0)); 
    135129 
    136130        terrain.iteratePatches( 
    137131        (TerrainPatch patch)  
    138132        { 
    139             if(tempPos.x >= patch.area.left && 
    140                tempPos.x < patch.area.right && 
    141                -tempPos.z >= patch.area.top && 
    142                -tempPos.z < patch.area.bottom) 
     133            if(pos.x >= patch.area.left && 
     134               pos.x < patch.area.right && 
     135               -pos.z >= patch.area.top && 
     136               -pos.z < patch.area.bottom) 
    143137            { 
    144138                float t, u, v; 
    …… 
    167161    } 
    168162 
    169     void matrices() 
     163    void calcMatrices() 
    170164    { 
    171165        float sinyaw = sin(yaw); 
    …… 
    250244        void update() 
    251245        { 
    252             collision(); 
    253             matrices(); 
     246            checkCollision(); 
     247            calcMatrices(); 
    254248        } 
    255249 

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

    r579 r580  
    2626private: 
    2727    Model model; 
     28    ModelInstance modelInstance; 
     29     
    2830    vec3 color; 
    2931    bool isNeutral; 
    …… 
    3335    void calcBoundingBox() 
    3436    { 
    35         bbox = model.boundingBox; 
     37        //bbox = model.boundingBox; 
    3638 
    3739        bbox.min *= scaling; 
    …… 
    5254         
    5355        model = Model.acquire(file); 
     56        modelInstance = model.createInstance(); 
     57         
    5458        this.color = color; 
    5559        this.isNeutral = isNeutral; 
    …… 
    6367    ~this() 
    6468    { 
     69        model.freeInstance(modelInstance); 
    6570        Model.release(model); 
    6671    } 
    …… 
    6873    override void update() 
    6974    { 
    70         if(recalcModelview) 
    71            calcBoundingBox();  
     75        bbox = modelInstance.boundingBox; 
     76        calcBoundingBox();  
    7277    } 
    7378     
    …… 
    7580    { 
    7681        visible = camera.frustum.boundingBoxVisible(bbox) && !fogOfWarCulled; 
     82         
     83        debug if(sceneGraph.debugNodeVisible(this)) 
     84            sceneGraph.addToRender(RenderPass.Debug, this); 
     85    } 
     86     
     87    debug override void render() 
     88    { 
     89        renderer.pushMatrix(); 
     90        //renderer.mulMatrix(absoluteModelview); 
     91        renderer.drawBoundingBox(bbox, vec3(1, 0, 1)); 
     92        renderer.popMatrix(); 
    7793    } 
    7894     
    …… 
    8096    { 
    8197        return bbox; 
     98    } 
     99     
     100    void setAnimation(char[] name) 
     101    { 
     102        modelInstance.setAnimation(name); 
    82103    } 
    83104} 
    …… 
    92113    version(GlowTest) Shader glowShader; 
    93114     
    94     static int renderPassNormal; 
    95     static int renderPassNormalBlended; 
    96     static int renderPassShadowMap; 
    97     version(GlowTest) static int renderPassGlow = -1; 
     115    static render_pass_t renderPassNormal; 
     116    static render_pass_t renderPassNormalBlended; 
     117    static render_pass_t renderPassShadowMap; 
     118    version(GlowTest) static render_pass_t renderPassGlow = -1; 
    98119     
    99120    static void setupRender(bool isNeutral) 
    100121    { 
    101         renderer.setRenderState(RenderState.BackfaceCulling, true); 
     122        //renderer.setRenderState(RenderState.BackfaceCulling, true); 
    102123         
    103124        auto shader = Shader.acquire(isNeutral ? "model-neutral.cfg" : "model.cfg"); 
    …… 
    126147    static void finishRender(bool isNeutral) 
    127148    { 
    128         renderer.setRenderState(RenderState.BackfaceCulling, false); 
     149        //renderer.setRenderState(RenderState.BackfaceCulling, false); 
    129150     
    130151        Shader.release(Shader.get(isNeutral ? "model-neutral.cfg" : "model.cfg")); 
    …… 
    203224            } 
    204225        ); 
     226    } 
     227     
     228    void renderMesh() 
     229    { 
     230        parent.modelInstance.render(mesh); 
    205231    } 
    206232 
    …… 
    305331            shader.setUniform("modelTransform", absoluteModelview); 
    306332         
    307         mesh.render(); 
     333        renderMesh(); 
    308334 
    309335        renderer.popMatrix(); 
    …… 
    318344        renderer.setShader(null); 
    319345         
    320         mesh.render(); 
     346        renderMesh(); 
    321347         
    322348        renderer.popMatrix(); 
    …… 
    333359        glowShader.setUniform("diffuseTexture", 0); 
    334360         
    335         mesh.render(); 
     361        renderMesh(); 
    336362         
    337363        renderer.popMatrix();    
    …… 
    340366    void renderDebug() 
    341367    { 
    342         renderer.pushMatrix(); 
     368        /+renderer.pushMatrix(); 
    343369        renderer.mulMatrix(absoluteModelview); 
    344370        renderer.drawBoundingBox(mesh.boundingBox, vec3(1, 0, 1)); 
    345         renderer.popMatrix(); 
     371        renderer.popMatrix();+/ 
    346372    } 
    347373} 

  • trunk/src/defend/sim/obj/Sheep.d

    r579 r580  
    2424        with(ti) 
    2525        { 
    26             model = "sheep/low.obj"; 
     26            //model = "sheep/low.obj"; 
     27            model = "sydney/sydney.cfg"; 
    2728            miniPic = "minipics/sheep.png"; 
    2829            parentType = "unit"; 
    2930            posOffset = vec3(0, 1, 0); 
    30             scale = vec3.one; 
     31            scale = vec3(0.035, 0.035, 0.035); 
     32            normRotation = vec3(1.6, -1.6, 0); 
    3133            developmentSteps = 18; 
    3234            properties[GameObject.Property.MaxLife] = objProp(500); 

  • trunk/src/defend/sim/obj/Unit.d

    r573 r580  
    7878class UnitTypeInfo : BaseTypeInfo 
    7979{ 
     80    vec3 normRotation = vec3.zero; 
     81 
    8082    // Time needed for development (in simulation steps) 
    8183    uint developmentSteps = 30; 
    …… 
    186188                    pause = 20; 
    187189                    path = null; 
     190                 
     191                    sceneNode.setAnimation("stand"); 
    188192                 
    189193                    debug(gameobjects) logger.spam("tile occupied; taking a break of {} steps", movePause); 
    …… 
    289293    void moveFinished() 
    290294    { 
     295        sceneNode.setAnimation("stand"); 
     296     
    291297        direction = finalDirection; 
    292298        status = Status.Idle; 
    …… 
    407413                if(!checkCollision(path[0])) 
    408414                { 
     415                    sceneNode.setAnimation("run"); 
     416                 
    409417                    status = Status.Moving; 
    410418                 
    …… 
    416424            } 
    417425            else 
     426            { 
     427                sceneNode.setAnimation("stand"); 
    418428                debug(gameobjects) logger.spam("no path found"); 
     429            } 
    419430        } 
    420431         
    …… 
    603614        sceneNode.translation = realPos + unitInfo.posOffset; 
    604615        sceneNode.scaling = unitInfo.scale; 
     616        sceneNode.setAnimation("stand"); 
    605617    } 
    606618     
    …… 
    646658     
    647659        sceneNode.translation = realPos + unitInfo.posOffset; 
    648          
    649         debug(gameobjects) 
    650         { 
    651             if(!direction.ok) 
    652                 logger.warn("direction is a nan"); 
    653         } 
    654          
    655         sceneNode.rotation(direction); 
     660        sceneNode.rotation = direction + unitInfo.normRotation; 
    656661    } 
    657662 
    …… 
    786791    } 
    787792     
    788     override ModelNode sceneNode() 
     793    override GameObjectModel sceneNode() 
    789794    { 
    790795        return _sceneNode; 

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

    r576 r580  
    6969        with(gameObjects) 
    7070        { 
    71             localCreate(cast(player_id_t)0, "house", 30, 30); 
     71            localCreate(cast(player_id_t)0, "house", 30, 30);            
     72            localCreate(cast(player_id_t)0, "sheep", 32, 29); 
    7273             
    7374            if(players.isPlayer(cast(player_id_t)1)) 
    …… 
    7677            //  localCreate(cast(player_id_t)0, "house", 40, 30); 
    7778             
    78             for(int i = 0; i < 50; i++) 
     79            version(none) for(int i = 0; i < 50; i++) 
    7980            { 
    8081                auto ti = getTypeInfo(NEUTRAL_PLAYER, "wood"); 

  • trunk/src/gen/math/BoundingBox.d

    r578 r580  
    4343        min.z = .min(min.z, point.z); 
    4444         
    45         center = (min + max) * 0.5; 
     45        //center = (min + max) * 0.5; 
    4646    } 
    4747     

  • trunk/src/gen/model/Mesh.d

    r541 r580  
    1414import gen.rend.PrimitiveType; 
    1515 
     16class ModelInstance 
     17{ 
     18    BoundingBox!(float) boundingBox; 
     19 
     20    this() 
     21    { 
     22 
     23    } 
     24 
     25    void render(Mesh mesh) 
     26    { 
     27        mesh.render(); 
     28    } 
     29 
     30    void setAnimation(char[] name) { } 
     31    void stopAnimation() { } 
     32} 
     33 
    1634class Mesh 
    1735{ 
    1836    mixin MAllocator; 
    1937     
     38    VertexArray vertices; 
     39    IndexBuffer indices; 
     40    Texture texture; 
     41    PrimitiveType type; 
     42    BoundingBox!(float) boundingBox; 
     43 
     44    ~this() 
     45    { 
     46        delete vertices; 
     47        delete indices; 
     48         
     49        if(texture) Texture.release(texture); 
     50    } 
     51     
     52    final void calcNormals() 
     53    { 
     54        assert(vertices !is null); 
     55        assert(indices is null); 
     56         
     57        for(uint i = 0; i < vertices.length; i += 3) 
     58        { 
     59            auto v1 = vertices.getVertexT!(Vertex)(i); 
     60            auto v2 = vertices.getVertexT!(Vertex)(i + 1); 
     61            auto v3 = vertices.getVertexT!(Vertex)(i + 2); 
     62 
     63            auto normal = vec3.cross((v2.position - v1.position), 
     64                                     (v3.position - v1.position)).normalized(); 
     65            v1.normal = v2.normal = v3.normal = normal; 
     66             
     67            vertices.setVertex(cast(int)i, *v1); 
     68            vertices.setVertex(cast(int)i + 1, *v2); 
     69            vertices.setVertex(cast(int)i + 2, *v3); 
     70        } 
     71         
     72        vertices.synchronize(); 
     73    } 
     74     
     75    void render() 
     76    { 
     77        renderer.setTexture(0, texture); 
     78        renderer.draw(vertices, indices, type); 
     79    } 
     80 
    2081    struct Vertex 
    2182    { 
    …… 
    43104        } 
    44105    } 
    45      
    46     VertexArray vertices; 
    47     IndexBuffer indices; 
    48     Texture texture; 
    49     PrimitiveType type; 
    50     BoundingBox!(float) boundingBox; 
    51  
    52     ~this() 
    53     { 
    54         delete vertices; 
    55         delete indices; 
    56          
    57         if(texture) Texture.release(texture); 
    58     } 
    59      
    60     void calcNormals() 
    61     { 
    62         assert(vertices !is null); 
    63         assert(indices is null); 
    64          
    65         for(uint i = 0; i < vertices.length; i += 3) 
    66         { 
    67             auto v1 = vertices.getVertexT!(Vertex)(i); 
    68             auto v2 = vertices.getVertexT!(Vertex)(i + 1); 
    69             auto v3 = vertices.getVertexT!(Vertex)(i + 2); 
    70  
    71             auto normal = vec3.cross((v2.position - v1.position), (v3.position - v1.position)).normalized(); 
    72             v1.normal = v2.normal = v3.normal = normal; 
    73              
    74             vertices.setVertex(cast(int)i, *v1); 
    75             vertices.setVertex(cast(int)i + 1, *v2); 
    76             vertices.setVertex(cast(int)i + 2, *v3); 
    77              
    78             //synchronized(Stdout) Stdout("normal: ")(v1.normal).newline; 
    79         } 
    80          
    81         vertices.synchronize(); 
    82     } 
    83      
    84     void render() 
    85     { 
    86         renderer.setTexture(0, texture); 
    87         renderer.draw(vertices, indices, type); 
    88     } 
    89106} 
    90107 

  • trunk/src/gen/model/Model.d

    r501 r580  
    11module gen.model.Model; 
    22 
     3import tango.io.Stdout; 
     4 
     5import gen.math.Vector; 
     6import gen.math.BoundingBox; 
    37import gen.util.Memory; 
    48import gen.util.Resource; 
    5 import gen.math.Vector; 
    6 import gen.math.BoundingBox; 
     9import gen.util.Config; 
    710import gen.model.Mesh; 
    811import gen.model.ModelObj; 
     12import gen.model.ModelMD2; 
    913import gen.rend.Texture; 
    1014import gen.rend.VertexArray; 
    …… 
    1721    Mesh[] _meshes; 
    1822     
     23    ModelInstance function() instanceFactory; 
     24     
     25    static ModelInstance createDefaultInstance() 
     26    { 
     27        return new ModelInstance; 
     28    } 
     29     
    1930    mixin ModelLoaderObj; 
     31    mixin ModelLoaderMD2; 
    2032     
    2133public: 
    …… 
    2941        return new Model(file); 
    3042    } 
    31  
     43     
     44    static Model loadResource(Config config) 
     45    { 
     46        return new Model(config); 
     47    } 
     48     
    3249    this(char[] name) 
    3350    { 
    34         boundingBox.max = vec3(-10_000, -10_000, -10_000); 
    35         boundingBox.min = vec3( 10_000,  10_000,  10_000); 
    36          
     51        instanceFactory = &createDefaultInstance; 
    3752        loadObj(name); 
    38          
    39         foreach(mesh; _meshes) 
    40             mesh.calcNormals(); 
     53    } 
     54     
     55    this(Config config) 
     56    { 
     57        instanceFactory = &createDefaultInstance; 
     58        loadMD2(config); 
    4159    } 
    4260 
    …… 
    5775    } 
    5876     
    59     void render() { foreach(mesh; meshes) mesh.render(); } 
     77    ModelInstance createInstance() 
     78    { 
     79        assert(instanceFactory !is null); 
     80         
     81        auto result = instanceFactory(); 
     82        result.boundingBox = boundingBox; 
     83         
     84        return result; 
     85    } 
     86     
     87    void freeInstance(ModelInstance instance) 
     88    { 
     89        // might use some kind of pool 
     90        delete instance; 
     91    } 
     92     
     93    //void render() { foreach(mesh; meshes) mesh.render(); } 
    6094} 

  • trunk/src/gen/model/ModelObj.d

    r543 r580  
    6161 
    6262            currentMesh.type = faceNumber == 3 ? PrimitiveType.Triangle : PrimitiveType.Quad; 
    63             currentMesh.vertices = renderer.createVertexArray(Mesh.Vertex.format, faceCount[objectIndex], VertexArrayUsage.StaticDraw); 
     63            currentMesh.vertices = renderer.createVertexArray(Mesh.Vertex.format, 
     64                                                              faceCount[objectIndex], 
     65                                                              VertexArrayUsage.StaticDraw); 
    6466            currentMesh.boundingBox.max = vec3(-10_000, -10_000, -10_000); 
    6567            currentMesh.boundingBox.min = vec3( 10_000,  10_000,  10_000); 
    …… 
    271273        } 
    272274 
    273         /+if(path == "data/models/sheep/low.obj") 
    274         { 
    275             scope file = new FileConduit("dump.log", FileConduit.ReadWriteCreate); 
    276             scope(exit) file.close(); 
    277          
    278             for(int i = 0; i < meshes[0].vertices.length; i++) 
    279             { 
    280                 auto vertex = meshes[0].vertices.getVertexT!(Mesh.Vertex)(i); 
    281                 file.output.write(vertex.position.toString()); 
    282                 file.output.write(vertex.texture.toString()); 
    283                 file.output.write(vertex.normal.toString()); 
    284             } 
    285         }+/ 
     275        foreach(mesh; _meshes) 
     276            mesh.calcNormals(); 
    286277         
    287278        foreach(mesh; meshes) 

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

    r528 r580  
    11module gen.rend.VertexArray; 
    22 
    3 enum VertexArrayUsage // Names and descriptions from deadlock 
     3enum VertexArrayUsage 
    44{ 
    55    // The data store contents will be specified once by the application, 

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

    r507 r580  
    6161        if(first * size < firstSet) firstSet = first * size; 
    6262        if(((first + num) * size) > lastSet) lastSet = (first + num) * size; 
    63          
     63 
    6464        copy[first * size .. first * size + num * size] = data[]; 
    6565    } 

  • trunk/src/gen/scene/Graph.d

    r574 r580  
    2222import gen.scene.Camera; 
    2323 
     24alias int render_pass_t; 
     25 
    2426// Standard render passes 
    2527enum RenderPass : int 
    …… 
    6365{ 
    6466    int id; 
    65     int priority; 
     67    int priority; // higher == later 
    6668    BufferedArray!(NodeHolder) nodes; 
    6769     
    …… 
    8486 
    8587    // Render pass types 
    86     int renderPassCounter = RenderPass.max + 1; 
     88    render_pass_t renderPassCounter = RenderPass.max + 1; 
    8789    RenderPassData[] renderPasses; // sorted by priority 
    8890    RenderPassData*[] renderPassRefs; // sorted by id 
    …… 
    109111     
    110112    // Add a render pass type 
    111     int addRenderPass(int priority, 
    112                       void function(NodeHolder[], Camera) setup, 
    113                       void function() clean, 
    114                       int id = -1, 
    115                       Framebuffer framebuffer = null, 
    116                       bool calcDistance = false) 
     113    render_pass_t addRenderPass(int priority, 
     114                                void function(NodeHolder[], Camera) setup, 
     115                                void function() clean, 
     116                                render_pass_t id = -1, 
     117                                Framebuffer framebuffer = null, 
     118                                bool calcDistance = false) 
    117119    out(result) 
    118120    { 
    …… 
    457459 
    458460    // Add a new node which shall be rendered this frame 
    459     void addToRender(int pass, SceneNode node, void delegate() render = null) 
     461    void addToRender(render_pass_t pass, SceneNode node, void delegate() render = null) 
    460462    { 
    461463        assert(cameraData !is null); 

  • trunk/src/gen/scene/MeshNode.d

    r574 r580  
    5656    override void process(Camera camera) 
    5757    { 
    58         sceneGraph.addToRender(mesh.texture.format == ImageFormat.RGBA ? RenderPass.Blended : RenderPass.Solid, this); 
     58        sceneGraph.addToRender(RenderPass.Solid, this); 
    5959    } 
    6060     

  • trunk/src/gen/scene/Node.d

    r561 r580  
    143143         
    144144        _rotation = v; 
    145         matrixRotation = mat4.zRotation(_rotation.z) * mat4.xRotation(_rotation.x) * mat4.yRotation(_rotation.y); 
     145        matrixRotation = mat4.zRotation(_rotation.z) * mat4.yRotation(_rotation.y) * mat4.xRotation(_rotation.x); 
    146146        recalcModelview = true; 
    147147    } 

  • trunk/src/gen/util/Array.d

    r576 r580  
    139139    void fill(T value, uint x, uint y, uint w, uint h) 
    140140    { 
    141         //data[x + y * width .. (x + w) + (y + h) * width] = value; 
     141        data[x + y * width .. (x + w) + (y + h) * width] = value; 
    142142         
    143         foreach(ref x; iterate(x, y, w, h)) 
    144           x = value; 
     143        //foreach(ref x; iterate(x, y, w, h)) 
     144        //    x = value; 
    145145    } 
    146146     

  • trunk/src/gen/util/Statistics.d

    r514 r580  
    5454                          "frustum bsphere checks"[], 
    5555                          "texture changes"[], 
    56                           "shader changes"[])); 
     56                          "shader changes"[], 
     57                          "vertices skinned"[])); 
    5758     
    5859    void render(GuiRenderer renderer, vec2i pos, Font font) 

  • trunk/src/windefend.cbp

    r570 r580  
    175175        <Unit filename="gen\model\Mesh.d" /> 
    176176        <Unit filename="gen\model\Model.d" /> 
     177        <Unit filename="gen\model\ModelMD2.d" /> 
    177178        <Unit filename="gen\model\ModelObj.d" /> 
    178179        <Unit filename="gen\net\tcp\Message.d" /> 

  • trunk/src/xf/omg/core/LinearAlgebra.d

    r551 r580  
    1212} 
    1313 
     14debug = OMG; 
    1415 
    1516 
    …… 
    6162    static if (4 == dim) const static Vector unitW = { x : cscalar!(flt, 0), y : cscalar!(flt, 0), z : cscalar!(flt, 0), w : cscalar!(flt, 1) }; 
    6263     
    63  
    64      
    65      
    66     bool ok() { 
    67         static if (dim >= 1) if (isNaN(x)) return false; 
    68         static if (dim >= 2) if (isNaN(y)) return false; 
    69         static if (dim >= 3) if (isNaN(z)) return false; 
    70         static if (dim >= 4) if (isNaN(w)) return false; 
    71         return true; 
    72     } 
    73      
    74     // :P 
    75     alias ok isOK; 
    76     alias ok isCorrect; 
     64     
     65    debug(OMG) 
     66    { 
     67        bool ok() { 
     68            static if (dim >= 1) if (isNaN(x)) return false; 
     69            static if (dim >= 2) if (isNaN(y)) return false; 
     70            static if (dim >= 3) if (isNaN(z)) return false; 
     71            static if (dim >= 4) if (isNaN(w)) return false; 
     72            return true; 
     73        } 
     74    } 
     75    else 
     76        const bool ok = true; 
     77         
     78        // :P 
     79        alias ok isOK; 
     80        alias ok isCorrect; 
    7781     
    7882