Hi All
I am trying to reduce GL Calls
Verts 11,000
GL Calls 220
I have a custom game object class with sprite and Box2D members. I create them in my scene class and stick them all in a vector. During update of scene I cycle through the vector and tell the object update.
I was testing with the old Batch Node to try see how can I reduce calls
My cache initialization
cocos2d::CCSpriteFrameCache* cache = cocos2d::CCSpriteFrameCache::sharedSpriteFrameCache();
cache->addSpriteFramesWithFile("test.plist");
cocos2d::CCSpriteBatchNode* sheet = cocos2d::CCSpriteBatchNode::create("test.png");
m_MainLayer->addChild(sheet , 1);
My sprite fucntion call
m_Sprite = cocos2d::Sprite::createWithSpriteFrameName("sprite.png");
Before when i just created 100 agents normal sprites and had them all moving, there was around 220 GL calls.
After i swapped normal sprites for the code above, it still has 220 calls. Nothing changed even though it appears im referencing only one sprite sheet
Any ideas what i am doing wrong ?
If i ignore my custom game class and simple add 100 sprites to my scene in the init function, this does work. It just does not work when using my game class.
Any ideas
Thank s
No need to use CC these are deprecated.
Your custom class what does it look like? What is the header?
Thanks Slack
#ifndef GOBJECT_H
#define GOBJECT_H
// BASIC GADDBOX OBJECT - USED THROUGHOUT THE GADDBOX API - CONCEPT BASED ON THAT OF UNITY GAME ENGINE
#define PTM_RATIO 100
#define RTD_RATIO 57.2957795131
#include "cocos2d.h"
#include "Box2D\Box2D.h"
#include "Settings.h"
#include <string>
class GObject {
public: // PUBLIC FUCNTIONS
// CONSTRUCTOR & DE-CONSTRUCTOR
GObject();
~GObject();
// INITIALIZE OBJECT FUNCTIONS - EMPTY OBJECT(GADDBOX) - SPRITE OBJECT(COCOS2DX) - PHYSICS OBJECTS(BOX2D)
bool init(cocos2d::Vec2 position, cocos2d::Vec2 target, std::string type, std::string tag, float angle, bool parent, cocos2d::Layer* CocosLayer);
bool initSprite(std::string filename, cocos2d::Vec2 anchor, float scale, int GaddBoxLayer, bool UI);
bool initBody(float density, float friction, float restitution, bool isStatic, int group, b2World * world);
// UPDATE FUCNTION HANDLES UPDATING ALL OBJECT TYPE
bool update();
// RETRIEVE REFERENCE & SET CHILDREN OBJECTS
std::vector<GObject*>& getChildren() { return m_Children; };
void setChildren(std::vector<GObject*> objects) { m_Children = objects; };
// SET & GET PARENT OBJECT POINTER
void setParent(GObject* parent) { m_Parent = parent; };
GObject* getParent() { return m_Parent; };
// GET & SET SPRITE TEXTURE POINTER
cocos2d::Sprite* getSprite() { return m_Sprite; };
void setSprite(cocos2d::Sprite* sprite) { m_Sprite = sprite; };
// GET & SET PHYSICS BODY POINTER
b2Body* getBody() { return m_Body; };
void setBody(b2Body* body) { m_Body = body; };
// GET & SET IF OBJECT IS TYPE PARENT (PARENTS ARE EMPTY OBJECTS FOR GUIDING AND CONTROLING GROUPS OF OBJECTS)
bool getIsParent() { return m_IsParent; };
void setIsParent(bool isParent) { m_IsParent = isParent; };
// OBJECTS CAN BE SELECTED OR DE-SELECTED - SELECTED OBJECTS HAVE A CIRCLE OR RECTANGLE OUTLINE
bool getIsSelected() { return m_IsSelected; };
void setIsSelected(bool selected) { m_IsSelected = selected; if (m_IsSelected) { m_Highlight->setOpacity(255); } else { m_Highlight->setOpacity(0); } };
// POSITION INFORMATION
cocos2d::Vec2 getPosition() { return m_Position; }
cocos2d::Vec2& getPositionRef() { return m_Position; }
void setPosition(cocos2d::Vec2 position) { m_Position = position; }
// TARGET INFORMATION
cocos2d::Vec2 getTarget() { return m_Target; }
cocos2d::Vec2& getTargetRef() { return m_Target; }
void setTarget(cocos2d::Vec2 target) { m_Target = target; }
void setLockedTarget(cocos2d::Vec2 target) { m_LockedTarget = target; }
// GET TARGET DISTANCE - RETRIEVES THE DISTANCE REMAINING BETWEEN POSITION AND TARGET
float getTargetDistance();
// VELOCITY INFORMATION & CALCULATION
cocos2d::Vec2 getVelocity() { return m_Velocity; };
void setVelocity(cocos2d::Vec2 velocity) { m_Velocity = velocity; };
void setVelocity();
// GET UNIT VECTOR FROM A POINT & CURRENT LOCATION
cocos2d::Vec3 getUnitVector(cocos2d::Vec2 location, cocos2d::Vec2 target);
cocos2d::Vec3 getAverageUVector3(cocos2d::Vec3 x, cocos2d::Vec3 y, cocos2d::Vec3 z);
// TYPE & TAG INFORMATION
std::string getType() { return m_Type; }
void setType(std::string type) { m_Type = type; }
std::string getTag() { return m_Tag; };
void setTag(std::string tag) { m_Tag = tag; }
// GET & SET VIRTUAL GADDBOX LAYER USED ON A SINGLE COCOS2D LAYER
int getGLayer() { return m_GLayer; };
void setGaddBoxLayer(int GaddBoxLayer) { m_GLayer = GaddBoxLayer; };
// GET & SET PHYSCIS COLLISION GROUPING - BOX2D
int getPhyGroup() { return m_PhyGroup; };
void setPhyGroup(int phyGroup) { m_PhyGroup = phyGroup; };
// GET & SET OBJECT MOTION RULE
void setMotion(bool motion) { m_Motion = motion; };
bool getMotion() { return m_Motion; };
// SET IF OBJECT CAN UPDATE
void setUpdate(bool update) { m_Update = update; };
// DEBUG WHEN ACTIVE WILL DISPLAY A BASE PRIMITIVE OBJECT TO REPRESENT THE OBJECTS POSITION & ROTATION
void setDebug(bool active);
void setTest(bool test) { m_Test = test; }; // TESTING PURPOSED FOR BREAKING POINTS
// GET & SET OBJECT SPEED
void setSpeed(float speed) {m_Speed = speed; m_SpeedP = speed;};
float getSpeed() { return m_Speed; };
// GET & SET OBJECT ROTATION / STEER SPEED
void setSteer(float steer) { m_Steer = steer; };
float getSteer() { return m_Steer; };
void setRotation();
// GET & SET OBJECT ANGLE
void setAngle(float angle) { m_Angle = angle; };
float getAngle() { return m_Angle; };
void setNormalAngle(); // NORMALISE ANGLE
// GET & SET OBJECT TARGET ANGLE
void setToAngle(float angle) { m_ToAngle = angle; }
float getToAngle() { return m_ToAngle; };
void setTargetAngle();
float getAbsolute(float x, float y); // RETRIEVE ABSOLUTE DIFFERENCE BETWEEN ANGLE AND TARGET ANGLE
// GET & SET OBJECT REST ANGLE - ANGLE MUST FACE WHEN AT REST
float getRestAngle() { return m_RestAngle; };
void setRestAngle(float angle) { m_RestAngle = angle; };
// GET & SET OBJECT MOVING STATUS
void setMoving(bool moving) { m_Moving = moving; };
float getMoving() { return m_Moving; };
// GET & SET OBJECT IS IN ACTION STATUS - POSSIBLE DEPRECIATED !
void setInAction(bool inAction) { m_InAction = inAction; };
bool getInAction() { return m_InAction; };
// SET & GET HOW MUCH A OBJECT IS WEIGHTED TOWARDS MOVING THE WAY IT IS FACING
void setMotionFacing(float motionFacing) { m_MotionFacing = motionFacing; };
float getMotionFacing() { return m_MotionFacing; };
// SET & GET HAS PLAYERED REACHED TARGET
bool getReached() { return m_Reached; };
void setReached(bool reached) { m_Reached = reached; };
// MEMORY MANAGEMENT - DELETE ME - GADDBOX MAIN CLASS HANDLES THIS IN UPDATE LOOP
void setDeleteMe() { delete this; };
bool getDeleteMe() { return m_DeleteMe; };
// RETRIEVE VECTOR NEIGHBORS OF OBJECTS WITH SPECIFIED DISTANCE FROM AN VECTOR OF OBJECTS
std::vector<GObject*> getNeigbhours(std::vector<GObject*> objects);
std::vector<GObject*> getNeigbhours() { return m_Neigbhours; };
cocos2d::Vec2 getCenterPoint(std::vector<GObject*> objects);
float getNeigbhourDistance() { return m_NeigbhourDistance; };
// SET & GET FOLLOW
void setFollow(bool follow) { m_Follow = follow; };
bool getFollow() { return m_Follow; };
// GET & SET ALLOW ROTATE
bool getRotate() { return m_Rotate; };
void setRotate(bool rotate) { m_Rotate = rotate; };
// GET & SET SERIUAL ID
int getSerialID() { return m_SerialID; };
void setSerialID(int serialID) { m_SerialID = serialID; };
void explosion();
void generateTarget();
bool inCircle(cocos2d::Vec2 point, cocos2d::Vec2 center, float radius);
void setIsLocked(bool locked) { m_IsLocked = locked; };
private: // MEMEBER VARIABLES
cocos2d::Layer* m_CocosLayer;
cocos2d::Sprite* m_Sprite;
cocos2d::Size m_Size;
cocos2d::DrawNode* m_DebugNode;
cocos2d::DrawNode* m_Highlight;
cocos2d::DrawNode* m_Control;
cocos2d::DrawNode* m_Dot;
b2FixtureDef m_BodyFixture;
b2BodyDef m_BodyDef;
b2Body* m_Body;
b2CircleShape m_Shape;
float32 m_AngularVelocity;
enum m_Category {
BOUNDARY = 0x0001,
PLAYER = 0x0002,
ENEMY = 0x0004,
BULLET = 0x0008,
MINE = 0x0010,
ASTEROID = 0x0011
};
GObject* m_Parent;
Settings* m_Settings;
std::vector<GObject*> m_Children;
std::vector<GObject*>::iterator m_Children_Iter;
std::vector<GObject*> m_Neigbhours;
std::string m_Type;
std::string m_Tag;
cocos2d::Vec2 m_Position;
cocos2d::Vec2 m_Target;
cocos2d::Vec2 m_LockedTarget;
cocos2d::Vec2 m_SearchTarget;
cocos2d::Vec3 m_UnitVector;
cocos2d::Vec3 m_AUnitVector;
cocos2d::Vec3 m_CUnitVector;
cocos2d::Vec3 m_SUnitVector;
cocos2d::Vec2 m_Velocity;
int m_GLayer;
int m_PhyGroup;
int m_SerialID;
int m_SceneWidth;
float m_Scale;
float m_ToAngle;
float m_Angle;
float m_RestAngle;
float m_Speed;
float m_SpeedP;
float m_Steer;
float m_MotionFacing; // HOW MUCH MOTION HAS TO BE FACING 0.0(NONE) - 1.0(FULL)
float m_MotionDrift; // HOW MUCH A OBJECT CAN DRIFT WHILE STEERING 0.0(NONE) - 1.0(FULL)
float m_Acceleration; // HOW FAST OBJECT REACHES SPEED 0.0(NONE) - 1.0(FULL)
float m_TargetReach;
float m_Difference;
float m_NeigbhourDistance;
float m_Health;
float m_ExplosionHeight;
bool m_VelocitySet;
bool m_IsSelected;
bool m_Moving;
bool m_InAction;
bool m_IsSprite;
bool m_IsBody;
bool m_Motion;
bool m_Rotate;
bool m_Test;
bool m_ClockWise;
bool m_Update;
bool m_Reached;
bool m_InitUpdate;
bool m_UI;
bool m_Node;
bool m_Debug;
bool m_IsParent;
bool m_IsGhostBody;
bool m_DeleteMe;
bool m_Follow; // INHERIT UNIT VECTOR
bool m_IsFacing;
bool m_IsBullet;
bool m_IsEnemy;
bool m_IsLocked;
};
#endif // DEFINE - GOBJECT_H
For the moment I am using a std::map<MyGameObject*, Sprite*> m_GamneObjects;
I can update my game object each update and tell sprite be where game object says
You need to extend a Cocos2d-x class that supports batching to get it auto-batched.
Yes I was trying this. Do you mean make my Game Object inherit Sprite
Example
class GameObject : publin cocos2d::Sprite {
}
Correct ?
yes, this is what I mean. and I hope you free typed that code…publin -> public
1 Like
Indeed . i prefer to use the publin syntax 
1 Like
